partially implement instance of checks and some codegen fixes

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 42 matching lines @@
   let _onListen = Symbol('_onListen');
   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 = dart.as(new StreamController({sync: true}), _StreamController$(T));
+        let controller = dart.as(new (StreamController$(T))({sync: true}), _StreamController$(T));
         future.then(dart.closureWrap(((value) => {
           controller._add(dart.as(value, T));
           controller._closeUnchecked();
         }).bind(this), "(T) → dynamic"), {onError: ((error, stackTrace) => {
             controller._addError(error, dart.as(stackTrace, core.StackTrace));
             controller._closeUnchecked();
           }).bind(this)});
         return controller.stream;
       }
       fromIterable(data) {
-        return new _GeneratedStreamImpl(() => new _IterablePendingEvents(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");
         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);
         }
         // Function startPeriodicTimer: () → void
         function startPeriodicTimer() {
           dart.assert(timer == null);
           timer = new Timer.periodic(period, (timer) => {
             sendEvent();
           });
         }
-        controller = new StreamController({sync: true, onListen: (() => {
+        controller = new (StreamController$(T))({sync: true, onListen: (() => {
             watch.start();
             startPeriodicTimer();
           }).bind(this), onPause: (() => {
             timer.cancel();
             timer = null;
             watch.stop();
           }).bind(this), onResume: (() => {
             dart.assert(timer == null);
             let elapsed = watch.elapsed;
             watch.start();
@@ skipping 11 matching lines @@
       }
       eventTransformed(source, mapSink) {
         return dart.as(new _BoundSinkStream(source, dart.closureWrap(mapSink, "(EventSink<dynamic>) → EventSink")), 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(this, dart.closureWrap(onListen, "(StreamSubscription<dynamic>) → void"), dart.closureWrap(onCancel, "(StreamSubscription<dynamic>) → void"));
+        return new (_AsBroadcastStream$(T))(this, dart.closureWrap(onListen, "(StreamSubscription<dynamic>) → void"), dart.closureWrap(onCancel, "(StreamSubscription<dynamic>) → void"));
       }
       where(test) {
-        return new _WhereStream(this, test);
+        return new (_WhereStream$(T))(this, test);
       }
       map(convert) {
-        return new _MapStream(this, convert);
+        return new (_MapStream$(T, dynamic))(this, convert);
       }
       asyncMap(convert) {
         let controller = null;
         let subscription = null;
         // Function onListen: () → void
         function onListen() {
           let add = controller.add;
           dart.assert(dart.notNull(dart.is(controller, _StreamController)) || dart.notNull(dart.is(controller, _BroadcastStreamController)));
           let eventSink = controller;
           let addError = eventSink[_addError];
@@ skipping 63 matching lines @@
             }).bind(this), onResume: (() => {
               subscription.resume();
             }).bind(this), onCancel: (() => {
               subscription.cancel();
             }).bind(this), sync: true});
         }
         return controller.stream;
       }
       handleError(onError, opts) {
         let test = opts && 'test' in opts ? opts.test : null;
-        return new _HandleErrorStream(this, onError, test);
+        return new (_HandleErrorStream$(T))(this, onError, test);
       }
       expand(convert) {
-        return new _ExpandStream(this, convert);
+        return new (_ExpandStream$(T, dynamic))(this, convert);
       }
       pipe(streamConsumer) {
         return streamConsumer.addStream(this).then(((_) => streamConsumer.close()).bind(this));
       }
       transform(streamTransformer) {
         return streamTransformer.bind(this);
       }
       reduce(combine) {
-        let result = new _Future();
+        let result = new (_Future$(T))();
         let seenFirst = false;
         let value = null;
         let subscription = null;
         subscription = this.listen((element) => {
           if (seenFirst) {
             _runUserCode(() => combine(value, element), (newValue) => {
               value = newValue;
             }, dart.as(_cancelAndErrorClosure(subscription, result), dart.throw_("Unimplemented type (dynamic, StackTrace) → dynamic")));
           } else {
             value = element;
@@ skipping 25 matching lines @@
         }, {onError: ((e, st) => {
             result._completeError(e, dart.as(st, core.StackTrace));
           }).bind(this), onDone: (() => {
             result._complete(value);
           }).bind(this), cancelOnError: true});
         return result;
       }
       join(separator) {
         if (separator === void 0)
           separator = "";
-        let result = new _Future();
+        let result = new (_Future$(core.String))();
         let buffer = new core.StringBuffer();
         let subscription = null;
         let first = true;
         subscription = this.listen(((element) => {
           if (!dart.notNull(first)) {
             buffer.write(separator);
           }
           first = false;
           try {
             buffer.write(element);
           } catch (e) {
             let s = dart.stackTrace(e);
             _cancelAndErrorWithReplacement(subscription, result, e, s);
           }
 
         }).bind(this), {onError: ((e) => {
             result._completeError(e);
           }).bind(this), onDone: (() => {
             result._complete(buffer.toString());
           }).bind(this), cancelOnError: true});
         return result;
       }
       contains(needle) {
-        let future = new _Future();
+        let future = new (_Future$(core.bool))();
         let subscription = null;
         subscription = this.listen((element) => {
           _runUserCode(() => dart.equals(element, needle), (isMatch) => {
             if (isMatch) {
               _cancelAndValue(subscription, future, true);
             }
           }, dart.as(_cancelAndErrorClosure(subscription, future), dart.throw_("Unimplemented type (dynamic, StackTrace) → dynamic")));
         }, {onError: future[_completeError], onDone: (() => {
             future._complete(false);
           }).bind(this), cancelOnError: true});
         return future;
       }
       forEach(action) {
         let future = new _Future();
         let subscription = null;
         subscription = this.listen((element) => {
           _runUserCode(() => action(element), (_) => {
           }, dart.as(_cancelAndErrorClosure(subscription, future), dart.throw_("Unimplemented type (dynamic, StackTrace) → dynamic")));
         }, {onError: future[_completeError], onDone: (() => {
             future._complete(null);
           }).bind(this), cancelOnError: true});
         return future;
       }
       every(test) {
-        let future = new _Future();
+        let future = new (_Future$(core.bool))();
         let subscription = null;
         subscription = this.listen((element) => {
           _runUserCode(() => test(element), (isMatch) => {
             if (!dart.notNull(isMatch)) {
               _cancelAndValue(subscription, future, false);
             }
           }, dart.as(_cancelAndErrorClosure(subscription, future), dart.throw_("Unimplemented type (dynamic, StackTrace) → dynamic")));
         }, {onError: future[_completeError], onDone: (() => {
             future._complete(true);
           }).bind(this), cancelOnError: true});
         return future;
       }
       any(test) {
-        let future = new _Future();
+        let future = new (_Future$(core.bool))();
         let subscription = null;
         subscription = this.listen((element) => {
           _runUserCode(() => test(element), (isMatch) => {
             if (isMatch) {
               _cancelAndValue(subscription, future, true);
             }
           }, dart.as(_cancelAndErrorClosure(subscription, future), dart.throw_("Unimplemented type (dynamic, StackTrace) → dynamic")));
         }, {onError: future[_completeError], onDone: (() => {
             future._complete(false);
           }).bind(this), cancelOnError: true});
         return future;
       }
       get length() {
-        let future = new _Future();
+        let future = new (_Future$(core.int))();
         let count = 0;
         this.listen(dart.closureWrap((_) => {
           count = dart.notNull(count) + 1;
         }, "(T) → void"), {onError: future[_completeError], onDone: (() => {
             future._complete(count);
           }).bind(this), cancelOnError: true});
         return future;
       }
       get isEmpty() {
-        let future = new _Future();
+        let future = new (_Future$(core.bool))();
         let subscription = null;
         subscription = this.listen(dart.closureWrap((_) => {
           _cancelAndValue(subscription, future, false);
         }, "(T) → void"), {onError: future[_completeError], onDone: (() => {
             future._complete(true);
           }).bind(this), cancelOnError: true});
         return future;
       }
       toList() {
         let result = new core.List$(T).from([]);
-        let future = new _Future();
+        let future = new (_Future$(core.List$(T)))();
         this.listen(((data) => {
           result.add(data);
         }).bind(this), {onError: future[_completeError], onDone: (() => {
             future._complete(result);
           }).bind(this), cancelOnError: true});
         return future;
       }
       toSet() {
-        let result = new core.Set();
-        let future = new _Future();
+        let result = new (core.Set$(T))();
+        let future = new (_Future$(core.Set$(T)))();
         this.listen(((data) => {
           result.add(data);
         }).bind(this), {onError: future[_completeError], onDone: (() => {
             future._complete(result);
           }).bind(this), cancelOnError: true});
         return future;
       }
       drain(futureValue) {
         if (futureValue === void 0)
           futureValue = null;
@@ skipping 10 matching lines @@
       }
       skipWhile(test) {
         return dart.as(new _SkipWhileStream(this, test), Stream$(T));
       }
       distinct(equals) {
         if (equals === void 0)
           equals = null;
         return dart.as(new _DistinctStream(this, equals), Stream$(T));
       }
       get first() {
-        let future = new _Future();
+        let future = new (_Future$(T))();
         let subscription = null;
         subscription = this.listen((value) => {
           _cancelAndValue(subscription, future, value);
         }, {
           onError: future[_completeError],
           onDone: () => {
             try {
               throw _internal.IterableElementError.noElement();
             } catch (e) {
               let s = dart.stackTrace(e);
               _completeWithErrorCallback(future, e, s);
             }
 
           },
           cancelOnError: true
         });
         return future;
       }
       get last() {
-        let future = new _Future();
+        let future = new (_Future$(T))();
         let result = null;
         let foundResult = false;
         let subscription = null;
         subscription = this.listen((value) => {
           foundResult = true;
           result = value;
         }, {onError: future[_completeError], onDone: (() => {
             if (foundResult) {
               future._complete(result);
               return;
             }
             try {
               throw _internal.IterableElementError.noElement();
             } catch (e) {
               let s = dart.stackTrace(e);
               _completeWithErrorCallback(future, e, s);
             }
 
           }).bind(this), cancelOnError: true});
         return future;
       }
       get single() {
-        let future = new _Future();
+        let future = new (_Future$(T))();
         let result = null;
         let foundResult = false;
         let subscription = null;
         subscription = this.listen((value) => {
           if (foundResult) {
             try {
               throw _internal.IterableElementError.tooMany();
             } catch (e) {
               let s = dart.stackTrace(e);
               _cancelAndErrorWithReplacement(subscription, future, e, s);
@@ skipping 69 matching lines @@
               throw _internal.IterableElementError.noElement();
             } catch (e) {
               let s = dart.stackTrace(e);
               _completeWithErrorCallback(future, e, s);
             }
 
           }).bind(this), cancelOnError: true});
         return future;
       }
       singleWhere(test) {
-        let future = new _Future();
+        let future = new (_Future$(T))();
         let result = null;
         let foundResult = false;
         let subscription = null;
         subscription = this.listen((value) => {
           _runUserCode(() => true == test(value), (isMatch) => {
             if (isMatch) {
               if (foundResult) {
                 try {
                   throw _internal.IterableElementError.tooMany();
                 } catch (e) {
@@ skipping 18 matching lines @@
               let s = dart.stackTrace(e);
               _completeWithErrorCallback(future, e, s);
             }
 
           }).bind(this), cancelOnError: true});
         return future;
       }
       elementAt(index) {
         if (dart.notNull(!(typeof index == 'number')) || dart.notNull(index) < 0)
           throw new core.ArgumentError(index);
-        let future = new _Future();
+        let future = new (_Future$(T))();
         let subscription = null;
         let elementIndex = 0;
         subscription = this.listen((value) => {
           if (index == elementIndex) {
             _cancelAndValue(subscription, future, value);
             return;
           }
           elementIndex = 1;
         }, {onError: future[_completeError], onDone: (() => {
             future._completeError(new core.RangeError.index(index, this, "index", null, elementIndex));
@@ skipping 74 matching lines @@
       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 = this[_createSubscription](onData, onError, onDone, cancelOnError);
         this[_onListen](subscription);
         return dart.as(subscription, StreamSubscription$(T));
       }
       [_createSubscription](onData, onError, onDone, cancelOnError) {
-        return new _BufferingStreamSubscription(onData, onError, onDone, cancelOnError);
+        return new (_BufferingStreamSubscription$(T))(onData, onError, onDone, cancelOnError);
       }
       [_onListen](subscription) {}
     }
     return _StreamImpl;
   });
   let _StreamImpl = _StreamImpl$(dart.dynamic);
   let _ControllerStream$ = dart.generic(function(T) {
     class _ControllerStream extends _StreamImpl$(T) {
       _ControllerStream(controller$) {
         this[_controller] = controller$;
@@ skipping 167 matching lines @@
       cancel() {
         this[_state] = ~dart.notNull(_BufferingStreamSubscription[_STATE_WAIT_FOR_CANCEL]);
         if (this[_isCanceled])
           return this[_cancelFuture];
         this[_cancel]();
         return this[_cancelFuture];
       }
       asFuture(futureValue) {
         if (futureValue === void 0)
           futureValue = null;
-        let result = new _Future();
+        let result = new (_Future$(T))();
         this[_onDone] = (() => {
           result._complete(futureValue);
         }).bind(this);
         this[_onError] = ((error, stackTrace) => {
           this.cancel();
           result._completeError(error, dart.as(stackTrace, core.StackTrace));
         }).bind(this);
         return result;
       }
       get [_isInputPaused]() {
@@ skipping 290 matching lines @@
         this[_onListen] = onListen$;
         this[_onCancel] = onCancel$;
         this[_state] = _BroadcastStreamController[_STATE_INITIAL];
         this[_next] = null;
         this[_previous] = null;
         this[_addStreamState] = null;
         this[_doneFuture] = null;
         this[_next] = this[_previous] = this;
       }
       get stream() {
-        return new _BroadcastStream(this);
+        return new (_BroadcastStream$(T))(this);
       }
       get sink() {
-        return new _StreamSinkWrapper(this);
+        return new (_StreamSinkWrapper$(T))(this);
       }
       get isClosed() {
         return (dart.notNull(this[_state]) & dart.notNull(_BroadcastStreamController[_STATE_CLOSED])) != 0;
       }
       get isPaused() {
         return false;
       }
       get hasListener() {
         return !dart.notNull(this[_isEmpty]);
       }
@@ skipping 32 matching lines @@
         let previous = subscription[_previous];
         let next = subscription[_next];
         previous[_next] = next;
         next[_previous] = previous;
         subscription[_next] = subscription[_previous] = subscription;
       }
       [_subscribe](onData, onError, onDone, cancelOnError) {
         if (this.isClosed) {
           if (onDone == null)
             onDone = _nullDoneHandler;
-          return new _DoneStreamSubscription(onDone);
+          return new (_DoneStreamSubscription$(T))(onDone);
         }
-        let subscription = new _BroadcastSubscription(this, onData, onError, onDone, cancelOnError);
+        let subscription = new (_BroadcastSubscription$(T))(this, onData, onError, onDone, cancelOnError);
         this[_addListener](dart.as(subscription, _BroadcastSubscription$(T)));
         if (core.identical(this[_next], this[_previous])) {
           _runGuarded(this[_onListen]);
         }
         return dart.as(subscription, StreamSubscription$(T));
       }
       [_recordCancel](subscription) {
         if (core.identical(subscription[_next], subscription))
           return null;
         dart.assert(!dart.notNull(core.identical(subscription[_next], subscription)));
@@ skipping 205 matching lines @@
         return dart.notNull(this[_pending] != null) && !dart.notNull(this[_pending].isEmpty);
       }
       [_addPendingEvent](event) {
         if (this[_pending] == null) {
           this[_pending] = new _StreamImplEvents();
         }
         this[_pending].add(event);
       }
       add(data) {
         if (!dart.notNull(this.isClosed) && dart.notNull(this[_isFiring])) {
-          this[_addPendingEvent](new _DelayedData(data));
+          this[_addPendingEvent](new (_DelayedData$(T))(data));
           return;
         }
         super.add(data);
         while (this[_hasPending]) {
           this[_pending].handleNext(this);
         }
       }
       addError(error, stackTrace) {
         if (stackTrace === void 0)
           stackTrace = null;
@@ skipping 86 matching lines @@
       this[_s] = s$;
     }
     toString() {
       return `DeferredLoadException: '${this[_s]}'`;
     }
   }
   DeferredLoadException[dart.implements] = () => [core.Exception];
   let Future$ = dart.generic(function(T) {
     class Future extends core.Object {
       Future(computation) {
-        let result = new _Future();
+        let result = new (_Future$(T))();
         Timer.run((() => {
           try {
             result._complete(computation());
           } catch (e) {
             let s = dart.stackTrace(e);
             _completeWithErrorCallback(result, e, s);
           }
 
         }).bind(this));
         return dart.as(result, Future$(T));
       }
       microtask(computation) {
-        let result = new _Future();
+        let result = new (_Future$(T))();
         scheduleMicrotask((() => {
           try {
             result._complete(computation());
           } catch (e) {
             let s = dart.stackTrace(e);
             _completeWithErrorCallback(result, e, s);
           }
 
         }).bind(this));
         return dart.as(result, Future$(T));
       }
       sync(computation) {
         try {
           let result = computation();
-          return new Future.value(result);
+          return new Future$(T).value(result);
         } catch (error) {
           let stackTrace = dart.stackTrace(error);
-          return new Future.error(error, stackTrace);
+          return new Future$(T).error(error, stackTrace);
         }
 
       }
       value(value) {
         if (value === void 0)
           value = null;
-        return new _Future.immediate(value);
+        return new _Future$(T).immediate(value);
       }
       error(error, stackTrace) {
         if (stackTrace === void 0)
           stackTrace = null;
         error = _nonNullError(error);
         if (!dart.notNull(core.identical(Zone.current, _ROOT_ZONE))) {
           let replacement = Zone.current.errorCallback(error, stackTrace);
           if (replacement != null) {
             error = _nonNullError(replacement.error);
             stackTrace = replacement.stackTrace;
           }
         }
-        return new _Future.immediateError(error, stackTrace);
+        return new _Future$(T).immediateError(error, stackTrace);
       }
       delayed(duration, computation) {
         if (computation === void 0)
           computation = null;
-        let result = new _Future();
+        let result = new (_Future$(T))();
         new Timer(duration, (() => {
           try {
             result._complete(computation == null ? null : computation());
           } catch (e) {
             let s = dart.stackTrace(e);
             _completeWithErrorCallback(result, e, s);
           }
 
         }).bind(this));
         return dart.as(result, Future$(T));
       }
       static wait(futures, opts) {
         let eagerError = opts && 'eagerError' in opts ? opts.eagerError : false;
         let cleanUp = opts && 'cleanUp' in opts ? opts.cleanUp : null;
-        let result = new _Future();
+        let result = new (_Future$(core.List))();
         let values = null;
         let remaining = 0;
         let error = null;
         let stackTrace = null;
         // Function handleError: (dynamic, dynamic) → void
         function handleError(theError, theStackTrace) {
           remaining = dart.notNull(remaining) - 1;
           if (values != null) {
             if (cleanUp != null) {
               for (let value of values) {
@@ skipping 90 matching lines @@
         result = `TimeoutException after ${this.duration}`;
       if (this.message != null)
         result = `${result}: ${this.message}`;
       return result;
     }
   }
   TimeoutException[dart.implements] = () => [core.Exception];
   let Completer$ = dart.generic(function(T) {
     class Completer extends core.Object {
       Completer() {
-        return new _AsyncCompleter();
+        return new (_AsyncCompleter$(T))();
       }
       sync() {
-        return new _SyncCompleter();
+        return new (_SyncCompleter$(T))();
       }
     }
     dart.defineNamedConstructor(Completer, 'sync');
     return Completer;
   });
   let Completer = Completer$(dart.dynamic);
   // Function _completeWithErrorCallback: (_Future<dynamic>, dynamic, dynamic) → void
   function _completeWithErrorCallback(result, error, stackTrace) {
     let replacement = Zone.current.errorCallback(error, dart.as(stackTrace, core.StackTrace));
     if (replacement != null) {
       error = _nonNullError(replacement.error);
       stackTrace = replacement.stackTrace;
     }
     result._completeError(error, dart.as(stackTrace, core.StackTrace));
   }
   // Function _nonNullError: (Object) → Object
   function _nonNullError(error) {
     return error != null ? error : new core.NullThrownError();
   }
   let _Completer$ = dart.generic(function(T) {
     class _Completer extends core.Object {
       _Completer() {
-        this.future = new _Future();
+        this.future = new (_Future$(T))();
       }
       completeError(error, stackTrace) {
         if (stackTrace === void 0)
           stackTrace = null;
         error = _nonNullError(error);
         if (!dart.notNull(this.future[_mayComplete]))
           throw new core.StateError("Future already completed");
         let replacement = Zone.current.errorCallback(error, stackTrace);
         if (replacement != null) {
           error = _nonNullError(replacement.error);
@@ skipping 204 matching lines @@
         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");
         }
         this[_addListener](new _FutureListener.catchError(result, onError, test));
         return result;
       }
       whenComplete(action) {
-        let result = new _Future();
+        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));
         return dart.as(result, Future$(T));
       }
       asStream() {
         return dart.as(new Stream.fromFuture(this), Stream$(T));
       }
       [_markPendingCompletion]() {
@@ skipping 542 matching lines @@
         return new _StreamHandlerTransformer(opts);
       }
     }
     dart.defineNamedConstructor(StreamTransformer, 'fromHandlers');
     return StreamTransformer;
   });
   let StreamTransformer = StreamTransformer$(dart.dynamic, dart.dynamic);
   let StreamIterator$ = dart.generic(function(T) {
     class StreamIterator extends core.Object {
       StreamIterator(stream) {
-        return new _StreamIteratorImpl(stream);
+        return new (_StreamIteratorImpl$(T))(stream);
       }
     }
     return StreamIterator;
   });
   let StreamIterator = StreamIterator$(dart.dynamic);
   let _ControllerEventSinkWrapper$ = dart.generic(function(T) {
     class _ControllerEventSinkWrapper extends core.Object {
       _ControllerEventSinkWrapper(sink$) {
         this[_sink] = sink$;
       }
@@ skipping 17 matching lines @@
     class StreamController extends core.Object {
       StreamController(opts) {
         let onListen = opts && 'onListen' in opts ? opts.onListen : null;
         let onPause = opts && 'onPause' in opts ? opts.onPause : null;
         let onResume = opts && 'onResume' in opts ? opts.onResume : null;
         let onCancel = opts && 'onCancel' in opts ? opts.onCancel : null;
         let sync = opts && 'sync' in opts ? opts.sync : false;
         if (dart.notNull(onListen == null) && dart.notNull(onPause == null) && dart.notNull(onResume == null) && dart.notNull(onCancel == null)) {
           return dart.as(sync ? new _NoCallbackSyncStreamController() : new _NoCallbackAsyncStreamController(), StreamController$(T));
         }
-        return sync ? new _SyncStreamController(onListen, onPause, onResume, onCancel) : new _AsyncStreamController(onListen, onPause, onResume, onCancel);
+        return sync ? new (_SyncStreamController$(T))(onListen, onPause, onResume, onCancel) : new (_AsyncStreamController$(T))(onListen, onPause, onResume, onCancel);
       }
       broadcast(opts) {
         let onListen = opts && 'onListen' in opts ? opts.onListen : null;
         let onCancel = opts && 'onCancel' in opts ? opts.onCancel : null;
         let sync = opts && 'sync' in opts ? opts.sync : false;
-        return sync ? new _SyncBroadcastStreamController(onListen, onCancel) : new _AsyncBroadcastStreamController(onListen, onCancel);
+        return sync ? new (_SyncBroadcastStreamController$(T))(onListen, onCancel) : new (_AsyncBroadcastStreamController$(T))(onListen, onCancel);
       }
     }
     StreamController[dart.implements] = () => [StreamSink$(T)];
     dart.defineNamedConstructor(StreamController, 'broadcast');
     return StreamController;
   });
   let StreamController = StreamController$(dart.dynamic);
   let _StreamControllerLifecycle$ = dart.generic(function(T) {
     class _StreamControllerLifecycle extends core.Object {
       [_recordPause](subscription) {}
@@ skipping 19 matching lines @@
     class _StreamController extends core.Object {
       _StreamController() {
         this[_varData] = null;
         this[_state] = _StreamController[_STATE_INITIAL];
         this[_doneFuture] = null;
       }
       get stream() {
         return dart.as(new _ControllerStream(this), Stream$(T));
       }
       get sink() {
-        return new _StreamSinkWrapper(this);
+        return new (_StreamSinkWrapper$(T))(this);
       }
       get [_isCanceled]() {
         return (dart.notNull(this[_state]) & dart.notNull(_StreamController[_STATE_CANCELED])) != 0;
       }
       get hasListener() {
         return (dart.notNull(this[_state]) & dart.notNull(_StreamController[_STATE_SUBSCRIBED])) != 0;
       }
       get [_isInitialState]() {
         return (dart.notNull(this[_state]) & dart.notNull(_StreamController[_STATE_SUBSCRIPTION_MASK])) == _StreamController[_STATE_INITIAL];
       }
@@ skipping 96 matching lines @@
         if (this.hasListener) {
           this[_sendDone]();
         } else if (this[_isInitialState]) {
           this[_ensurePendingEvents]().add(new _DelayedDone());
         }
       }
       [_add](value) {
         if (this.hasListener) {
           this[_sendData](value);
         } else if (this[_isInitialState]) {
-          this[_ensurePendingEvents]().add(new _DelayedData(value));
+          this[_ensurePendingEvents]().add(new (_DelayedData$(T))(value));
         }
       }
       [_addError](error, stackTrace) {
         if (this.hasListener) {
           this[_sendError](error, stackTrace);
         } else if (this[_isInitialState]) {
           this[_ensurePendingEvents]().add(new _DelayedError(error, stackTrace));
         }
       }
       [_close]() {
@@ skipping 557 matching lines @@
   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[_zone] = Zone.current;
         this[_controller] = null;
         this[_subscription] = null;
         super.Stream();
-        this[_controller] = new _AsBroadcastStreamController(this[_onListen], this[_onCancel]);
+        this[_controller] = new (_AsBroadcastStreamController$(T))(this[_onListen], this[_onCancel]);
       }
       get isBroadcast() {
         return true;
       }
       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;
         if (dart.notNull(this[_controller] == null) || dart.notNull(this[_controller].isClosed)) {
-          return new _DoneStreamSubscription(onDone);
+          return new (_DoneStreamSubscription$(T))(onDone);
         }
         if (this[_subscription] == null) {
           this[_subscription] = this[_source].listen(this[_controller].add, {onError: this[_controller].addError, onDone: this[_controller].close});
         }
         cancelOnError = core.identical(true, cancelOnError);
         return this[_controller]._subscribe(onData, onError, onDone, cancelOnError);
       }
       [_onCancel]() {
         let shutdown = dart.notNull(this[_controller] == null) || dart.notNull(this[_controller].isClosed);
         if (this[_onCancelHandler] != null) {
@@ skipping 93 matching lines @@
         this[_current] = null;
         this[_futureOrPrefetch] = null;
         this[_state] = _StreamIteratorImpl[_STATE_FOUND];
         this[_subscription] = stream.listen(this[_onData], {onError: this[_onError], onDone: this[_onDone], cancelOnError: true});
       }
       get current() {
         return this[_current];
       }
       moveNext() {
         if (this[_state] == _StreamIteratorImpl[_STATE_DONE]) {
-          return new _Future.immediate(false);
+          return new _Future$(core.bool).immediate(false);
         }
         if (this[_state] == _StreamIteratorImpl[_STATE_MOVING]) {
           throw new core.StateError("Already waiting for next.");
         }
         if (this[_state] == _StreamIteratorImpl[_STATE_FOUND]) {
           this[_state] = _StreamIteratorImpl[_STATE_MOVING];
           this[_current] = null;
-          this[_futureOrPrefetch] = new _Future();
+          this[_futureOrPrefetch] = new (_Future$(core.bool))();
           return dart.as(this[_futureOrPrefetch], Future$(core.bool));
         } else {
           dart.assert(dart.notNull(this[_state]) >= dart.notNull(_StreamIteratorImpl[_STATE_EXTRA_DATA]));
           switch (this[_state]) {
             case _StreamIteratorImpl[_STATE_EXTRA_DATA]:
             {
               this[_state] = _StreamIteratorImpl[_STATE_FOUND];
               this[_current] = dart.as(this[_futureOrPrefetch], T);
               this[_futureOrPrefetch] = null;
               this[_subscription].resume();
-              return new _Future.immediate(true);
+              return new _Future$(core.bool).immediate(true);
             }
             case _StreamIteratorImpl[_STATE_EXTRA_ERROR]:
             {
               let prefetch = dart.as(this[_futureOrPrefetch], AsyncError);
               this[_clear]();
-              return new _Future.immediateError(prefetch.error, prefetch.stackTrace);
+              return new _Future$(core.bool).immediateError(prefetch.error, prefetch.stackTrace);
             }
             case _StreamIteratorImpl[_STATE_EXTRA_DONE]:
             {
               this[_clear]();
-              return new _Future.immediate(false);
+              return new _Future$(core.bool).immediate(false);
             }
           }
         }
       }
       [_clear]() {
         this[_subscription] = null;
         this[_futureOrPrefetch] = null;
         this[_current] = null;
         this[_state] = _StreamIteratorImpl[_STATE_DONE];
       }
@@ skipping 119 matching lines @@
         return this[_source].isBroadcast;
       }
       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);
         return this[_createSubscription](onData, onError, onDone, cancelOnError);
       }
       [_createSubscription](onData, onError, onDone, cancelOnError) {
-        return new _ForwardingStreamSubscription(this, onData, onError, onDone, cancelOnError);
+        return new (_ForwardingStreamSubscription$(S, T))(this, onData, onError, onDone, cancelOnError);
       }
       [_handleData](data, sink) {
         let outputData = data;
         sink._add(outputData);
       }
       [_handleError](error, stackTrace, sink) {
         sink._addError(error, stackTrace);
       }
       [_handleDone](sink) {
         sink._close();
@@ skipping 335 matching lines @@
   });
   let _EventSinkWrapper = _EventSinkWrapper$(dart.dynamic);
   let _transformerSink = Symbol('_transformerSink');
   let _isSubscribed = Symbol('_isSubscribed');
   let _SinkTransformerStreamSubscription$ = dart.generic(function(S, T) {
     class _SinkTransformerStreamSubscription extends _BufferingStreamSubscription$(T) {
       _SinkTransformerStreamSubscription(source, mapper, onData, onError, onDone, cancelOnError) {
         this[_transformerSink] = null;
         this[_subscription] = null;
         super._BufferingStreamSubscription(onData, onError, onDone, cancelOnError);
-        let eventSink = new _EventSinkWrapper(this);
+        let eventSink = new (_EventSinkWrapper$(T))(this);
         this[_transformerSink] = mapper(eventSink);
         this[_subscription] = source.listen(this[_handleData], {onError: this[_handleError], onDone: this[_handleDone]});
       }
       get [_isSubscribed]() {
         return this[_subscription] != null;
       }
       [_add](data) {
         if (this[_isClosed]) {
           throw new core.StateError("Stream is already closed");
         }
@@ skipping 65 matching lines @@
     return _SinkTransformerStreamSubscription;
   });
   let _SinkTransformerStreamSubscription = _SinkTransformerStreamSubscription$(dart.dynamic, dart.dynamic);
   let _sinkMapper = Symbol('_sinkMapper');
   let _StreamSinkTransformer$ = dart.generic(function(S, T) {
     class _StreamSinkTransformer extends core.Object {
       _StreamSinkTransformer(sinkMapper) {
         this[_sinkMapper] = sinkMapper;
       }
       bind(stream) {
-        return new _BoundSinkStream(stream, this[_sinkMapper]);
+        return new (_BoundSinkStream$(S, T))(stream, this[_sinkMapper]);
       }
     }
     _StreamSinkTransformer[dart.implements] = () => [StreamTransformer$(S, T)];
     return _StreamSinkTransformer;
   });
   let _StreamSinkTransformer = _StreamSinkTransformer$(dart.dynamic, dart.dynamic);
   let _BoundSinkStream$ = dart.generic(function(S, T) {
     class _BoundSinkStream extends Stream$(T) {
       get isBroadcast() {
         return this[_stream].isBroadcast;
@@ skipping 48 matching lines @@
         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) => {
           if (handleData == null)
             handleData = dart.closureWrap(_StreamHandlerTransformer[_defaultHandleData], "(S, EventSink<T>) → void");
           if (handleError == null)
             handleError = dart.closureWrap(_StreamHandlerTransformer[_defaultHandleError], "(Object, StackTrace, EventSink<T>) → void");
           if (handleDone == null)
             handleDone = _StreamHandlerTransformer[_defaultHandleDone];
-          return new _HandlerEventSink(handleData, handleError, handleDone, outputSink);
+          return new (_HandlerEventSink$(S, T))(handleData, handleError, handleDone, outputSink);
         }, "(EventSink<T>) → EventSink<S>"));
       }
       bind(stream) {
         return super.bind(stream);
       }
       static [_defaultHandleData](data, sink) {
         sink.add(data);
       }
       static [_defaultHandleError](error, stackTrace, sink) {
         sink.addError(error);
       }
       static [_defaultHandleDone](sink) {
         sink.close();
       }
     }
     return _StreamHandlerTransformer;
   });
   let _StreamHandlerTransformer = _StreamHandlerTransformer$(dart.dynamic, dart.dynamic);
   let _transformer = Symbol('_transformer');
   let _StreamSubscriptionTransformer$ = dart.generic(function(S, T) {
     class _StreamSubscriptionTransformer extends core.Object {
       _StreamSubscriptionTransformer(transformer$) {
         this[_transformer] = transformer$;
       }
       bind(stream) {
-        return new _BoundSubscriptionStream(stream, this[_transformer]);
+        return new (_BoundSubscriptionStream$(S, T))(stream, this[_transformer]);
       }
     }
     _StreamSubscriptionTransformer[dart.implements] = () => [StreamTransformer$(S, T)];
     return _StreamSubscriptionTransformer;
   });
   let _StreamSubscriptionTransformer = _StreamSubscriptionTransformer$(dart.dynamic, dart.dynamic);
   let _BoundSubscriptionStream$ = dart.generic(function(S, T) {
     class _BoundSubscriptionStream extends Stream$(T) {
       _BoundSubscriptionStream(stream$, transformer$) {
         this[_stream] = stream$;
@@ skipping 821 matching lines @@
   exports.StreamIterator = StreamIterator;
   exports.StreamIterator$ = StreamIterator$;
   exports.StreamController = StreamController;
   exports.StreamController$ = StreamController$;
   exports.Timer = Timer;
   exports.ZoneSpecification = ZoneSpecification;
   exports.ZoneDelegate = ZoneDelegate;
   exports.Zone = Zone;
   exports.runZoned = runZoned;
 })(async || (async = {}));