WIP(core): use asynchooks to resolve es2017 native async/await issue

Author: JiaLiPassion

gulpfile.js

@@ -82,6 +82,10 @@ gulp.task('compile-node', function(cb) {
   tsc('tsconfig-node.json', cb);
 });
 
+gulp.task('compile-node-es2017', function(cb) {
+  tsc('tsconfig-node.es2017.json', cb);
+});
+
 gulp.task('compile-esm', function(cb) {
   tsc('tsconfig-esm.json', cb);
 });
@@ -310,6 +314,11 @@ gulp.task('build', [
   'build/closure.js'
 ]);
 
+gulp.task('test/node2017', ['compile-node-es2017'], function(cb) {
+  var testAsyncPromise = require('./build/test/node_async').testAsyncPromise;
+  testAsyncPromise();
+});
+
 gulp.task('test/node', ['compile-node'], function(cb) {
   var JasmineRunner = require('jasmine');
   var jrunner = new JasmineRunner();

lib/browser/define-property.ts

@@ -22,7 +22,7 @@ const OBJECT = 'object';
 const UNDEFINED = 'undefined';
 
 export function propertyPatch() {
-  Object.defineProperty = function(obj, prop, desc) {
+  Object.defineProperty = function(obj: any, prop: string, desc: any) {
     if (isUnconfigurable(obj, prop)) {
       throw new TypeError('Cannot assign to read only property \'' + prop + '\' of ' + obj);
     }
@@ -49,7 +49,7 @@ export function propertyPatch() {
     return _create(obj, proto);
   };
 
-  Object.getOwnPropertyDescriptor = function(obj, prop) {
+  Object.getOwnPropertyDescriptor = function(obj: any, prop: string) {
     const desc = _getOwnPropertyDescriptor(obj, prop);
     if (isUnconfigurable(obj, prop)) {
       desc.configurable = false;

lib/common/promise.ts

@@ -233,7 +233,8 @@ Zone.__load_patch('ZoneAwarePromise', (global: any, Zone: ZoneType, api: _ZonePr
     const delegate = (promise as any)[symbolState] ?
         (typeof onFulfilled === FUNCTION) ? onFulfilled : forwardResolution :
         (typeof onRejected === FUNCTION) ? onRejected : forwardRejection;
-    zone.scheduleMicroTask(source, () => {
+
+      zone.scheduleMicroTask(source, () => {
       try {
         resolvePromise(
             chainPromise, true, zone.run(delegate, undefined, [(promise as any)[symbolValue]]));
@@ -244,12 +245,17 @@ Zone.__load_patch('ZoneAwarePromise', (global: any, Zone: ZoneType, api: _ZonePr
   }
 
   const ZONE_AWARE_PROMISE_TO_STRING = 'function ZoneAwarePromise() { [native code] }';
+  type PROMISE = 'Promise';
 
   class ZoneAwarePromise<R> implements Promise<R> {
     static toString() {
       return ZONE_AWARE_PROMISE_TO_STRING;
     }
 
+    get[Symbol.toStringTag]() {
+      return 'Promise' as PROMISE;
+    }
+
     static resolve<R>(value: R): Promise<R> {
       return resolvePromise(<ZoneAwarePromise<R>>new this(null), RESOLVED, value);
     }
@@ -409,9 +415,13 @@ Zone.__load_patch('ZoneAwarePromise', (global: any, Zone: ZoneType, api: _ZonePr
     }
 
     Ctor.prototype.then = function(onResolve: any, onReject: any) {
+      const zone = this.zone;
       const wrapped = new ZoneAwarePromise((resolve, reject) => {
         originalThen.call(this, resolve, reject);
       });
+      if (zone) {
+        (wrapped as any).zone = zone;
+      }
       return wrapped.then(onResolve, onReject);
     };
     (Ctor as any)[symbolThenPatched] = true;

lib/node/async_hooks_promise.ts

@@ -0,0 +1,64 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+/**
+ * patch nodejs async operations (timer, promise, net...) with
+ * nodejs async_hooks
+ */
+Zone.__load_patch('node_async_hooks_promise', (global: any, Zone: ZoneType, api: _ZonePrivate) => {
+  let async_hooks;
+  try {
+    async_hooks = require('async_hooks');
+  } catch (err) {
+    print(err.message);
+    return;
+  }
+
+  const PROMISE_PROVIDER = 'PROMISE';
+  const noop = function() {};
+
+  function print(message: string) {
+    (process as any)._rawDebug(message);
+  }
+
+  function init(id: number, provider: string, triggerId: number, parentHandle: any) {
+    if (provider === PROMISE_PROVIDER) {
+      if (!parentHandle) {
+        print('no parenthandle');
+        return;
+      }
+      const promise = parentHandle.promise;
+      const originalThen = promise.then;
+
+      promise.then = function(onResolve: any, onReject: any) {
+        const zone = Zone.current;
+        const wrapped = new Promise((resolve, reject) => {
+          originalThen.call(this, resolve, reject);
+        });
+        if (zone) {
+          (wrapped as any).zone = zone;
+        }
+        return wrapped.then(onResolve, onReject);
+      };
+    }
+  }
+
+  function before(id: number) {
+    //print('before ' + id);
+  }
+
+  function after(id: number) {
+    //print('after ' + id);
+  }
+
+  function destroy(id: number) {
+    //print('destroy ' + id);
+  }
+
+  async_hooks.createHook({ init, before, after, destroy }).enable();
+});

lib/node/async_promise.ts

@@ -0,0 +1,91 @@
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+
+/**
+ * patch nodejs async operations (timer, promise, net...) with
+ * nodejs async_hooks
+ */
+Zone.__load_patch('node_async_hooks_promise', (global: any, Zone: ZoneType, api: _ZonePrivate) => {
+  let async_hooks;
+  try {
+    async_hooks = require('async_hooks');
+  } catch (err) {
+    print(err.message);
+    return;
+  }
+
+  const PROMISE_PROVIDER = 'PROMISE';
+  const noop = function() {};
+
+  const idPromise: {[key: number]: any} = {};
+
+  function print(...args: string[]) {
+    if (!args) {
+      return;
+    }
+    (process as any)._rawDebug(args.join(' '));
+  }
+
+  function init(id: number, provider: string, triggerId: number, parentHandle: any) {
+    if (provider === PROMISE_PROVIDER) {
+      if (!parentHandle) {
+        print('no parenthandle');
+        return;
+      }
+      const promise = parentHandle.promise;
+      const originalThen = promise.then;
+
+      const zone = Zone.current;
+      if (zone.name === 'promise') {
+        print('init promise', id.toString());
+      }
+      if (!zone.parent) {
+        print('root zone');
+        return;
+      }
+      const currentAsyncContext: any = {};
+      currentAsyncContext.id = id;
+      currentAsyncContext.zone = zone;
+      idPromise[id] = currentAsyncContext;
+      promise.then = function(onResolve: any, onReject: any) {
+        const wrapped = new Promise((resolve, reject) => {
+          originalThen.call(this, resolve, reject);
+        });
+        if (zone) {
+          (wrapped as any).zone = zone;
+        }
+        return zone.run(() => {
+          return wrapped.then(onResolve, onReject);
+        });
+      };
+    }
+  }
+
+  function before(id: number) {
+    const currentAsyncContext = idPromise[id];
+    if (currentAsyncContext) {
+      print('before ' + id, currentAsyncContext.zone.name);
+      api.setAsyncContext(currentAsyncContext);
+    }
+  }
+
+  function after(id: number) {
+    const currentAsyncContext = idPromise[id];
+    if (currentAsyncContext) {
+      print('after ' + id, currentAsyncContext.zone.name);
+      idPromise[id] = null;
+      api.setAsyncContext(null);
+    }
+  }
+
+  function destroy(id: number) {
+    print('destroy ' + id);
+  }
+
+  async_hooks.createHook({init, before, after, destroy}).enable();
+});

lib/node/node.ts

@@ -111,7 +111,6 @@ Zone.__load_patch(
           });
         };
       }
-
     });
 
 

lib/node/rollup-main.ts

@@ -9,4 +9,5 @@
 import '../zone';
 import '../common/promise';
 import '../common/to-string';
+import './async_hooks_promise';
 import './node';