Rewrite Futures.

sdk/lib/async/zone.dart

 // Copyright (c) 2013, 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.
 
 part of dart.async;
 
 /**
  * A Zone represents the asynchronous version of a dynamic extent. Asynchronous
  * callbacks are executed in the zone they have been queued in. For example,
  * the callback of a `future.then` is executed in the same zone as the one where
@@ skipping 69 matching lines @@
   void executePeriodicCallbackGuarded(void f());
 
   /**
    * Executes [f] in `this` zone.
    *
    * The behavior of this method should be the same as
    * [executePeriodicCallback] except that it can have a return value.
    *
    * Returns the result of the invocation.
    */
-  runFromChildZone(f());
+  dynamic runFromChildZone(f());
 
   /**
    * Same as [runFromChildZone] but catches uncaught errors and gives them to
    * [handleUncaughtError].
    */
-  runFromChildZoneGuarded(f());
+  dynamic runFromChildZoneGuarded(f());
 
   /**
    * Runs [f] asynchronously in [zone].
    */
   void runAsync(void f(), _Zone zone);
 
   /**
    * Creates a Timer where the callback is executed in this zone.
    */
   Timer createTimer(Duration duration, void callback());
@@ skipping 67 matching lines @@
   }
 
   /**
    * Cleans up this zone when it is done.
    *
    * This releases internal memore structures that are no longer necessary.
    *
    * A zone is done when its dynamic extent has finished executing and
    * there are no outstanding asynchronous callbacks.
    */
-  _dispose() {
+  void _dispose() {
     if (_parentZone != null) {
       _parentZone._removeChild(this);
     }
   }
 
   /**
    * Checks if the zone is done and doesn't have any outstanding callbacks
    * anymore.
    *
    * This method is called when an operation has decremented the
@@ skipping 16 matching lines @@
   }
 
   void executePeriodicCallback(void f()) {
     this._runUnguarded(f);
   }
 
   void executePeriodicCallbackGuarded(void f()) {
     this._runGuarded(f);
   }
 
-  runFromChildZone(f()) => this._runUnguarded(f);
-  runFromChildZoneGuarded(f()) => this._runGuarded(f);
+  dynamic runFromChildZone(f()) => this._runUnguarded(f);
+  dynamic runFromChildZoneGuarded(f()) => this._runGuarded(f);
 
-  _runInZone(f(), bool handleUncaught) {
+  dynamic _runInZone(f(), bool handleUncaught) {
     if (identical(_Zone._current, this)
         && !handleUncaught
         && _isExecutingCallback) {
       // No need to go through a try/catch.
       return f();
     }
 
     _Zone oldZone = _Zone._current;
     _Zone._current = this;
     // While we are executing the function we don't want to have other
@@ skipping 19 matching lines @@
       _Zone._current = oldZone;
       _checkIfDone();
     }
   }
 
   /**
    * Runs the function and catches uncaught errors.
    *
    * Uncaught errors are given to [handleUncaughtError].
    */
-  _runGuarded(void f()) {
+  dynamic _runGuarded(void f()) {
     return _runInZone(f, true);
   }
 
   /**
    * Runs the function but doesn't catch uncaught errors.
    */
-  _runUnguarded(void f()) {
+  dynamic _runUnguarded(void f()) {
     return _runInZone(f, false);
   }
 
-  runAsync(void f(), _Zone zone) => _parentZone.runAsync(f, zone);
+  void runAsync(void f(), _Zone zone) => _parentZone.runAsync(f, zone);
 
   // TODO(floitsch): the zone should just forward to the parent zone. The
   // default zone should then create the _ZoneTimer.
   Timer createTimer(Duration duration, void callback()) {
     return new _ZoneTimer(this, duration, callback);
   }
 
   // TODO(floitsch): the zone should just forward to the parent zone. The
   // default zone should then create the _ZoneTimer.
   Timer createPeriodicTimer(Duration duration, void callback(Timer timer)) {
@@ skipping 12 matching lines @@
 }
 
 /**
  * The default-zone that conceptually surrounds the `main` function.
  */
 class _DefaultZone extends _ZoneBase {
   _DefaultZone() : super._defaultZone();
 
   _Zone get _errorZone => this;
 
-  handleUncaughtError(error) {
+  void handleUncaughtError(error) {
     _scheduleAsyncCallback(() {
       print("Uncaught Error: ${error}");
       var trace = getAttachedStackTrace(error);
       _attachStackTrace(error, null);
       if (trace != null) {
         print("Stack Trace:\n$trace\n");
       }
       throw error;
     });
   }
@@ skipping 15 matching lines @@
 
 /**
  * A zone that executes a callback when the zone is dead.
  */
 class _WaitForCompletionZone extends _ZoneBase {
   final _CompletionCallback _onDone;
 
   _WaitForCompletionZone(_Zone parentZone, this._onDone) : super(parentZone);
 
   /**
-   * Runs the given function asynchronously. Executes the [_onDone] callback
-   * when the zone is done.
+   * Runs the given function.
+   *
+   * Executes the [_onDone] callback when the zone is done.
    */
-  runWaitForCompletion(void f()) {
+  dynamic runWaitForCompletion(void f()) {
     return this._runUnguarded(f);
   }
 
-  _dispose() {
+  void _dispose() {
     super._dispose();
     _onDone();
   }
 
   String toString() => "WaitForCompletion ${super.toString()}";
 }
 
 typedef void _HandleErrorCallback(error);
 
 /**
  * A zone that collects all uncaught errors and provides them in a stream.
  * The stream is closed when the zone is done.
  */
 class _CatchErrorsZone extends _WaitForCompletionZone {
   final _HandleErrorCallback _handleError;
 
   _CatchErrorsZone(_Zone parentZone, this._handleError, void onDone())
       : super(parentZone, onDone);
 
   _Zone get _errorZone => this;
 
-  handleUncaughtError(error) {
+  void handleUncaughtError(error) {
     try {
       _handleError(error);
     } catch(e, s) {
       if (identical(e, s)) {
         _parentZone.handleUncaughtError(error);
       } else {
         _parentZone.handleUncaughtError(_asyncError(e, s));
       }
     }
   }
 
   /**
    * Runs the given function asynchronously. Executes the [_onDone] callback
    * when the zone is done.
    */
-  runWaitForCompletion(void f()) {
+  dynamic runWaitForCompletion(void f()) {
     return this._runGuarded(f);
   }
 
   String toString() => "CatchErrors ${super.toString()}";
 }
 
 typedef void _RunAsyncInterceptor(void callback());
 
 class _RunAsyncZone extends _ZoneBase {
   final _RunAsyncInterceptor _runAsyncInterceptor;
@@ skipping 134 matching lines @@
   if (onError == null && onDone == null) return body();
   if (onError == null) {
     _WaitForCompletionZone zone =
         new _WaitForCompletionZone(_Zone._current, onDone);
     return zone.runWaitForCompletion(body);
   }
   if (onDone == null) onDone = _nullDoneHandler;
   _CatchErrorsZone zone = new _CatchErrorsZone(_Zone._current, onError, onDone);
   return zone.runWaitForCompletion(body);
 }