fix #552, Object members on native types

tool/input_sdk/private/ddc_runtime/generators.dart

 // Copyright (c) 2015, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 /// This library adapts ES6 generators to implement Dart's async/await.
 /// It's designed to interact with Dart's Future/Stream and follow Dart
 /// async/await semantics.
 /// See https://github.com/dart-lang/dev_compiler/issues/245 for ideas on
 /// reconciling Dart's Future and ES6 Promise.
 /// Inspired by `co`: https://github.com/tj/co/blob/master/index.js, which is a
@@ skipping 27 matching lines @@
     return next(iter.throw(err));
   }
   function next(ret) {
     if (ret.done) return ret.value;
     // Checks if the awaited value is a Future.
     let future = ret.value;
     if (!$instanceOf(future, ${getGenericClass(Future)})) {
       future = $Future.value(future);
     }
     // Chain the Future so `await` receives the Future's value.
-    return future.then($dynamicR)(onValue, {onError: onError});
+    return future.then($dynamic)(onValue, {onError: onError});
   }
   return ${getGenericClass(Future)}(T).new(function() {
     iter = $gen(...$args)[Symbol.iterator]();
     return onValue();
   });
 })()''');
 
 // Implementation inspired by _AsyncStarStreamController in
 // dart-lang/sdk's runtime/lib/core_patch.dart
 //
@@ skipping 98 matching lines @@
       // waiting on this Future. Make sure to prevent scheduling, and pass the
       // value back as the result of the `yield`.
       //
       // TODO(jmesserly): is the timing here correct? The assumption here is
       // that we should schedule `await` in `async*` the same as in `async`.
       this.isWaiting = true;
       let future = iter.value;
       if (!$instanceOf(future, ${getGenericClass(Future)})) {
         future = $Future.value(future);
       }
-      return future.then($dynamicR)((x) => this.runBody(x),
+      return future.then($dynamic)((x) => this.runBody(x),
           { onError: (e, s) => this.throwError(e, s) });
     }
 
     // Adds element to stream, returns true if the caller should terminate
     // execution of the generator.
     add(event) {
       // If stream is cancelled, tell caller to exit the async generator.
       if (!this.controller.hasListener) return true;
       this.controller.add(event);
       this.scheduleGenerator();
       this.isSuspendedAtYield = true;
       return false;
     }
 
     // Adds the elements of stream into this controller's stream.
     // The generator will be scheduled again when all of the
     // elements of the added stream have been consumed.
     // Returns true if the caller should terminate
     // execution of the generator.
     addStream(stream) {
       // If stream is cancelled, tell caller to exit the async generator.
       if (!this.controller.hasListener) return true;
 
       this.isAdding = true;
-      this.controller.addStream(stream, {cancelOnError: false}).then($dynamicR)(
+      this.controller.addStream(stream, {cancelOnError: false}).then($dynamic)(
           () => {
         this.isAdding = false;
         this.scheduleGenerator();
       }, { onError: (e, s) => this.throwError(e, s) });
     }
 
     throwError(error, stackTrace) {
       try {
         this.iterator.throw(error);
       } catch (e) {
@@ skipping 12 matching lines @@
       this.controller.addError(error, stackTrace);
     }
   }
 ''');
 
 /// Returns a Stream of T implemented by an async* function. */
 ///
 asyncStar(gen, T, @rest args) => JS('', '''(() => {
   return new $_AsyncStarStreamController($gen, $T, $args).controller.stream;
 })()''');