Disable closure wrapping by default

lib/runtime/dart/async.js

 var async;
 (function(exports) {
   'use strict';
   // Function _invokeErrorHandler: (Function, Object, StackTrace) → dynamic
   function _invokeErrorHandler(errorHandler, error, stackTrace) {
     if (dart.is(errorHandler, ZoneBinaryCallback)) {
       return dart.dinvokef(errorHandler, error, stackTrace);
     } else {
       return dart.dinvokef(errorHandler, error);
     }
@@ skipping 43 matching lines @@
   let _addError = Symbol('_addError');
   let _completeError = Symbol('_completeError');
   let _complete = Symbol('_complete');
   let _sink = Symbol('_sink');
   let Stream$ = dart.generic(function(T) {
     class Stream extends core.Object {
       Stream() {
       }
       fromFuture(future) {
         let controller = new (StreamController$(T))({sync: true});
-        future.then(dart.closureWrap((value) => {
+        future.then(dart.as((value) => {
           controller._add(dart.as(value, T));
           controller._closeUnchecked();
-        }, "(T) → dynamic"), {
+        }, dart.throw_("Unimplemented type (T) → dynamic")), {
           onError: (error, stackTrace) => {
             controller._addError(error, dart.as(stackTrace, core.StackTrace));
             controller._closeUnchecked();
           }
         });
         return controller.stream;
       }
       fromIterable(data) {
         return new (_GeneratedStreamImpl$(T))(() => new (_IterablePendingEvents$(T))(data));
       }
       periodic(period, computation) {
         if (computation === void 0)
           computation = null;
         if (computation == null)
-          computation = dart.closureWrap((i) => null, "(int) → T");
+          computation = dart.as((i) => null, dart.throw_("Unimplemented type (int) → T"));
         let timer = null;
         let computationCount = 0;
         let controller = null;
         let watch = new core.Stopwatch();
         // Function sendEvent: () → void
         function sendEvent() {
           watch.reset();
           let data = computation(((x) => computationCount = dart.notNull(x) + 1, x)(computationCount));
           controller.add(data);
         }
@@ skipping 27 matching lines @@
           },
           onCancel: () => {
             if (timer != null)
               timer.cancel();
             timer = null;
           }
         });
         return controller.stream;
       }
       eventTransformed(source, mapSink) {
-        return dart.as(new _BoundSinkStream(source, dart.closureWrap(mapSink, "(EventSink<dynamic>) → EventSink")), Stream$(T));
+        return dart.as(new _BoundSinkStream(source, dart.as(mapSink, _SinkMapper)), Stream$(T));
       }
       get isBroadcast() {
         return false;
       }
       asBroadcastStream(opts) {
         let onListen = opts && 'onListen' in opts ? opts.onListen : null;
         let onCancel = opts && 'onCancel' in opts ? opts.onCancel : null;
-        return new (_AsBroadcastStream$(T))(this, dart.closureWrap(onListen, "(StreamSubscription<dynamic>) → void"), dart.closureWrap(onCancel, "(StreamSubscription<dynamic>) → void"));
+        return new (_AsBroadcastStream$(T))(this, dart.as(onListen, dart.throw_("Unimplemented type (StreamSubscription<dynamic>) → void")), dart.as(onCancel, dart.throw_("Unimplemented type (StreamSubscription<dynamic>) → void")));
       }
       where(test) {
         return new (_WhereStream$(T))(this, test);
       }
       map(convert) {
         return new (_MapStream$(T, dynamic))(this, convert);
       }
       asyncMap(convert) {
         let controller = null;
         let subscription = null;
@@ skipping 254 matching lines @@
           onDone: () => {
             future._complete(false);
           },
           cancelOnError: true
         });
         return future;
       }
       get length() {
         let future = new (_Future$(core.int))();
         let count = 0;
-        this.listen(dart.closureWrap((_) => {
+        this.listen(dart.as((_) => {
           count = dart.notNull(count) + 1;
-        }, "(T) → void"), {
+        }, dart.throw_("Unimplemented type (T) → void")), {
           onError: future[_completeError],
           onDone: () => {
             future._complete(count);
           },
           cancelOnError: true
         });
         return future;
       }
       get isEmpty() {
         let future = new (_Future$(core.bool))();
         let subscription = null;
-        subscription = this.listen(dart.closureWrap((_) => {
+        subscription = this.listen(dart.as((_) => {
           _cancelAndValue(subscription, future, false);
-        }, "(T) → void"), {
+        }, dart.throw_("Unimplemented type (T) → void")), {
           onError: future[_completeError],
           onDone: () => {
             future._complete(true);
           },
           cancelOnError: true
         });
         return future;
       }
       toList() {
         let result = new core.List$(T).from([]);
@@ skipping 283 matching lines @@
           controller.close();
         }
         // Function onListen: () → void
         function onListen() {
           zone = Zone.current;
           if (onTimeout == null) {
             timeout = () => {
               controller.addError(new TimeoutException("No stream event", timeLimit), null);
             };
           } else {
-            onTimeout = dart.closureWrap(zone.registerUnaryCallback(onTimeout), "(EventSink<dynamic>) → void");
+            onTimeout = dart.as(zone.registerUnaryCallback(onTimeout), dart.throw_("Unimplemented type (EventSink<dynamic>) → void"));
             let wrapper = new _ControllerEventSinkWrapper(null);
             timeout = () => {
               wrapper[_sink] = controller;
               zone.runUnaryGuarded(onTimeout, wrapper);
               wrapper[_sink] = null;
             };
           }
           subscription = this.listen(onData, {onError: onError, onDone: onDone});
           timer = zone.createTimer(timeLimit, dart.as(timeout, dart.throw_("Unimplemented type () → void")));
         }
@@ skipping 159 matching lines @@
         }
       }
       [_extractPending]() {
         dart.assert(this[_isCanceled]);
         let events = this[_pending];
         this[_pending] = null;
         return events;
       }
       onData(handleData) {
         if (handleData == null)
-          handleData = dart.closureWrap(_nullDataHandler, "(T) → void");
-        this[_onData] = dart.closureWrap(this[_zone].registerUnaryCallback(handleData), "(T) → void");
+          handleData = dart.as(_nullDataHandler, dart.throw_("Unimplemented type (T) → void"));
+        this[_onData] = dart.as(this[_zone].registerUnaryCallback(handleData), _DataHandler);
       }
       onError(handleError) {
         if (handleError == null)
           handleError = _nullErrorHandler;
         this[_onError] = _registerErrorHandler(handleError, this[_zone]);
       }
       onDone(handleDone) {
         if (handleDone == null)
           handleDone = _nullDoneHandler;
         this[_onDone] = this[_zone].registerCallback(handleDone);
@@ skipping 564 matching lines @@
       }
       [_sendError](error, stackTrace) {
         if (this[_isEmpty])
           return;
         this[_forEachListener]((subscription) => {
           subscription._addError(error, stackTrace);
         });
       }
       [_sendDone]() {
         if (!dart.notNull(this[_isEmpty])) {
-          this[_forEachListener](dart.closureWrap((subscription) => {
+          this[_forEachListener](dart.as((subscription) => {
             subscription._close();
-          }, "(_BufferingStreamSubscription<T>) → void"));
+          }, dart.throw_("Unimplemented type (_BufferingStreamSubscription<T>) → void")));
         } else {
           dart.assert(this[_doneFuture] != null);
           dart.assert(this[_doneFuture][_mayComplete]);
           this[_doneFuture]._asyncComplete(null);
         }
       }
     }
     return _SyncBroadcastStreamController;
   });
   let _SyncBroadcastStreamController = _SyncBroadcastStreamController$();
@@ skipping 568 matching lines @@
           this[_state] = _Future[_CHAINED];
         } else {
           dart.assert(this[_isChained]);
           this[_state] = _Future[_INCOMPLETE];
         }
       }
       then(f, opts) {
         let onError = opts && 'onError' in opts ? opts.onError : null;
         let result = new _Future();
         if (!dart.notNull(core.identical(result[_zone], _ROOT_ZONE))) {
-          f = dart.closureWrap(result[_zone].registerUnaryCallback(f), "(T) → dynamic");
+          f = dart.as(result[_zone].registerUnaryCallback(f), dart.throw_("Unimplemented type (T) → dynamic"));
           if (onError != null) {
             onError = _registerErrorHandler(onError, result[_zone]);
           }
         }
         this[_addListener](new _FutureListener.then(result, f, onError));
         return result;
       }
       catchError(onError, opts) {
         let test = opts && 'test' in opts ? opts.test : null;
         let result = new _Future();
         if (!dart.notNull(core.identical(result[_zone], _ROOT_ZONE))) {
           onError = _registerErrorHandler(onError, result[_zone]);
           if (test != null)
-            test = dart.closureWrap(result[_zone].registerUnaryCallback(test), "(dynamic) → bool");
+            test = dart.as(result[_zone].registerUnaryCallback(test), dart.throw_("Unimplemented type (dynamic) → bool"));
         }
         this[_addListener](new _FutureListener.catchError(result, onError, test));
         return result;
       }
       whenComplete(action) {
         let result = new (_Future$(T))();
         if (!dart.notNull(core.identical(result[_zone], _ROOT_ZONE))) {
           action = result[_zone].registerCallback(action);
         }
         this[_addListener](new _FutureListener.whenComplete(result, action));
@@ skipping 1327 matching lines @@
   let _onListenHandler = Symbol('_onListenHandler');
   let _onCancelHandler = Symbol('_onCancelHandler');
   let _cancelSubscription = Symbol('_cancelSubscription');
   let _pauseSubscription = Symbol('_pauseSubscription');
   let _resumeSubscription = Symbol('_resumeSubscription');
   let _isSubscriptionPaused = Symbol('_isSubscriptionPaused');
   let _AsBroadcastStream$ = dart.generic(function(T) {
     class _AsBroadcastStream extends Stream$(T) {
       _AsBroadcastStream(source$, onListenHandler, onCancelHandler) {
         this[_source] = source$;
-        this[_onListenHandler] = dart.closureWrap(Zone.current.registerUnaryCallback(onListenHandler), "(StreamSubscription<dynamic>) → void");
-        this[_onCancelHandler] = dart.closureWrap(Zone.current.registerUnaryCallback(onCancelHandler), "(StreamSubscription<dynamic>) → void");
+        this[_onListenHandler] = dart.as(Zone.current.registerUnaryCallback(onListenHandler), _broadcastCallback);
+        this[_onCancelHandler] = dart.as(Zone.current.registerUnaryCallback(onCancelHandler), _broadcastCallback);
         this[_zone] = Zone.current;
         this[_controller] = null;
         this[_subscription] = null;
         super.Stream();
         this[_controller] = new (_AsBroadcastStreamController$(T))(this[_onListen], this[_onCancel]);
       }
       get isBroadcast() {
         return true;
       }
       listen(onData, opts) {
@@ skipping 763 matching lines @@
       _BoundSinkStream(stream$, sinkMapper) {
         this[_stream] = stream$;
         this[_sinkMapper] = sinkMapper;
         super.Stream();
       }
       listen(onData, opts) {
         let onError = opts && 'onError' in opts ? opts.onError : null;
         let onDone = opts && 'onDone' in opts ? opts.onDone : null;
         let cancelOnError = opts && 'cancelOnError' in opts ? opts.cancelOnError : null;
         cancelOnError = core.identical(true, cancelOnError);
-        let subscription = new _SinkTransformerStreamSubscription(this[_stream], dart.closureWrap(this[_sinkMapper], "(EventSink<dynamic>) → EventSink"), onData, onError, onDone, cancelOnError);
+        let subscription = new _SinkTransformerStreamSubscription(this[_stream], dart.as(this[_sinkMapper], _SinkMapper), onData, onError, onDone, cancelOnError);
         return subscription;
       }
     }
     return _BoundSinkStream;
   });
   let _BoundSinkStream = _BoundSinkStream$();
   let _TransformDataHandler$ = dart.generic(function(S, T) {
     class _TransformDataHandler extends core.Function {}
     return _TransformDataHandler;
   });
@@ skipping 34 matching lines @@
   let _HandlerEventSink = _HandlerEventSink$();
   let _defaultHandleData = Symbol('_defaultHandleData');
   let _defaultHandleError = Symbol('_defaultHandleError');
   let _defaultHandleDone = Symbol('_defaultHandleDone');
   let _StreamHandlerTransformer$ = dart.generic(function(S, T) {
     class _StreamHandlerTransformer extends _StreamSinkTransformer$(S, T) {
       _StreamHandlerTransformer(opts) {
         let handleData = opts && 'handleData' in opts ? opts.handleData : null;
         let handleError = opts && 'handleError' in opts ? opts.handleError : null;
         let handleDone = opts && 'handleDone' in opts ? opts.handleDone : null;
-        super._StreamSinkTransformer(dart.closureWrap((outputSink) => {
+        super._StreamSinkTransformer(dart.as((outputSink) => {
           if (handleData == null)
-            handleData = dart.closureWrap(_StreamHandlerTransformer[_defaultHandleData], "(S, EventSink<T>) → void");
+            handleData = dart.as(_StreamHandlerTransformer[_defaultHandleData], dart.throw_("Unimplemented type (S, EventSink<T>) → void"));
           if (handleError == null)
-            handleError = dart.closureWrap(_StreamHandlerTransformer[_defaultHandleError], "(Object, StackTrace, EventSink<T>) → void");
+            handleError = dart.as(_StreamHandlerTransformer[_defaultHandleError], dart.throw_("Unimplemented type (Object, StackTrace, EventSink<T>) → void"));
           if (handleDone == null)
             handleDone = _StreamHandlerTransformer[_defaultHandleDone];
           return new (_HandlerEventSink$(S, T))(handleData, handleError, handleDone, outputSink);
-        }, "(EventSink<T>) → EventSink<S>"));
+        }, _SinkMapper));
       }
       bind(stream) {
         return super.bind(stream);
       }
       static [_defaultHandleData](data, sink) {
         sink.add(data);
       }
       static [_defaultHandleError](error, stackTrace, sink) {
         sink.addError(error);
       }
@@ skipping 51 matching lines @@
     Timer(duration, callback) {
       if (dart.equals(Zone.current, Zone.ROOT)) {
         return Zone.current.createTimer(duration, callback);
       }
       return Zone.current.createTimer(duration, Zone.current.bindCallback(callback, {runGuarded: true}));
     }
     periodic(duration, callback) {
       if (dart.equals(Zone.current, Zone.ROOT)) {
         return Zone.current.createPeriodicTimer(duration, callback);
       }
-      return Zone.current.createPeriodicTimer(duration, dart.closureWrap(Zone.current.bindUnaryCallback(callback, {runGuarded: true}), "(Timer) → void"));
+      return Zone.current.createPeriodicTimer(duration, dart.as(Zone.current.bindUnaryCallback(callback, {runGuarded: true}), dart.throw_("Unimplemented type (Timer) → void")));
     }
     static run(callback) {
       new Timer(core.Duration.ZERO, callback);
     }
     static [_createTimer](duration, callback) {
       let milliseconds = duration.inMilliseconds;
       if (dart.notNull(milliseconds) < 0)
         milliseconds = 0;
       return new _isolate_helper.TimerImpl(milliseconds, callback);
     }
@@ skipping 467 matching lines @@
   // Function _rootCreateTimer: (Zone, ZoneDelegate, Zone, Duration, () → void) → Timer
   function _rootCreateTimer(self, parent, zone, duration, callback) {
     if (!dart.notNull(core.identical(_ROOT_ZONE, zone))) {
       callback = zone.bindCallback(callback);
     }
     return Timer._createTimer(duration, callback);
   }
   // Function _rootCreatePeriodicTimer: (Zone, ZoneDelegate, Zone, Duration, (Timer) → void) → Timer
   function _rootCreatePeriodicTimer(self, parent, zone, duration, callback) {
     if (!dart.notNull(core.identical(_ROOT_ZONE, zone))) {
-      callback = dart.closureWrap(zone.bindUnaryCallback(callback), "(Timer) → void");
+      callback = dart.as(zone.bindUnaryCallback(callback), dart.throw_("Unimplemented type (Timer) → void"));
     }
     return Timer._createPeriodicTimer(duration, callback);
   }
   // Function _rootPrint: (Zone, ZoneDelegate, Zone, String) → void
   function _rootPrint(self, parent, zone, line) {
     _internal.printToConsole(line);
   }
   // Function _printToZone: (String) → void
   function _printToZone(line) {
     Zone.current.print(line);
@@ skipping 322 matching lines @@
   exports.ScheduleMicrotaskHandler = ScheduleMicrotaskHandler;
   exports.CreateTimerHandler = CreateTimerHandler;
   exports.CreatePeriodicTimerHandler = CreatePeriodicTimerHandler;
   exports.PrintHandler = PrintHandler;
   exports.ForkHandler = ForkHandler;
   exports.ZoneSpecification = ZoneSpecification;
   exports.ZoneDelegate = ZoneDelegate;
   exports.Zone = Zone;
   exports.runZoned = runZoned;
 })(async || (async = {}));