fixes private named constructors

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 40 matching lines @@
   let _createSubscription = Symbol('_createSubscription');
   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() {
       }
-      Stream$fromFuture(future) {
+      fromFuture(future) {
         let controller = dart.as(new StreamController({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;
       }
-      Stream$fromIterable(data) {
+      fromIterable(data) {
         return new _GeneratedStreamImpl(() => new _IterablePendingEvents(data));
       }
-      Stream$periodic(period, computation) {
+      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() {
@@ skipping 24 matching lines @@
               startPeriodicTimer();
               sendEvent();
             });
           }).bind(this), onCancel: (() => {
             if (timer !== null)
               timer.cancel();
             timer = null;
           }).bind(this)});
         return controller.stream;
       }
-      Stream$eventTransformed(source, mapSink) {
+      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"));
       }
@@ skipping 1438 matching lines @@
           try {
             result._complete(computation());
           } catch (e) {
             let s = dart.stackTrace(e);
             _completeWithErrorCallback(result, e, s);
           }
 
         }).bind(this));
         return dart.as(result, Future$(T));
       }
-      Future$microtask(computation) {
+      microtask(computation) {
         let result = new _Future();
         scheduleMicrotask((() => {
           try {
             result._complete(computation());
           } catch (e) {
             let s = dart.stackTrace(e);
             _completeWithErrorCallback(result, e, s);
           }
 
         }).bind(this));
         return dart.as(result, Future$(T));
       }
-      Future$sync(computation) {
+      sync(computation) {
         try {
           let result = computation();
           return new Future.value(result);
         } catch (error) {
           let stackTrace = dart.stackTrace(error);
           return new Future.error(error, stackTrace);
         }
 
       }
-      Future$value(value) {
+      value(value) {
         if (value === void 0)
           value = null;
         return new _Future.immediate(value);
       }
-      Future$error(error, stackTrace) {
+      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);
       }
-      Future$delayed(duration, computation) {
+      delayed(duration, computation) {
         if (computation === void 0)
           computation = null;
         let result = new _Future();
         new Timer(duration, (() => {
           try {
             result._complete(computation === null ? null : computation());
           } catch (e) {
             let s = dart.stackTrace(e);
             _completeWithErrorCallback(result, e, s);
           }
@@ skipping 109 matching lines @@
       if (this.message !== null)
         result = `${result}: ${this.message}`;
       return result;
     }
   }
   let Completer$ = dart.generic(function(T) {
     class Completer extends core.Object {
       Completer() {
         return new _AsyncCompleter();
       }
-      Completer$sync() {
+      sync() {
         return new _SyncCompleter();
       }
     }
     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));
@@ skipping 62 matching lines @@
       }
     }
     return _SyncCompleter;
   });
   let _SyncCompleter = _SyncCompleter$(dart.dynamic);
   let _nextListener = Symbol('_nextListener');
   let _onValue = Symbol('_onValue');
   let _errorTest = Symbol('_errorTest');
   let _whenCompleteAction = Symbol('_whenCompleteAction');
   class _FutureListener extends core.Object {
-    _FutureListener$then(result, onValue, errorCallback) {
+    then(result, onValue, errorCallback) {
       this.result = result;
       this.callback = onValue;
       this.errorCallback = errorCallback;
       this.state = errorCallback === null ? _FutureListener.STATE_THEN : _FutureListener.STATE_THEN_ONERROR;
       this[_nextListener] = null;
     }
-    _FutureListener$catchError(result, errorCallback, test) {
+    catchError(result, errorCallback, test) {
       this.result = result;
       this.errorCallback = errorCallback;
       this.callback = test;
       this.state = test === null ? _FutureListener.STATE_CATCHERROR : _FutureListener.STATE_CATCHERROR_TEST;
       this[_nextListener] = null;
     }
-    _FutureListener$whenComplete(result, onComplete) {
+    whenComplete(result, onComplete) {
       this.result = result;
       this.callback = onComplete;
       this.errorCallback = null;
       this.state = _FutureListener.STATE_WHENCOMPLETE;
       this[_nextListener] = null;
     }
-    _FutureListener$chain(result) {
+    chain(result) {
       this.result = result;
       this.callback = null;
       this.errorCallback = null;
       this.state = _FutureListener.STATE_CHAIN;
       this[_nextListener] = null;
     }
     get [_zone]() {
       return this.result[_zone];
     }
     get handlesValue() {
@@ skipping 61 matching lines @@
   let _chainForeignFuture = Symbol('_chainForeignFuture');
   let _chainCoreFuture = Symbol('_chainCoreFuture');
   let _completeWithValue = Symbol('_completeWithValue');
   let _Future$ = dart.generic(function(T) {
     class _Future extends core.Object {
       _Future() {
         this[_zone] = Zone.current;
         this[_state] = _Future[_INCOMPLETE];
         this[_resultOrListeners] = null;
       }
-      _Future$immediate(value) {
+      immediate(value) {
         this[_zone] = Zone.current;
         this[_state] = _Future[_INCOMPLETE];
         this[_resultOrListeners] = null;
         this[_asyncComplete](value);
       }
-      _Future$immediateError(error, stackTrace) {
+      immediateError(error, stackTrace) {
         if (stackTrace === void 0)
           stackTrace = null;
         this[_zone] = Zone.current;
         this[_state] = _Future[_INCOMPLETE];
         this[_resultOrListeners] = null;
         this[_asyncCompleteError](error, stackTrace);
       }
       get [_mayComplete]() {
         return this[_state] === _Future[_INCOMPLETE];
       }
@@ skipping 584 matching lines @@
     class StreamSink extends core.Object {
     }
     return StreamSink;
   });
   let StreamSink = StreamSink$(dart.dynamic);
   let StreamTransformer$ = dart.generic(function(S, T) {
     class StreamTransformer extends core.Object {
       StreamTransformer(transformer) {
         return new _StreamSubscriptionTransformer(transformer);
       }
-      StreamTransformer$fromHandlers(opts) {
+      fromHandlers(opts) {
         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) {
@@ skipping 29 matching lines @@
         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);
       }
-      StreamController$broadcast(opts) {
+      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);
       }
     }
     dart.defineNamedConstructor(StreamController, 'broadcast');
     return StreamController;
   });
   let StreamController = StreamController$(dart.dynamic);
@@ skipping 1574 matching lines @@
   let _BoundSubscriptionStream = _BoundSubscriptionStream$(dart.dynamic, dart.dynamic);
   let _createTimer = Symbol('_createTimer');
   let _createPeriodicTimer = Symbol('_createPeriodicTimer');
   class Timer extends core.Object {
     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}));
     }
-    Timer$periodic(duration, callback) {
+    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"));
     }
     static run(callback) {
       new Timer(core.Duration.ZERO, callback);
     }
     static [_createTimer](duration, callback) {
       let milliseconds = duration.inMilliseconds;
@@ skipping 12 matching lines @@
   class _ZoneFunction extends core.Object {
     _ZoneFunction(zone, func) {
       this.zone = zone;
       this.function = func;
     }
   }
   class ZoneSpecification extends core.Object {
     ZoneSpecification(opts) {
       return new _ZoneSpecification(opts);
     }
-    ZoneSpecification$from(other, opts) {
+    from(other, opts) {
       let handleUncaughtError = opts && 'handleUncaughtError' in opts ? opts.handleUncaughtError : null;
       let run = opts && 'run' in opts ? opts.run : null;
       let runUnary = opts && 'runUnary' in opts ? opts.runUnary : null;
       let runBinary = opts && 'runBinary' in opts ? opts.runBinary : null;
       let registerCallback = opts && 'registerCallback' in opts ? opts.registerCallback : null;
       let registerUnaryCallback = opts && 'registerUnaryCallback' in opts ? opts.registerUnaryCallback : null;
       let registerBinaryCallback = opts && 'registerBinaryCallback' in opts ? opts.registerBinaryCallback : null;
       let errorCallback = opts && 'errorCallback' in opts ? opts.errorCallback : null;
       let scheduleMicrotask = opts && 'scheduleMicrotask' in opts ? opts.scheduleMicrotask : null;
       let createTimer = opts && 'createTimer' in opts ? opts.createTimer : null;
@@ skipping 29 matching lines @@
       this.errorCallback = errorCallback;
       this.scheduleMicrotask = scheduleMicrotask;
       this.createTimer = createTimer;
       this.createPeriodicTimer = createPeriodicTimer;
       this.print = print;
       this.fork = fork;
     }
   }
   class ZoneDelegate extends core.Object {
   }
+  let _$ = Symbol('_');
   let _enter = Symbol('_enter');
   let _leave = Symbol('_leave');
-  let _$ = Symbol('_');
   class Zone extends core.Object {
-    Zone$_() {
+    [_$]() {
     }
     static get current() {
       return Zone[_current];
     }
     static [_enter](zone) {
       dart.assert(zone !== null);
       dart.assert(!dart.notNull(core.identical(zone, Zone[_current])));
       let previous = Zone[_current];
       Zone[_current] = zone;
       return previous;
@@ skipping 692 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 = {}));