Use generic functions in zones.

pkg/compiler/lib/src/common/tasks.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.
 
 library dart2js.common.tasks;
 
 import 'dart:async'
     show Future, Zone, ZoneDelegate, ZoneSpecification, runZoned;
 
 /// Used to measure where time is spent in the compiler.
@@ skipping 97 matching lines @@
             run: _run, runUnary: _runUnary, runBinary: _runBinary));
   }
 
   /// Run [f] in [zone]. Running must be delegated to [parent] to ensure that
   /// various state is set up correctly (in particular that `Zone.current`
   /// has the right value). Since [_measureZoned] can be called recursively
   /// (synchronously), some of the measuring zones we create will be parents
   /// of other measuring zones, but we still need to call through the parent
   /// chain. Consequently, we use a zone value keyed by [measurer] to see if
   /// we should measure or not when delegating.
-  _run(Zone self, ZoneDelegate parent, Zone zone, f()) {
+  R _run<R>(Zone self, ZoneDelegate parent, Zone zone, R f()) {
     if (zone[measurer] != this) return parent.run(zone, f);
     CompilerTask previous = _start();
     try {
       return parent.run(zone, f);
     } finally {
       _stop(previous);
     }
   }
 
   /// Same as [run] except that [f] takes one argument, [arg].
-  _runUnary(Zone self, ZoneDelegate parent, Zone zone, f(arg), arg) {
+  R _runUnary<R, T>(
+      Zone self, ZoneDelegate parent, Zone zone, R f(T arg), T arg) {
     if (zone[measurer] != this) return parent.runUnary(zone, f, arg);
     CompilerTask previous = _start();
     try {
       return parent.runUnary(zone, f, arg);
     } finally {
       _stop(previous);
     }
   }
 
   /// Same as [run] except that [f] takes two arguments ([a1] and [a2]).
-  _runBinary(Zone self, ZoneDelegate parent, Zone zone, f(a1, a2), a1, a2) {
+  R _runBinary<R, T1, T2>(Zone self, ZoneDelegate parent, Zone zone,
+      R f(T1 a1, T2 a2), T1 a1, T2 a2) {
     if (zone[measurer] != this) return parent.runBinary(zone, f, a1, a2);
     CompilerTask previous = _start();
     try {
       return parent.runBinary(zone, f, a1, a2);
     } finally {
       _stop(previous);
     }
   }
 
   /// Asynchronous version of [measure]. Use this when action returns a future
@@ skipping 89 matching lines @@
   }
 
   /// Call this when the eventloop returns control to us.
   void stopAsyncWallClock() {
     if (currentAsyncTask != null) {
       currentAsyncTask._watch.stop();
     }
     asyncWallClock.stop();
   }
 }