fixes #52, fields shadowing getters/setters or other fields

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, dart.functionType(dart.dynamic, [dart.dynamic])));
     }
   }
   let _getBestStackTrace = Symbol('_getBestStackTrace');
+  let error$ = Symbol('error');
+  let stackTrace$ = Symbol('stackTrace');
   class AsyncError extends core.Object {
+    get error() {
+      return this[error$];
+    }
+    get stackTrace() {
+      return this[stackTrace$];
+    }
     AsyncError(error, stackTrace) {
-      this.error = error;
-      this.stackTrace = stackTrace;
+      this[error$] = error;
+      this[stackTrace$] = stackTrace;
     }
     toString() {
       return this.error.toString();
     }
   }
   AsyncError[dart.implements] = () => [core.Error];
   class _UncaughtAsyncError extends AsyncError {
     _UncaughtAsyncError(error, stackTrace) {
       super.AsyncError(error, _UncaughtAsyncError[_getBestStackTrace](error, stackTrace));
     }
@@ skipping 804 matching lines @@
   let _expectsEvent = Symbol('_expectsEvent');
   let _STATE_EVENT_ID = Symbol('_STATE_EVENT_ID');
   let _toggleEventId = Symbol('_toggleEventId');
   let _isFiring = Symbol('_isFiring');
   let _STATE_FIRING = Symbol('_STATE_FIRING');
   let _setRemoveAfterFiring = Symbol('_setRemoveAfterFiring');
   let _STATE_REMOVE_AFTER_FIRING = Symbol('_STATE_REMOVE_AFTER_FIRING');
   let _removeAfterFiring = Symbol('_removeAfterFiring');
   let _onPause = Symbol('_onPause');
   let _onResume = Symbol('_onResume');
+  let _controller$ = Symbol('_controller');
   let _onCancel = Symbol('_onCancel');
   let _recordCancel = Symbol('_recordCancel');
   let _recordPause = Symbol('_recordPause');
   let _recordResume = Symbol('_recordResume');
+  let _STATE_CANCEL_ON_ERROR = Symbol('_STATE_CANCEL_ON_ERROR');
   let _zone = Symbol('_zone');
   let _state = Symbol('_state');
-  let _STATE_CANCEL_ON_ERROR = Symbol('_STATE_CANCEL_ON_ERROR');
   let _onData = Symbol('_onData');
   let _onError = Symbol('_onError');
   let _onDone = Symbol('_onDone');
   let _cancelFuture = Symbol('_cancelFuture');
   let _pending = Symbol('_pending');
   let _setPendingEvents = Symbol('_setPendingEvents');
   let _STATE_HAS_PENDING = Symbol('_STATE_HAS_PENDING');
   let _extractPending = Symbol('_extractPending');
   let _isCanceled = Symbol('_isCanceled');
   let _isPaused = Symbol('_isPaused');
@@ skipping 325 matching lines @@
     _BufferingStreamSubscription._STATE_WAIT_FOR_CANCEL = 16;
     _BufferingStreamSubscription._STATE_IN_CALLBACK = 32;
     _BufferingStreamSubscription._STATE_HAS_PENDING = 64;
     _BufferingStreamSubscription._STATE_PAUSE_COUNT = 128;
     _BufferingStreamSubscription._STATE_PAUSE_COUNT_SHIFT = 7;
     return _BufferingStreamSubscription;
   });
   let _BufferingStreamSubscription = _BufferingStreamSubscription$();
   let _ControllerSubscription$ = dart.generic(function(T) {
     class _ControllerSubscription extends _BufferingStreamSubscription$(T) {
+      get [_controller]() {
+        return this[_controller$];
+      }
       _ControllerSubscription(controller, onData, onError, onDone, cancelOnError) {
-        this[_controller] = controller;
+        this[_controller$] = controller;
         super._BufferingStreamSubscription(onData, onError, onDone, cancelOnError);
       }
       [_onCancel]() {
         return this[_controller][_recordCancel](this);
       }
       [_onPause]() {
         this[_controller][_recordPause](this);
       }
       [_onResume]() {
         this[_controller][_recordResume](this);
@@ skipping 431 matching lines @@
       asFuture(value) {
         if (value === void 0)
           value = null;
         return new _Future();
       }
     }
     _DoneSubscription[dart.implements] = () => [StreamSubscription$(T)];
     return _DoneSubscription;
   });
   let _DoneSubscription = _DoneSubscription$();
+  let libraryName$ = Symbol('libraryName');
+  let uri$ = Symbol('uri');
   class DeferredLibrary extends core.Object {
+    get libraryName() {
+      return this[libraryName$];
+    }
+    get uri() {
+      return this[uri$];
+    }
     DeferredLibrary(libraryName, opts) {
       let uri = opts && 'uri' in opts ? opts.uri : null;
-      this.libraryName = libraryName;
-      this.uri = uri;
+      this[libraryName$] = libraryName;
+      this[uri$] = uri;
     }
     load() {
       throw 'DeferredLibrary not supported. ' + 'please use the `import "lib.dart" deferred as lib` syntax.';
     }
   }
   let _s = Symbol('_s');
   class DeferredLoadException extends core.Object {
     DeferredLoadException(s) {
       this[_s] = s;
     }
@@ skipping 162 matching lines @@
     dart.defineNamedConstructor(Future, 'error');
     dart.defineNamedConstructor(Future, 'delayed');
     dart.defineLazyProperties(Future, {
       get _nullFuture() {
         return new Future.value(null);
       }
     });
     return Future;
   });
   let Future = Future$();
+  let message$ = Symbol('message');
+  let duration$ = Symbol('duration');
   class TimeoutException extends core.Object {
+    get message() {
+      return this[message$];
+    }
+    get duration() {
+      return this[duration$];
+    }
     TimeoutException(message, duration) {
       if (duration === void 0)
         duration = null;
-      this.message = message;
-      this.duration = duration;
+      this[message$] = message;
+      this[duration$] = duration;
     }
     toString() {
       let result = "TimeoutException";
       if (this.duration != null)
         result = `TimeoutException after ${this.duration}`;
       if (this.message != null)
         result = `${result}: ${this.message}`;
       return result;
     }
   }
@@ skipping 1146 matching lines @@
         this[_subscription][_addPending](new _DelayedError(error, stackTrace));
       }
       [_sendDone]() {
         this[_subscription][_addPending](new _DelayedDone());
       }
     }
     _AsyncStreamControllerDispatch[dart.implements] = () => [_StreamController$(T)];
     return _AsyncStreamControllerDispatch;
   });
   let _AsyncStreamControllerDispatch = _AsyncStreamControllerDispatch$();
+  let _onListen$ = Symbol('_onListen');
+  let _onPause$ = Symbol('_onPause');
+  let _onResume$ = Symbol('_onResume');
+  let _onCancel$ = Symbol('_onCancel');
   let _AsyncStreamController$ = dart.generic(function(T) {
     class _AsyncStreamController extends dart.mixin(_StreamController$(T), _AsyncStreamControllerDispatch$(T)) {
+      get [_onListen]() {
+        return this[_onListen$];
+      }
+      get [_onPause]() {
+        return this[_onPause$];
+      }
+      get [_onResume]() {
+        return this[_onResume$];
+      }
+      get [_onCancel]() {
+        return this[_onCancel$];
+      }
       _AsyncStreamController(onListen, onPause, onResume, onCancel) {
-        this[_onListen] = onListen;
-        this[_onPause] = onPause;
-        this[_onResume] = onResume;
-        this[_onCancel] = onCancel;
+        this[_onListen$] = onListen;
+        this[_onPause$] = onPause;
+        this[_onResume$] = onResume;
+        this[_onCancel$] = onCancel;
         super._StreamController();
       }
     }
     return _AsyncStreamController;
   });
   let _AsyncStreamController = _AsyncStreamController$();
+  let _onListen$0 = Symbol('_onListen');
+  let _onPause$0 = Symbol('_onPause');
+  let _onResume$0 = Symbol('_onResume');
+  let _onCancel$0 = Symbol('_onCancel');
   let _SyncStreamController$ = dart.generic(function(T) {
     class _SyncStreamController extends dart.mixin(_StreamController$(T), _SyncStreamControllerDispatch$(T)) {
+      get [_onListen]() {
+        return this[_onListen$0];
+      }
+      get [_onPause]() {
+        return this[_onPause$0];
+      }
+      get [_onResume]() {
+        return this[_onResume$0];
+      }
+      get [_onCancel]() {
+        return this[_onCancel$0];
+      }
       _SyncStreamController(onListen, onPause, onResume, onCancel) {
-        this[_onListen] = onListen;
-        this[_onPause] = onPause;
-        this[_onResume] = onResume;
-        this[_onCancel] = onCancel;
+        this[_onListen$0] = onListen;
+        this[_onPause$0] = onPause;
+        this[_onResume$0] = onResume;
+        this[_onCancel$0] = onCancel;
         super._StreamController();
       }
     }
     return _SyncStreamController;
   });
   let _SyncStreamController = _SyncStreamController$();
   class _NoCallbacks extends core.Object {
     get [_onListen]() {
       return null;
     }
@@ skipping 512 matching lines @@
       asFuture(futureValue) {
         if (futureValue === void 0)
           futureValue = null;
         throw new core.UnsupportedError("Cannot change handlers of asBroadcastStream source subscription.");
       }
     }
     _BroadcastSubscriptionWrapper[dart.implements] = () => [StreamSubscription$(T)];
     return _BroadcastSubscriptionWrapper;
   });
   let _BroadcastSubscriptionWrapper = _BroadcastSubscriptionWrapper$();
+  let _STATE_FOUND = Symbol('_STATE_FOUND');
   let _current = Symbol('_current');
   let _futureOrPrefetch = Symbol('_futureOrPrefetch');
-  let _STATE_FOUND = Symbol('_STATE_FOUND');
   let _STATE_DONE = Symbol('_STATE_DONE');
   let _STATE_MOVING = Symbol('_STATE_MOVING');
   let _STATE_EXTRA_DATA = Symbol('_STATE_EXTRA_DATA');
   let _STATE_EXTRA_ERROR = Symbol('_STATE_EXTRA_ERROR');
   let _clear = Symbol('_clear');
   let _STATE_EXTRA_DONE = Symbol('_STATE_EXTRA_DONE');
   let _StreamIteratorImpl$ = dart.generic(function(T) {
     class _StreamIteratorImpl extends core.Object {
       _StreamIteratorImpl(stream) {
         this[_subscription] = null;
@@ skipping 1006 matching lines @@
   }
   _ZoneDelegate[dart.implements] = () => [ZoneDelegate];
   class _Zone extends core.Object {
     _Zone() {
     }
     inSameErrorZone(otherZone) {
       return dart.notNull(core.identical(this, otherZone)) || dart.notNull(core.identical(this.errorZone, otherZone.errorZone));
     }
   }
   _Zone[dart.implements] = () => [Zone];
+  let _runUnary$ = Symbol('_runUnary');
+  let _run$ = Symbol('_run');
+  let _runBinary$ = Symbol('_runBinary');
+  let _registerCallback$ = Symbol('_registerCallback');
+  let _registerUnaryCallback$ = Symbol('_registerUnaryCallback');
+  let _registerBinaryCallback$ = Symbol('_registerBinaryCallback');
+  let _errorCallback$ = Symbol('_errorCallback');
+  let _scheduleMicrotask$ = Symbol('_scheduleMicrotask');
+  let _createTimer$ = Symbol('_createTimer');
+  let _createPeriodicTimer$ = Symbol('_createPeriodicTimer');
+  let _print$ = Symbol('_print');
+  let _fork$ = Symbol('_fork');
+  let _handleUncaughtError$ = Symbol('_handleUncaughtError');
+  let parent$ = Symbol('parent');
+  let _map = Symbol('_map');
+  let _map$ = Symbol('_map');
   let _delegateCache = Symbol('_delegateCache');
-  let _map = Symbol('_map');
   class _CustomZone extends _Zone {
+    get [_runUnary]() {
+      return this[_runUnary$];
+    }
+    set [_runUnary](value) {
+      this[_runUnary$] = value;
+    }
+    get [_run]() {
+      return this[_run$];
+    }
+    set [_run](value) {
+      this[_run$] = value;
+    }
+    get [_runBinary]() {
+      return this[_runBinary$];
+    }
+    set [_runBinary](value) {
+      this[_runBinary$] = value;
+    }
+    get [_registerCallback]() {
+      return this[_registerCallback$];
+    }
+    set [_registerCallback](value) {
+      this[_registerCallback$] = value;
+    }
+    get [_registerUnaryCallback]() {
+      return this[_registerUnaryCallback$];
+    }
+    set [_registerUnaryCallback](value) {
+      this[_registerUnaryCallback$] = value;
+    }
+    get [_registerBinaryCallback]() {
+      return this[_registerBinaryCallback$];
+    }
+    set [_registerBinaryCallback](value) {
+      this[_registerBinaryCallback$] = value;
+    }
+    get [_errorCallback]() {
+      return this[_errorCallback$];
+    }
+    set [_errorCallback](value) {
+      this[_errorCallback$] = value;
+    }
+    get [_scheduleMicrotask]() {
+      return this[_scheduleMicrotask$];
+    }
+    set [_scheduleMicrotask](value) {
+      this[_scheduleMicrotask$] = value;
+    }
+    get [_createTimer]() {
+      return this[_createTimer$];
+    }
+    set [_createTimer](value) {
+      this[_createTimer$] = value;
+    }
+    get [_createPeriodicTimer]() {
+      return this[_createPeriodicTimer$];
+    }
+    set [_createPeriodicTimer](value) {
+      this[_createPeriodicTimer$] = value;
+    }
+    get [_print]() {
+      return this[_print$];
+    }
+    set [_print](value) {
+      this[_print$] = value;
+    }
+    get [_fork]() {
+      return this[_fork$];
+    }
+    set [_fork](value) {
+      this[_fork$] = value;
+    }
+    get [_handleUncaughtError]() {
+      return this[_handleUncaughtError$];
+    }
+    set [_handleUncaughtError](value) {
+      this[_handleUncaughtError$] = value;
+    }
+    get parent() {
+      return this[parent$];
+    }
+    get [_map$]() {
+      return this[_map];
+    }
     get [_delegate]() {
       if (this[_delegateCache] != null)
         return this[_delegateCache];
       this[_delegateCache] = new _ZoneDelegate(this);
       return this[_delegateCache];
     }
     _CustomZone(parent, specification, map) {
-      this.parent = parent;
+      this[parent$] = parent;
       this[_map] = map;
-      this[_runUnary] = null;
-      this[_run] = null;
-      this[_runBinary] = null;
-      this[_registerCallback] = null;
-      this[_registerUnaryCallback] = null;
-      this[_registerBinaryCallback] = null;
-      this[_errorCallback] = null;
-      this[_scheduleMicrotask] = null;
-      this[_createTimer] = null;
-      this[_createPeriodicTimer] = null;
-      this[_print] = null;
-      this[_fork] = null;
-      this[_handleUncaughtError] = null;
+      this[_runUnary$] = null;
+      this[_run$] = null;
+      this[_runBinary$] = null;
+      this[_registerCallback$] = null;
+      this[_registerUnaryCallback$] = null;
+      this[_registerBinaryCallback$] = null;
+      this[_errorCallback$] = null;
+      this[_scheduleMicrotask$] = null;
+      this[_createTimer$] = null;
+      this[_createPeriodicTimer$] = null;
+      this[_print$] = null;
+      this[_fork$] = null;
+      this[_handleUncaughtError$] = null;
       this[_delegateCache] = null;
       super._Zone();
       this[_run] = specification.run != null ? new _ZoneFunction(this, specification.run) : this.parent[_run];
       this[_runUnary] = specification.runUnary != null ? new _ZoneFunction(this, specification.runUnary) : this.parent[_runUnary];
       this[_runBinary] = specification.runBinary != null ? new _ZoneFunction(this, specification.runBinary) : this.parent[_runBinary];
       this[_registerCallback] = specification.registerCallback != null ? new _ZoneFunction(this, specification.registerCallback) : this.parent[_registerCallback];
       this[_registerUnaryCallback] = specification.registerUnaryCallback != null ? new _ZoneFunction(this, specification.registerUnaryCallback) : this.parent[_registerUnaryCallback];
       this[_registerBinaryCallback] = specification.registerBinaryCallback != null ? new _ZoneFunction(this, specification.registerBinaryCallback) : this.parent[_registerBinaryCallback];
       this[_errorCallback] = specification.errorCallback != null ? new _ZoneFunction(this, specification.errorCallback) : this.parent[_errorCallback];
       this[_scheduleMicrotask] = specification.scheduleMicrotask != null ? new _ZoneFunction(this, specification.scheduleMicrotask) : this.parent[_scheduleMicrotask];
@@ skipping 54 matching lines @@
     bindBinaryCallback(f, opts) {
       let runGuarded = opts && 'runGuarded' in opts ? opts.runGuarded : true;
       let registered = this.registerBinaryCallback(f);
       if (runGuarded) {
         return ((arg1, arg2) => this.runBinaryGuarded(registered, arg1, arg2)).bind(this);
       } else {
         return ((arg1, arg2) => this.runBinary(registered, arg1, arg2)).bind(this);
       }
     }
     get(key) {
-      let result = this[_map].get(key);
-      if (dart.notNull(result != null) || dart.notNull(this[_map].containsKey(key)))
+      let result = this[_map$].get(key);
+      if (dart.notNull(result != null) || dart.notNull(this[_map$].containsKey(key)))
         return result;
       if (this.parent != null) {
         let value = this.parent.get(key);
         if (value != null) {
-          this[_map].set(key, value);
+          this[_map$].set(key, value);
         }
         return value;
       }
       dart.assert(dart.equals(this, _ROOT_ZONE));
       return null;
     }
     handleUncaughtError(error, stackTrace) {
       let implementation = this[_handleUncaughtError];
       dart.assert(implementation != null);
       let parentDelegate = _parentDelegate(implementation.zone);
@@ skipping 166 matching lines @@
   function _rootFork(self, parent, zone, specification, zoneValues) {
     _internal.printToZone = _printToZone;
     if (specification == null) {
       specification = new ZoneSpecification();
     } else if (!dart.is(specification, _ZoneSpecification)) {
       throw new core.ArgumentError("ZoneSpecifications must be instantiated" + " with the provided constructor.");
     }
     let valueMap = null;
     if (zoneValues == null) {
       if (dart.is(zone, _Zone)) {
-        valueMap = zone[_map];
+        valueMap = zone[_map$];
       } else {
         valueMap = new collection.HashMap();
       }
     } else {
       valueMap = new collection.HashMap.from(zoneValues);
     }
     return new _CustomZone(dart.as(zone, _Zone), specification, valueMap);
   }
   class _RootZoneSpecification extends core.Object {
     get handleUncaughtError() {
@@ skipping 78 matching lines @@
     }
     get [_fork]() {
       return new _ZoneFunction(_ROOT_ZONE, _rootFork);
     }
     get [_handleUncaughtError]() {
       return new _ZoneFunction(_ROOT_ZONE, _rootHandleUncaughtError);
     }
     get parent() {
       return null;
     }
-    get [_map]() {
+    get [_map$]() {
       return _RootZone[_rootMap];
     }
     get [_delegate]() {
       if (_RootZone[_rootDelegate] != null)
         return _RootZone[_rootDelegate];
       return _RootZone[_rootDelegate] = new _ZoneDelegate(this);
     }
     get errorZone() {
       return this;
     }
@@ skipping 200 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 = {}));