Make core libraries use generic method syntax.

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;
 
 typedef R ZoneCallback<R>();
 typedef R ZoneUnaryCallback<R, T>(T arg);
 typedef R ZoneBinaryCallback<R, T1, T2>(T1 arg1, T2 arg2);
 
@@ skipping 198 matching lines @@
  *
  * While zones have access to their parent zone (through [Zone.parent]) it is
  * recommended to call the methods on the provided parent delegate for two
  * reasons:
  * 1. the delegate methods take an additional `zone` argument which is the
  *   zone the action has been initiated in.
  * 2. delegate calls are more efficient, since the implementation knows how
  *   to skip zones that would just delegate to their parents.
  */
 abstract class ZoneDelegate {
-  /*=R*/ handleUncaughtError/*<R>*/(
+  R handleUncaughtError<R>(
       Zone zone, error, StackTrace stackTrace);
-  /*=R*/ run/*<R>*/(Zone zone, /*=R*/ f());
-  /*=R*/ runUnary/*<R, T>*/(Zone zone, /*=R*/ f(/*=T*/ arg), /*=T*/ arg);
-  /*=R*/ runBinary/*<R, T1, T2>*/(Zone zone,
-      /*=R*/ f(/*=T1*/ arg1, /*=T2*/ arg2), /*=T1*/ arg1, /*=T2*/ arg2);
-  ZoneCallback/*<R>*/ registerCallback/*<R>*/(Zone zone, /*=R*/ f());
-  ZoneUnaryCallback/*<R, T>*/ registerUnaryCallback/*<R, T>*/(
-      Zone zone, /*=R*/ f(/*=T*/ arg));
-  ZoneBinaryCallback/*<R, T1, T2>*/ registerBinaryCallback/*<R, T1, T2>*/(
-      Zone zone, /*=R*/ f(/*=T1*/ arg1, /*=T2*/ arg2));
+  R run<R>(Zone zone, R f());
+  R runUnary<R, T>(Zone zone, R f(T arg), T arg);
+  R runBinary<R, T1, T2>(Zone zone,
+      R f(T1 arg1, T2 arg2), T1 arg1, T2 arg2);
+  ZoneCallback<R> registerCallback<R>(Zone zone, R f());
+  ZoneUnaryCallback<R, T> registerUnaryCallback<R, T>(
+      Zone zone, R f(T arg));
+  ZoneBinaryCallback<R, T1, T2> registerBinaryCallback<R, T1, T2>(
+      Zone zone, R f(T1 arg1, T2 arg2));
   AsyncError errorCallback(Zone zone, Object error, StackTrace stackTrace);
   void scheduleMicrotask(Zone zone, void f());
   Timer createTimer(Zone zone, Duration duration, void f());
   Timer createPeriodicTimer(Zone zone, Duration period, void f(Timer timer));
   void print(Zone zone, String line);
   Zone fork(Zone zone, ZoneSpecification specification, Map zoneValues);
 }
 
 /**
  * A zone represents an environment that remains stable across asynchronous
@@ skipping 75 matching lines @@
    *   chains, but for which no child registered an error handler.
    *   Most asynchronous classes, like [Future] or [Stream] push errors to their
    *   listeners. Errors are propagated this way until either a listener handles
    *   the error (for example with [Future.catchError]), or no listener is
    *   available anymore. In the latter case, futures and streams invoke the
    *   zone's [handleUncaughtError].
    *
    * By default, when handled by the root zone, uncaught asynchronous errors are
    * treated like uncaught synchronous exceptions.
    */
-  /*=R*/ handleUncaughtError/*<R>*/(error, StackTrace stackTrace);
+  R handleUncaughtError<R>(error, StackTrace stackTrace);
 
   /**
    * The parent zone of the this zone.
    *
    * Is `null` if `this` is the [ROOT] zone.
    *
    * Zones are created by [fork] on an existing zone, or by [runZoned] which
    * forks the [current] zone. The new zone's parent zone is the zone it was
    * forked from.
    */
@@ skipping 80 matching lines @@
    * By default (as implemented in the [ROOT] zone), runs [action]
    * with [current] set to this zone.
    *
    * If [action] throws, the synchronous exception is not caught by the zone's
    * error handler. Use [runGuarded] to achieve that.
    *
    * Since the root zone is the only zone that can modify the value of
    * [current], custom zones intercepting run should always delegate to their
    * parent zone. They may take actions before and after the call.
    */
-  /*=R*/ run/*<R>*/(/*=R*/ action());
+  R run<R>(R action());
 
   /**
    * Executes the given [action] with [argument] in this zone.
    *
    * As [run] except that [action] is called with one [argument] instead of
    * none.
    */
-  /*=R*/ runUnary/*<R, T>*/(/*=R*/ action(/*=T*/ argument), /*=T*/ argument);
+  R runUnary<R, T>(R action(T argument), T argument);
 
   /**
    * Executes the given [action] with [argument1] and [argument2] in this
    * zone.
    *
    * As [run] except that [action] is called with two arguments instead of none.
    */
-  /*=R*/ runBinary/*<R, T1, T2>*/(
-      /*=R*/ action(/*=T1*/ argument1, /*=T2*/ argument2), /*=T1*/ argument1,
-      /*=T2*/ argument2);
+  R runBinary<R, T1, T2>(
+      R action(T1 argument1, T2 argument2), T1 argument1,
+      T2 argument2);
 
   /**
    * Executes the given [action] in this zone and catches synchronous
    * errors.
    *
    * This function is equivalent to:
    * ```
    * try {
    *   return this.run(action);
    * } catch (e, s) {
    *   return this.handleUncaughtError(e, s);
    * }
    * ```
    *
    * See [run].
    */
-  /*=R*/ runGuarded/*<R>*/(/*=R*/ action());
+  R runGuarded<R>(R action());
 
   /**
    * Executes the given [action] with [argument] in this zone and
    * catches synchronous errors.
    *
    * See [runGuarded].
    */
-  /*=R*/ runUnaryGuarded/*<R, T>*/(/*=R*/ action(/*=T*/ argument),
-      /*=T*/ argument);
+  R runUnaryGuarded<R, T>(R action(T argument),
+      T argument);
 
   /**
    * Executes the given [action] with [argument1] and [argument2] in this
    * zone and catches synchronous errors.
    *
    * See [runGuarded].
    */
-  /*=R*/ runBinaryGuarded/*<R, T1, T2>*/(
-      /*=R*/ action(/*=T1*/ argument1, /*=T2*/ argument2), /*=T1*/ argument1,
-      /*=T2*/ argument2);
+  R runBinaryGuarded<R, T1, T2>(
+      R action(T1 argument1, T2 argument2), T1 argument1,
+      T2 argument2);
 
   /**
    * Registers the given callback in this zone.
    *
    * When implementing an asynchronous primitive that uses callbacks, the
    * callback must be registered using [registerCallback] at the point where the
    * user provides the callback. This allows zones to record other information
    * that they need at the same time, perhaps even wrapping the callback, so
    * that the callback is prepared when it is later run in the same zones
    * (using [run]). For example, a zone may decide
    * to store the stack trace (at the time of the registration) with the
    * callback.
    *
    * Returns the callback that should be used in place of the provided
    * [callback]. Frequently zones simply return the original callback.
    *
    * Custom zones may intercept this operation. The default implementation in
    * [Zone.ROOT] returns the original callback unchanged.
    */
-  ZoneCallback/*<R>*/ registerCallback/*<R>*/(/*=R*/ callback());
+  ZoneCallback<R> registerCallback<R>(R callback());
 
   /**
    * Registers the given callback in this zone.
    *
    * Similar to [registerCallback] but with a unary callback.
    */
-  ZoneUnaryCallback/*<R, T>*/ registerUnaryCallback/*<R, T>*/(
-      /*=R*/ callback(/*=T*/ arg));
+  ZoneUnaryCallback<R, T> registerUnaryCallback<R, T>(
+      R callback(T arg));
 
   /**
    * Registers the given callback in this zone.
    *
    * Similar to [registerCallback] but with a unary callback.
    */
-  ZoneBinaryCallback/*<R, T1, T2>*/ registerBinaryCallback/*<R, T1, T2>*/(
-      /*=R*/ callback(/*=T1*/ arg1, /*=T2*/ arg2));
+  ZoneBinaryCallback<R, T1, T2> registerBinaryCallback<R, T1, T2>(
+      R callback(T1 arg1, T2 arg2));
 
   /**
    *  Equivalent to:
    *
    *      ZoneCallback registered = this.registerCallback(action);
    *      if (runGuarded) return () => this.runGuarded(registered);
    *      return () => this.run(registered);
    *
    */
-  ZoneCallback/*<R>*/ bindCallback/*<R>*/(
-      /*=R*/ action(), { bool runGuarded: true });
+  ZoneCallback<R> bindCallback<R>(
+      R action(), { bool runGuarded: true });
 
   /**
    *  Equivalent to:
    *
    *      ZoneCallback registered = this.registerUnaryCallback(action);
    *      if (runGuarded) return (arg) => this.runUnaryGuarded(registered, arg);
    *      return (arg) => thin.runUnary(registered, arg);
    */
-  ZoneUnaryCallback/*<R, T>*/ bindUnaryCallback/*<R, T>*/(
-      /*=R*/ action(/*=T*/ argument), { bool runGuarded: true });
+  ZoneUnaryCallback<R, T> bindUnaryCallback<R, T>(
+      R action(T argument), { bool runGuarded: true });
 
   /**
    *  Equivalent to:
    *
    *      ZoneCallback registered = registerBinaryCallback(action);
    *      if (runGuarded) {
    *        return (arg1, arg2) => this.runBinaryGuarded(registered, arg);
    *      }
    *      return (arg1, arg2) => thin.runBinary(registered, arg1, arg2);
    */
-  ZoneBinaryCallback/*<R, T1, T2>*/ bindBinaryCallback/*<R, T1, T2>*/(
-      /*=R*/ action(/*=T1*/ argument1, /*=T2*/ argument2),
+  ZoneBinaryCallback<R, T1, T2> bindBinaryCallback<R, T1, T2>(
+      R action(T1 argument1, T2 argument2),
       { bool runGuarded: true });
 
   /**
    * Intercepts errors when added programatically to a `Future` or `Stream`.
    *
    * When calling [Completer.completeError], [Stream.addError],
    * or some [Future] constructors, the current zone is allowed to intercept
    * and replace the error.
    *
    * Future constructors invoke this function when the error is received
@@ skipping 105 matching lines @@
 ZoneDelegate _parentDelegate(_Zone zone) {
   if (zone.parent == null) return null;
   return zone.parent._delegate;
 }
 
 class _ZoneDelegate implements ZoneDelegate {
   final _Zone _delegationTarget;
 
   _ZoneDelegate(this._delegationTarget);
 
-  /*=R*/ handleUncaughtError/*<R>*/(
+  R handleUncaughtError<R>(
       Zone zone, error, StackTrace stackTrace) {
     var implementation = _delegationTarget._handleUncaughtError;
     _Zone implZone = implementation.zone;
     HandleUncaughtErrorHandler handler = implementation.function;
     // TODO(floitsch): make this a generic method call on '<R>' once it's
     // supported. Remove the unnecessary cast.
     return handler(
         implZone, _parentDelegate(implZone), zone, error, stackTrace)
         as Object/*=R*/;
   }
 
-  /*=R*/ run/*<R>*/(Zone zone, /*=R*/ f()) {
+  R run<R>(Zone zone, R f()) {
     var implementation = _delegationTarget._run;
     _Zone implZone = implementation.zone;
     RunHandler handler = implementation.function;
     // TODO(floitsch): make this a generic method call on '<R>' once it's
     // supported. Remove the unnecessary cast.
     return handler(implZone, _parentDelegate(implZone), zone, f)
         as Object/*=R*/;
   }
 
-  /*=R*/ runUnary/*<R, T>*/(Zone zone, /*=R*/ f(/*=T*/ arg), /*=T*/ arg) {
+  R runUnary<R, T>(Zone zone, R f(T arg), T arg) {
     var implementation = _delegationTarget._runUnary;
     _Zone implZone = implementation.zone;
     RunUnaryHandler handler = implementation.function;
     // TODO(floitsch): make this a generic method call on '<R, T>' once it's
     // supported. Remove the unnecessary cast.
     return handler(
         implZone, _parentDelegate(implZone), zone, f, arg) as Object/*=R*/;
   }
 
-  /*=R*/ runBinary/*<R, T1, T2>*/(Zone zone,
-      /*=R*/ f(/*=T1*/ arg1, /*=T2*/ arg2), /*=T1*/ arg1, /*=T2*/ arg2) {
+  R runBinary<R, T1, T2>(Zone zone,
+      R f(T1 arg1, T2 arg2), T1 arg1, T2 arg2) {
     var implementation = _delegationTarget._runBinary;
     _Zone implZone = implementation.zone;
     RunBinaryHandler handler = implementation.function;
     // TODO(floitsch): make this a generic method call on '<R, T1, T2>' once
     // it's supported. Remove the unnecessary cast.
     return handler(
         implZone, _parentDelegate(implZone), zone, f, arg1, arg2)
         as Object/*=R*/;
   }
 
-  ZoneCallback/*<R>*/ registerCallback/*<R>*/(Zone zone, /*=R*/ f()) {
+  ZoneCallback<R> registerCallback<R>(Zone zone, R f()) {
     var implementation = _delegationTarget._registerCallback;
     _Zone implZone = implementation.zone;
     RegisterCallbackHandler handler = implementation.function;
     // TODO(floitsch): make this a generic method call on '<R>' once it's
     // supported. Remove the unnecessary cast.
     return handler(implZone, _parentDelegate(implZone), zone, f)
         as Object/*=ZoneCallback<R>*/;
   }
 
-  ZoneUnaryCallback/*<R, T>*/ registerUnaryCallback/*<R, T>*/(
-      Zone zone, /*=R*/ f(/*=T*/ arg)) {
+  ZoneUnaryCallback<R, T> registerUnaryCallback<R, T>(
+      Zone zone, R f(T arg)) {
     var implementation = _delegationTarget._registerUnaryCallback;
     _Zone implZone = implementation.zone;
     RegisterUnaryCallbackHandler handler = implementation.function;
     // TODO(floitsch): make this a generic method call on '<R, T>' once it's
     // supported. Remove the unnecessary cast.
     return handler(implZone, _parentDelegate(implZone), zone, f)
         as Object/*=ZoneUnaryCallback<R, T>*/;
   }
 
-  ZoneBinaryCallback/*<R, T1, T2>*/ registerBinaryCallback/*<R, T1, T2>*/(
-      Zone zone, /*=R*/ f(/*=T1*/ arg1, /*=T2*/ arg2)) {
+  ZoneBinaryCallback<R, T1, T2> registerBinaryCallback<R, T1, T2>(
+      Zone zone, R f(T1 arg1, T2 arg2)) {
     var implementation = _delegationTarget._registerBinaryCallback;
     _Zone implZone = implementation.zone;
     RegisterBinaryCallbackHandler handler = implementation.function;
     // TODO(floitsch): make this a generic method call on '<R, T1, T2>' once
     // it's supported. Remove the unnecessary cast.
     return handler(implZone, _parentDelegate(implZone), zone, f)
         as Object/*=ZoneBinaryCallback<R, T1, T2>*/;
   }
 
   AsyncError errorCallback(Zone zone, Object error, StackTrace stackTrace) {
@@ skipping 160 matching lines @@
   }
 
   /**
    * The closest error-handling zone.
    *
    * Returns `this` if `this` has an error-handler. Otherwise returns the
    * parent's error-zone.
    */
   Zone get errorZone => _handleUncaughtError.zone;
 
-  /*=R*/ runGuarded/*<R>*/(/*=R*/ f()) {
+  R runGuarded<R>(R f()) {
     try {
       return run(f);
     } catch (e, s) {
       return handleUncaughtError(e, s);
     }
   }
 
-  /*=R*/ runUnaryGuarded/*<R, T>*/(/*=R*/ f(/*=T*/ arg), /*=T*/ arg) {
+  R runUnaryGuarded<R, T>(R f(T arg), T arg) {
     try {
       return runUnary(f, arg);
     } catch (e, s) {
       return handleUncaughtError(e, s);
     }
   }
 
-  /*=R*/ runBinaryGuarded/*<R, T1, T2>*/(
-      /*=R*/ f(/*=T1*/ arg1, /*=T2*/ arg2), /*=T1*/ arg1, /*=T2*/ arg2) {
+  R runBinaryGuarded<R, T1, T2>(
+      R f(T1 arg1, T2 arg2), T1 arg1, T2 arg2) {
     try {
       return runBinary(f, arg1, arg2);
     } catch (e, s) {
       return handleUncaughtError(e, s);
     }
   }
 
-  ZoneCallback/*<R>*/ bindCallback/*<R>*/(
-      /*=R*/ f(), { bool runGuarded: true }) {
+  ZoneCallback<R> bindCallback<R>(
+      R f(), { bool runGuarded: true }) {
     var registered = registerCallback(f);
     if (runGuarded) {
       return () => this.runGuarded(registered);
     } else {
       return () => this.run(registered);
     }
   }
 
-  ZoneUnaryCallback/*<R, T>*/ bindUnaryCallback/*<R, T>*/(
-      /*=R*/ f(/*=T*/ arg), { bool runGuarded: true }) {
+  ZoneUnaryCallback<R, T> bindUnaryCallback<R, T>(
+      R f(T arg), { bool runGuarded: true }) {
     var registered = registerUnaryCallback(f);
     if (runGuarded) {
       return (arg) => this.runUnaryGuarded(registered, arg);
     } else {
       return (arg) => this.runUnary(registered, arg);
     }
   }
 
-  ZoneBinaryCallback/*<R, T1, T2>*/ bindBinaryCallback/*<R, T1, T2>*/(
-      /*=R*/ f(/*=T1*/ arg1, /*=T2*/ arg2), { bool runGuarded: true }) {
+  ZoneBinaryCallback<R, T1, T2> bindBinaryCallback<R, T1, T2>(
+      R f(T1 arg1, T2 arg2), { bool runGuarded: true }) {
     var registered = registerBinaryCallback(f);
     if (runGuarded) {
       return (arg1, arg2) => this.runBinaryGuarded(registered, arg1, arg2);
     } else {
       return (arg1, arg2) => this.runBinary(registered, arg1, arg2);
     }
   }
 
   operator [](Object key) {
     var result = _map[key];
     if (result != null || _map.containsKey(key)) return result;
     // If we are not the root zone, look up in the parent zone.
     if (parent != null) {
       // We do not optimize for repeatedly looking up a key which isn't
       // there. That would require storing the key and keeping it alive.
       // Copying the key/value from the parent does not keep any new values
       // alive.
       var value = parent[key];
       if (value != null) {
         _map[key] = value;
       }
       return value;
     }
     assert(this == _ROOT_ZONE);
     return null;
   }
 
   // Methods that can be customized by the zone specification.
 
-  /*=R*/ handleUncaughtError/*<R>*/(error, StackTrace stackTrace) {
+  R handleUncaughtError<R>(error, StackTrace stackTrace) {
     var implementation = this._handleUncaughtError;
     assert(implementation != null);
     ZoneDelegate parentDelegate = _parentDelegate(implementation.zone);
     HandleUncaughtErrorHandler handler = implementation.function;
     // TODO(floitsch): make this a generic method call on '<R>' once it's
     // supported. Remove the unnecessary cast.
     return handler(
         implementation.zone, parentDelegate, this, error, stackTrace)
         as Object/*=R*/;
   }
 
   Zone fork({ZoneSpecification specification, Map zoneValues}) {
     var implementation = this._fork;
     assert(implementation != null);
     ZoneDelegate parentDelegate = _parentDelegate(implementation.zone);
     ForkHandler handler = implementation.function;
     return handler(implementation.zone, parentDelegate, this,
                    specification, zoneValues);
   }
 
-  /*=R*/ run/*<R>*/(/*=R*/ f()) {
+  R run<R>(R f()) {
     var implementation = this._run;
     assert(implementation != null);
     ZoneDelegate parentDelegate = _parentDelegate(implementation.zone);
     RunHandler handler = implementation.function;
     // TODO(floitsch): make this a generic method call on '<R>' once it's
     // supported. Remove the unnecessary cast.
     return handler(implementation.zone, parentDelegate, this, f)
         as Object/*=R*/;
   }
 
-  /*=R*/ runUnary/*<R, T>*/(/*=R*/ f(/*=T*/ arg), /*=T*/ arg) {
+  R runUnary<R, T>(R f(T arg), T arg) {
     var implementation = this._runUnary;
     assert(implementation != null);
     ZoneDelegate parentDelegate = _parentDelegate(implementation.zone);
     RunUnaryHandler handler = implementation.function;
     // TODO(floitsch): make this a generic method call on '<R, T>' once it's
     // supported. Remove the unnecessary cast.
     return handler(implementation.zone, parentDelegate, this, f, arg)
         as Object/*=R*/;
   }
 
-  /*=R*/ runBinary/*<R, T1, T2>*/(
-      /*=R*/ f(/*=T1*/ arg1, /*=T2*/ arg2), /*=T1*/ arg1, /*=T2*/ arg2) {
+  R runBinary<R, T1, T2>(
+      R f(T1 arg1, T2 arg2), T1 arg1, T2 arg2) {
     var implementation = this._runBinary;
     assert(implementation != null);
     ZoneDelegate parentDelegate = _parentDelegate(implementation.zone);
     RunBinaryHandler handler = implementation.function;
     // TODO(floitsch): make this a generic method call on '<R, T1, T2>' once
     // it's supported. Remove the unnecessary cast.
     return handler(
         implementation.zone, parentDelegate, this, f, arg1, arg2)
         as Object/*=R*/;
   }
 
-  ZoneCallback/*<R>*/ registerCallback/*<R>*/(/*=R*/ callback()) {
+  ZoneCallback<R> registerCallback<R>(R callback()) {
     var implementation = this._registerCallback;
     assert(implementation != null);
     ZoneDelegate parentDelegate = _parentDelegate(implementation.zone);
     RegisterCallbackHandler handler = implementation.function;
     // TODO(floitsch): make this a generic method call on '<R>' once it's
     // supported. Remove the unnecessary cast.
     return handler(implementation.zone, parentDelegate, this, callback)
         as Object/*=ZoneCallback<R>*/;
   }
 
-  ZoneUnaryCallback/*<R, T>*/ registerUnaryCallback/*<R, T>*/(
-      /*=R*/ callback(/*=T*/ arg)) {
+  ZoneUnaryCallback<R, T> registerUnaryCallback<R, T>(
+      R callback(T arg)) {
     var implementation = this._registerUnaryCallback;
     assert(implementation != null);
     ZoneDelegate parentDelegate = _parentDelegate(implementation.zone);
     RegisterUnaryCallbackHandler handler = implementation.function;
     // TODO(floitsch): make this a generic method call on '<R, T>' once it's
     // supported. Remove the unnecessary cast.
     return handler(implementation.zone, parentDelegate, this, callback)
         as Object/*=ZoneUnaryCallback<R, T>*/;
   }
 
-  ZoneBinaryCallback/*<R, T1, T2>*/ registerBinaryCallback/*<R, T1, T2>*/(
-      /*=R*/ callback(/*=T1*/ arg1, /*=T2*/ arg2)) {
+  ZoneBinaryCallback<R, T1, T2> registerBinaryCallback<R, T1, T2>(
+      R callback(T1 arg1, T2 arg2)) {
     var implementation = this._registerBinaryCallback;
     assert(implementation != null);
     ZoneDelegate parentDelegate = _parentDelegate(implementation.zone);
     RegisterBinaryCallbackHandler handler = implementation.function;
     // TODO(floitsch): make this a generic method call on '<R, T1, T2>' once
     // it's supported. Remove the unnecessary cast.
     return handler(implementation.zone, parentDelegate, this, callback)
         as Object/*=ZoneBinaryCallback<R, T1, T2>*/;
   }
 
@@ skipping 35 matching lines @@
 
   void print(String line) {
     var implementation = this._print;
     assert(implementation != null);
     ZoneDelegate parentDelegate = _parentDelegate(implementation.zone);
     PrintHandler handler = implementation.function;
     return handler(implementation.zone, parentDelegate, this, line);
   }
 }
 
-/*=R*/ _rootHandleUncaughtError/*<R>*/(
+R _rootHandleUncaughtError<R>(
     Zone self, ZoneDelegate parent, Zone zone, error, StackTrace stackTrace) {
   _schedulePriorityAsyncCallback(() {
     if (error == null) error = new NullThrownError();
     if (stackTrace == null) throw error;
     _rethrow(error, stackTrace);
   });
 }
 
 external void _rethrow(Object error, StackTrace stackTrace);
 
-/*=R*/ _rootRun/*<R>*/(Zone self, ZoneDelegate parent, Zone zone, /*=R*/ f()) {
+R _rootRun<R>(Zone self, ZoneDelegate parent, Zone zone, R f()) {
   if (Zone._current == zone) return f();
 
   Zone old = Zone._enter(zone);
   try {
     return f();
   } finally {
     Zone._leave(old);
   }
 }
 
-/*=R*/ _rootRunUnary/*<R, T>*/(Zone self, ZoneDelegate parent, Zone zone,
-    /*=R*/ f(/*=T*/ arg), /*=T*/ arg) {
+R _rootRunUnary<R, T>(Zone self, ZoneDelegate parent, Zone zone,
+    R f(T arg), T arg) {
   if (Zone._current == zone) return f(arg);
 
   Zone old = Zone._enter(zone);
   try {
     return f(arg);
   } finally {
     Zone._leave(old);
   }
 }
 
-/*=R*/ _rootRunBinary/*<R, T1, T2>*/(Zone self, ZoneDelegate parent, Zone zone,
-    /*=R*/ f(/*=T1*/ arg1, /*=T2*/ arg2), /*=T1*/ arg1, /*=T2*/ arg2) {
+R _rootRunBinary<R, T1, T2>(Zone self, ZoneDelegate parent, Zone zone,
+    R f(T1 arg1, T2 arg2), T1 arg1, T2 arg2) {
   if (Zone._current == zone) return f(arg1, arg2);
 
   Zone old = Zone._enter(zone);
   try {
     return f(arg1, arg2);
   } finally {
     Zone._leave(old);
   }
 }
 
-ZoneCallback/*<R>*/ _rootRegisterCallback/*<R>*/(
-    Zone self, ZoneDelegate parent, Zone zone, /*=R*/ f()) {
+ZoneCallback<R> _rootRegisterCallback<R>(
+    Zone self, ZoneDelegate parent, Zone zone, R f()) {
   return f;
 }
 
-ZoneUnaryCallback/*<R, T>*/ _rootRegisterUnaryCallback/*<R, T>*/(
-    Zone self, ZoneDelegate parent, Zone zone, /*=R*/ f(/*=T*/ arg)) {
+ZoneUnaryCallback<R, T> _rootRegisterUnaryCallback<R, T>(
+    Zone self, ZoneDelegate parent, Zone zone, R f(T arg)) {
   return f;
 }
 
-ZoneBinaryCallback/*<R, T1, T2>*/ _rootRegisterBinaryCallback/*<R, T1, T2>*/(
+ZoneBinaryCallback<R, T1, T2> _rootRegisterBinaryCallback<R, T1, T2>(
     Zone self, ZoneDelegate parent, Zone zone,
-    /*=R*/ f(/*=T1*/ arg1, /*=T2*/ arg2)) {
+    R f(T1 arg1, T2 arg2)) {
   return f;
 }
 
 AsyncError _rootErrorCallback(Zone self, ZoneDelegate parent, Zone zone,
                               Object error, StackTrace stackTrace) => null;
 
 void _rootScheduleMicrotask(Zone self, ZoneDelegate parent, Zone zone, f()) {
   if (!identical(_ROOT_ZONE, zone)) {
     bool hasErrorHandler = !_ROOT_ZONE.inSameErrorZone(zone);
     f = zone.bindCallback(f, runGuarded: hasErrorHandler);
     // Use root zone as event zone if the function is already bound.
     zone = _ROOT_ZONE;
   }
   _scheduleAsyncCallback(f);
 }
 
 Timer _rootCreateTimer(Zone self, ZoneDelegate parent, Zone zone,
                        Duration duration, void callback()) {
   if (!identical(_ROOT_ZONE, zone)) {
     callback = zone.bindCallback(callback);
   }
   return Timer._createTimer(duration, callback);
 }
 
 Timer _rootCreatePeriodicTimer(
     Zone self, ZoneDelegate parent, Zone zone,
     Duration duration, void callback(Timer timer)) {
   if (!identical(_ROOT_ZONE, zone)) {
     // TODO(floitsch): the return type should be 'void'.
-    callback = zone.bindUnaryCallback/*<dynamic, Timer>*/(callback);
+    callback = zone.bindUnaryCallback<dynamic, Timer>(callback);
   }
   return Timer._createPeriodicTimer(duration, callback);
 }
 
 void _rootPrint(Zone self, ZoneDelegate parent, Zone zone, String line) {
   printToConsole(line);
 }
 
 void _printToZone(String line) {
   Zone.current.print(line);
@@ skipping 81 matching lines @@
   /**
    * The closest error-handling zone.
    *
    * Returns `this` if `this` has an error-handler. Otherwise returns the
    * parent's error-zone.
    */
   Zone get errorZone => this;
 
   // Zone interface.
 
-  /*=R*/ runGuarded/*<R>*/(/*=R*/ f()) {
+  R runGuarded<R>(R f()) {
     try {
       if (identical(_ROOT_ZONE, Zone._current)) {
         return f();
       }
-      return _rootRun/*<R>*/(null, null, this, f);
+      return _rootRun<R>(null, null, this, f);
     } catch (e, s) {
-      return handleUncaughtError/*<R>*/(e, s);
+      return handleUncaughtError<R>(e, s);
     }
   }
 
-  /*=R*/ runUnaryGuarded/*<R, T>*/(/*=R*/ f(/*=T*/ arg), /*=T*/ arg) {
+  R runUnaryGuarded<R, T>(R f(T arg), T arg) {
     try {
       if (identical(_ROOT_ZONE, Zone._current)) {
         return f(arg);
       }
-      return _rootRunUnary/*<R, T>*/(null, null, this, f, arg);
+      return _rootRunUnary<R, T>(null, null, this, f, arg);
     } catch (e, s) {
-      return handleUncaughtError/*<R>*/(e, s);
+      return handleUncaughtError<R>(e, s);
     }
   }
 
-  /*=R*/ runBinaryGuarded/*<R, T1, T2>*/(
-      /*=R*/ f(/*=T1*/ arg1, /*=T2*/ arg2), /*=T1*/ arg1, /*=T2*/ arg2) {
+  R runBinaryGuarded<R, T1, T2>(
+      R f(T1 arg1, T2 arg2), T1 arg1, T2 arg2) {
     try {
       if (identical(_ROOT_ZONE, Zone._current)) {
         return f(arg1, arg2);
       }
-      return _rootRunBinary/*<R, T1, T2>*/(null, null, this, f, arg1, arg2);
+      return _rootRunBinary<R, T1, T2>(null, null, this, f, arg1, arg2);
     } catch (e, s) {
-      return handleUncaughtError/*<R>*/(e, s);
+      return handleUncaughtError<R>(e, s);
     }
   }
 
-  ZoneCallback/*<R>*/ bindCallback/*<R>*/(
-      /*=R*/ f(), { bool runGuarded: true }) {
+  ZoneCallback<R> bindCallback<R>(
+      R f(), { bool runGuarded: true }) {
     if (runGuarded) {
-      return () => this.runGuarded/*<R>*/(f);
+      return () => this.runGuarded<R>(f);
     } else {
-      return () => this.run/*<R>*/(f);
+      return () => this.run<R>(f);
     }
   }
 
-  ZoneUnaryCallback/*<R, T>*/ bindUnaryCallback/*<R, T>*/(
-      /*=R*/ f(/*=T*/ arg), { bool runGuarded: true }) {
+  ZoneUnaryCallback<R, T> bindUnaryCallback<R, T>(
+      R f(T arg), { bool runGuarded: true }) {
     if (runGuarded) {
-      return (arg) => this.runUnaryGuarded/*<R, T>*/(f, arg);
+      return (arg) => this.runUnaryGuarded<R, T>(f, arg);
     } else {
-      return (arg) => this.runUnary/*<R, T>*/(f, arg);
+      return (arg) => this.runUnary<R, T>(f, arg);
     }
   }
 
-  ZoneBinaryCallback/*<R, T1, T2>*/ bindBinaryCallback/*<R, T1, T2>*/(
-      /*=R*/ f(/*=T1*/ arg1, /*=T2*/ arg2), { bool runGuarded: true }) {
+  ZoneBinaryCallback<R, T1, T2> bindBinaryCallback<R, T1, T2>(
+      R f(T1 arg1, T2 arg2), { bool runGuarded: true }) {
     if (runGuarded) {
       return (arg1, arg2) =>
-          this.runBinaryGuarded/*<R, T1, T2>*/(f, arg1, arg2);
+          this.runBinaryGuarded<R, T1, T2>(f, arg1, arg2);
     } else {
-      return (arg1, arg2) => this.runBinary/*<R, T1, T2>*/(f, arg1, arg2);
+      return (arg1, arg2) => this.runBinary<R, T1, T2>(f, arg1, arg2);
     }
   }
 
   operator [](Object key) => null;
 
   // Methods that can be customized by the zone specification.
 
-  /*=R*/ handleUncaughtError/*<R>*/(error, StackTrace stackTrace) {
+  R handleUncaughtError<R>(error, StackTrace stackTrace) {
     return _rootHandleUncaughtError(null, null, this, error, stackTrace);
   }
 
   Zone fork({ZoneSpecification specification, Map zoneValues}) {
     return _rootFork(null, null, this, specification, zoneValues);
   }
 
-  /*=R*/ run/*<R>*/(/*=R*/ f()) {
+  R run<R>(R f()) {
     if (identical(Zone._current, _ROOT_ZONE)) return f();
     return _rootRun(null, null, this, f);
   }
 
-  /*=R*/ runUnary/*<R, T>*/(/*=R*/ f(/*=T*/ arg), /*=T*/ arg) {
+  R runUnary<R, T>(R f(T arg), T arg) {
     if (identical(Zone._current, _ROOT_ZONE)) return f(arg);
     return _rootRunUnary(null, null, this, f, arg);
   }
 
-  /*=R*/ runBinary/*<R, T1, T2>*/(
-      /*=R*/ f(/*=T1*/ arg1, /*=T2*/ arg2), /*=T1*/ arg1, /*=T2*/ arg2) {
+  R runBinary<R, T1, T2>(
+      R f(T1 arg1, T2 arg2), T1 arg1, T2 arg2) {
     if (identical(Zone._current, _ROOT_ZONE)) return f(arg1, arg2);
     return _rootRunBinary(null, null, this, f, arg1, arg2);
   }
 
-  ZoneCallback/*<R>*/ registerCallback/*<R>*/(/*=R*/ f()) => f;
+  ZoneCallback<R> registerCallback<R>(R f()) => f;
 
-  ZoneUnaryCallback/*<R, T>*/ registerUnaryCallback/*<R, T>*/(
-      /*=R*/ f(/*=T*/ arg)) => f;
+  ZoneUnaryCallback<R, T> registerUnaryCallback<R, T>(
+      R f(T arg)) => f;
 
-  ZoneBinaryCallback/*<R, T1, T2>*/ registerBinaryCallback/*<R, T1, T2>*/(
-      /*=R*/ f(/*=T1*/ arg1, /*=T2*/ arg2)) => f;
+  ZoneBinaryCallback<R, T1, T2> registerBinaryCallback<R, T1, T2>(
+      R f(T1 arg1, T2 arg2)) => f;
 
   AsyncError errorCallback(Object error, StackTrace stackTrace) => null;
 
   void scheduleMicrotask(void f()) {
     _rootScheduleMicrotask(null, null, this, f);
   }
 
   Timer createTimer(Duration duration, void f()) {
     return Timer._createTimer(duration, f);
   }
@@ skipping 27 matching lines @@
  *         future = future.catchError((e) { print("Never reached!"); });
  *       }, onError: (e) { print("unused error handler"); });
  *     }, onError: (e) { print("catches error of first error-zone."); });
  *
  * Example:
  *
  *     runZoned(() {
  *       new Future(() { throw "asynchronous error"; });
  *     }, onError: print);  // Will print "asynchronous error".
  */
-/*=R*/ runZoned/*<R>*/(/*=R*/ body(),
+R runZoned<R>(R body(),
                  { Map zoneValues,
                    ZoneSpecification zoneSpecification,
                    Function onError }) {
   HandleUncaughtErrorHandler errorHandler;
   if (onError != null) {
     errorHandler = (Zone self, ZoneDelegate parent, Zone zone,
                     error, StackTrace stackTrace) {
       try {
-        if (onError is ZoneBinaryCallback<dynamic/*=R*/, dynamic, StackTrace>) {
+        if (onError is ZoneBinaryCallback<R, dynamic, StackTrace>) {
           return self.parent.runBinary(onError, error, stackTrace);
         }
         return self.parent.runUnary(onError, error);
       } catch(e, s) {
         if (identical(e, error)) {
           return parent.handleUncaughtError(zone, error, stackTrace);
         } else {
           return parent.handleUncaughtError(zone, e, s);
         }
       }
     };
   }
   if (zoneSpecification == null) {
     zoneSpecification =
         new ZoneSpecification(handleUncaughtError: errorHandler);
   } else if (errorHandler != null) {
     zoneSpecification =
         new ZoneSpecification.from(zoneSpecification,
                                    handleUncaughtError: errorHandler);
   }
   Zone zone = Zone.current.fork(specification: zoneSpecification,
                                 zoneValues: zoneValues);
   if (onError != null) {
     return zone.runGuarded(body);
   } else {
     return zone.run(body);
   }
 }