Generate static calls for Object fields and methods

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.dcall(errorHandler, error, stackTrace);
     } else {
       return dart.dcall(errorHandler, error);
     }
   }
   // Function _registerErrorHandler: (Function, Zone) → Function
   function _registerErrorHandler(errorHandler, zone) {
     if (dart.is(errorHandler, ZoneBinaryCallback)) {
       return zone.registerBinaryCallback(errorHandler);
     } else {
       return zone.registerUnaryCallback(dart.as(errorHandler, __CastType0));
     }
   }
   let _getBestStackTrace = Symbol('_getBestStackTrace');
   class AsyncError extends core.Object {
     AsyncError(error, stackTrace) {
       this.error = error;
       this.stackTrace = stackTrace;
     }
     toString() {
-      return this.error.toString();
+      return dart.toString(this.error);
     }
   }
   AsyncError[dart.implements] = () => [core.Error];
   class _UncaughtAsyncError extends AsyncError {
     _UncaughtAsyncError(error, stackTrace) {
       super.AsyncError(error, _UncaughtAsyncError[_getBestStackTrace](error, stackTrace));
     }
     static [_getBestStackTrace](error, stackTrace) {
       if (stackTrace != null)
         return stackTrace;
@@ skipping 295 matching lines @@
           } catch (e) {
             let s = dart.stackTrace(e);
             _cancelAndErrorWithReplacement(subscription, result, e, s);
           }
 
         }, {
           onError: e => {
             result[_completeError](e);
           },
           onDone: () => {
-            result[_complete](buffer.toString());
+            result[_complete](dart.toString(buffer));
           },
           cancelOnError: true
         });
         return result;
       }
       contains(needle) {
         let future = new (_Future$(core.bool))();
         let subscription = null;
         subscription = this.listen(element => {
           _runUserCode(() => dart.equals(element, needle), isMatch => {
@@ skipping 440 matching lines @@
   let _StreamImpl = _StreamImpl$();
   let _ControllerStream$ = dart.generic(function(T) {
     class _ControllerStream extends _StreamImpl$(T) {
       _ControllerStream(controller) {
         this[_controller] = controller;
       }
       [_createSubscription](onData, onError, onDone, cancelOnError) {
         return this[_controller][_subscribe](onData, onError, onDone, cancelOnError);
       }
       get hashCode() {
-        return dart.notNull(this[_controller].hashCode) ^ 892482866;
+        return dart.notNull(dart.hashCode(this[_controller])) ^ 892482866;
       }
       ['=='](other) {
         if (core.identical(this, other))
           return true;
         if (!dart.is(other, _ControllerStream))
           return false;
         let otherStream = dart.as(other, _ControllerStream);
         return core.identical(otherStream[_controller], this[_controller]);
       }
     }
@@ skipping 855 matching lines @@
   class DeferredLoadException extends core.Object {
     DeferredLoadException(s) {
       this[_s] = s;
     }
     toString() {
       return `DeferredLoadException: '${this[_s]}'`;
     }
   }
   DeferredLoadException[dart.implements] = () => [core.Exception];
   let _completeWithValue = Symbol('_completeWithValue');
+  let _nullFuture = Symbol('_nullFuture');
   let Future$ = dart.generic(function(T) {
     class Future extends core.Object {
       Future(computation) {
         let result = new (_Future$(T))();
         Timer.run(() => {
           try {
             result[_complete](computation());
           } catch (e) {
             let s = dart.stackTrace(e);
             _completeWithErrorCallback(result, e, s);
@@ skipping 139 matching lines @@
         dart.dcall(nextIteration, true);
         return doneSignal;
       }
     }
     dart.defineNamedConstructor(Future, 'microtask');
     dart.defineNamedConstructor(Future, 'sync');
     dart.defineNamedConstructor(Future, 'value');
     dart.defineNamedConstructor(Future, 'error');
     dart.defineNamedConstructor(Future, 'delayed');
     dart.defineLazyProperties(Future, {
-      get _nullFuture() {
+      get [_nullFuture]() {
         return new Future.value(null);
       }
     });
     return Future;
   });
   let Future = Future$();
   class TimeoutException extends core.Object {
     TimeoutException(message, duration) {
       if (duration === void 0)
         duration = null;
@@ skipping 917 matching lines @@
   });
   let _StreamControllerLifecycle = _StreamControllerLifecycle$();
   let _varData = Symbol('_varData');
   let _STATE_SUBSCRIBED = Symbol('_STATE_SUBSCRIBED');
   let _isInitialState = Symbol('_isInitialState');
   let _STATE_SUBSCRIPTION_MASK = Symbol('_STATE_SUBSCRIPTION_MASK');
   let _subscription = Symbol('_subscription');
   let _pendingEvents = Symbol('_pendingEvents');
   let _ensurePendingEvents = Symbol('_ensurePendingEvents');
   let _badEventState = Symbol('_badEventState');
-  let _nullFuture = Symbol('_nullFuture');
   let _StreamController$ = dart.generic(function(T) {
     class _StreamController extends core.Object {
       _StreamController() {
         this[_varData] = null;
         this[_state] = _StreamController[_STATE_INITIAL];
         this[_doneFuture] = null;
       }
       get stream() {
         return new (_ControllerStream$(T))(this);
       }
@@ skipping 1323 matching lines @@
           }
 
           if (!dart.notNull(isEqual)) {
             sink[_add](inputEvent);
             this[_previous] = inputEvent;
           }
         }
       }
     }
     dart.defineLazyProperties(_DistinctStream, {
-      get _SENTINEL() {
+      get [_SENTINEL]() {
         return new core.Object();
       },
-      set _SENTINEL(_) {}
+      set [_SENTINEL](_) {}
     });
     return _DistinctStream;
   });
   let _DistinctStream = _DistinctStream$();
   let _EventSinkWrapper$ = dart.generic(function(T) {
     class _EventSinkWrapper extends core.Object {
       _EventSinkWrapper(sink) {
         this[_sink] = sink;
       }
       add(data) {
@@ skipping 1003 matching lines @@
     }
     createPeriodicTimer(duration, f) {
       return Timer[_createPeriodicTimer](duration, f);
     }
     print(line) {
       _internal.printToConsole(line);
     }
   }
   _RootZone._rootDelegate = null;
   dart.defineLazyProperties(_RootZone, {
-    get _rootMap() {
+    get [_rootMap]() {
       return new collection.HashMap();
     },
-    set _rootMap(_) {}
+    set [_rootMap](_) {}
   });
   let _ROOT_ZONE = dart.const(new _RootZone());
   // Function runZoned: (() → dynamic, {zoneValues: Map<dynamic, dynamic>, zoneSpecification: ZoneSpecification, onError: Function}) → dynamic
   function runZoned(body, opts) {
     let zoneValues = opts && 'zoneValues' in opts ? opts.zoneValues : null;
     let zoneSpecification = opts && 'zoneSpecification' in opts ? opts.zoneSpecification : null;
     let onError = opts && 'onError' in opts ? opts.onError : null;
     let errorHandler = null;
     if (onError != null) {
       errorHandler = (self, parent, zone, error, stackTrace) => {
@@ skipping 88 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 = {}));