Promise assimilation fix.

src/promise.js

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 var $promiseCreate;
 var $promiseResolve;
 var $promiseReject;
 var $promiseChain;
 var $promiseCatch;
 var $promiseThen;
@@ skipping 87 matching lines @@
         %_CallFunction(x, deferred.resolve, deferred.reject, then);
       } catch(r) {
         deferred.reject(r);
       }
       return deferred.promise;
     }
   }
   return x;
 }
 
-function PromiseHandle(value, handler, deferred) {
+function PromiseHandle(value, handler, deferred, thenable) {
   try {
     %DebugPushPromise(deferred.promise, PromiseHandle);
     DEBUG_PREPARE_STEP_IN_IF_STEPPING(handler);
     var result = handler(value);
-    if (result === deferred.promise)
+    if (result === deferred.promise) {
       throw MakeTypeError(kPromiseCyclic, result);
-    else if (IsPromise(result))
+    } else if (IsPromise(result) && thenable) {
+      var then = result.then;
+      if (IS_SPEC_FUNCTION(then)) {
+        PromiseCallThenInSeparateTask(result, deferred, then);
+      } else {
+        deferred.resolve(result);
+      }
+    } else if (IsPromise(result)) {
       %_CallFunction(result, deferred.resolve, deferred.reject, PromiseChain);
-    else
+    } else {
       deferred.resolve(result);
+    }
   } catch (exception) {
     try { deferred.reject(exception); } catch (e) { }
   } finally {
     %DebugPopPromise();
   }
 }
 
+function PromiseCallThenInSeparateTask(result, deferred, then) {
+  var id, name, instrumenting = DEBUG_IS_ACTIVE;
+  %EnqueueMicrotask(function() {
+    if (instrumenting) {
+      %DebugAsyncTaskEvent({ type: "willCall", id: id, name: name });
+    }
+    try {
+      %_CallFunction(result, deferred.resolve, deferred.reject, then);
+    } catch(exception) {
+      try { deferred.reject(exception); } catch (e) { }
+    }
+    if (instrumenting) {
+      %DebugAsyncTaskEvent({ type: "didCall", id: id, name: name });
+    }
+  });
+  if (instrumenting) {
+    id = ++lastMicrotaskId;
+    name = "Promise.prototype.then";
+    %DebugAsyncTaskEvent({ type: "enqueue", id: id, name: name });
+  }
+}
+
 function PromiseEnqueue(value, tasks, status) {
   var id, name, instrumenting = DEBUG_IS_ACTIVE;
   %EnqueueMicrotask(function() {
     if (instrumenting) {
       %DebugAsyncTaskEvent({ type: "willHandle", id: id, name: name });
     }
-    for (var i = 0; i < tasks.length; i += 2) {
-      PromiseHandle(value, tasks[i], tasks[i + 1])
+    for (var i = 0; i < tasks.length; i += 3) {
+      // tasks[i: i + 2] consists of the reaction handler, the associated
+      // deferred object and whether the thenable handling is required.
+      PromiseHandle(value, tasks[i], tasks[i + 1], tasks[i + 2])
     }
     if (instrumenting) {
       %DebugAsyncTaskEvent({ type: "didHandle", id: id, name: name });
     }
   });
   if (instrumenting) {
     id = ++lastMicrotaskId;
     name = status > 0 ? "Promise.resolve" : "Promise.reject";
     %DebugAsyncTaskEvent({ type: "enqueue", id: id, name: name });
   }
 }
 
+function PromiseChainInternal(onResolve, onReject, thenable) {
+  onResolve = IS_UNDEFINED(onResolve) ? PromiseIdResolveHandler : onResolve;
+  onReject = IS_UNDEFINED(onReject) ? PromiseIdRejectHandler : onReject;
+  var deferred = %_CallFunction(this.constructor, PromiseDeferred);
+  switch (GET_PRIVATE(this, promiseStatus)) {
+    case UNDEFINED:
+      throw MakeTypeError(kNotAPromise, this);
+    case 0:  // Pending
+      GET_PRIVATE(this, promiseOnResolve).push(onResolve, deferred, thenable);
+      GET_PRIVATE(this, promiseOnReject).push(onReject, deferred, thenable);
+      break;
+    case +1:  // Resolved
+      PromiseEnqueue(GET_PRIVATE(this, promiseValue),
+                     [onResolve, deferred, thenable],
+                     +1);
+      break;
+    case -1:  // Rejected
+      if (!HAS_DEFINED_PRIVATE(this, promiseHasHandler)) {
+        // Promise has already been rejected, but had no handler.
+        // Revoke previously triggered reject event.
+        %PromiseRevokeReject(this);
+      }
+      PromiseEnqueue(GET_PRIVATE(this, promiseValue),
+                     [onReject, deferred, thenable],
+                     -1);
+      break;
+  }
+  // Mark this promise as having handler.
+  SET_PRIVATE(this, promiseHasHandler, true);
+  if (DEBUG_IS_ACTIVE) {
+    %DebugPromiseEvent({ promise: deferred.promise, parentPromise: this });
+  }
+  return deferred.promise;
+}
+
 function PromiseIdResolveHandler(x) { return x }
 function PromiseIdRejectHandler(r) { throw r }
 
 function PromiseNopResolver() {}
 
 // -------------------------------------------------------------------
 // Define exported functions.
 
 // For bootstrapper.
 
@@ skipping 61 matching lines @@
     %PromiseRejectEvent(promise, r, false);
   } else {
     promise = new this(function(resolve, reject) { reject(r) });
   }
   return promise;
 }
 
 // Simple chaining.
 
 function PromiseChain(onResolve, onReject) {  // a.k.a. flatMap
-  onResolve = IS_UNDEFINED(onResolve) ? PromiseIdResolveHandler : onResolve;
-  onReject = IS_UNDEFINED(onReject) ? PromiseIdRejectHandler : onReject;
-  var deferred = %_CallFunction(this.constructor, PromiseDeferred);
-  switch (GET_PRIVATE(this, promiseStatus)) {
-    case UNDEFINED:
-      throw MakeTypeError(kNotAPromise, this);
-    case 0:  // Pending
-      GET_PRIVATE(this, promiseOnResolve).push(onResolve, deferred);
-      GET_PRIVATE(this, promiseOnReject).push(onReject, deferred);
-      break;
-    case +1:  // Resolved
-      PromiseEnqueue(GET_PRIVATE(this, promiseValue),
-                     [onResolve, deferred],
-                     +1);
-      break;
-    case -1:  // Rejected
-      if (!HAS_DEFINED_PRIVATE(this, promiseHasHandler)) {
-        // Promise has already been rejected, but had no handler.
-        // Revoke previously triggered reject event.
-        %PromiseRevokeReject(this);
-      }
-      PromiseEnqueue(GET_PRIVATE(this, promiseValue),
-                     [onReject, deferred],
-                     -1);
-      break;
-  }
-  // Mark this promise as having handler.
-  SET_PRIVATE(this, promiseHasHandler, true);
-  if (DEBUG_IS_ACTIVE) {
-    %DebugPromiseEvent({ promise: deferred.promise, parentPromise: this });
-  }
-  return deferred.promise;
+  return %_CallFunction(this, onResolve, onReject, false,
+                        PromiseChainInternal);
 }
 
 function PromiseCatch(onReject) {
   return this.then(UNDEFINED, onReject);
 }
 
 // Multi-unwrapped chaining with thenable coercion.
 
 function PromiseThen(onResolve, onReject) {
   onResolve = IS_SPEC_FUNCTION(onResolve) ? onResolve
@@ skipping 10 matching lines @@
         DEBUG_PREPARE_STEP_IN_IF_STEPPING(onReject);
         return onReject(MakeTypeError(kPromiseCyclic, x));
       } else if (IsPromise(x)) {
         return x.then(onResolve, onReject);
       } else {
         DEBUG_PREPARE_STEP_IN_IF_STEPPING(onResolve);
         return onResolve(x);
       }
     },
     onReject,
-    PromiseChain
+    true,
+    PromiseChainInternal
   );
 }
 
 // Combinators.
 
 function PromiseCast(x) {
   // TODO(rossberg): cannot do better until we support @@create.
   return IsPromise(x) ? x : new this(function(resolve) { resolve(x) });
 }
 
@@ skipping 41 matching lines @@
   }
   return deferred.promise;
 }
 
 
 // Utility for debugger
 
 function PromiseHasUserDefinedRejectHandlerRecursive(promise) {
   var queue = GET_PRIVATE(promise, promiseOnReject);
   if (IS_UNDEFINED(queue)) return false;
-  for (var i = 0; i < queue.length; i += 2) {
+  for (var i = 0; i < queue.length; i += 3) {
     if (queue[i] != PromiseIdRejectHandler) return true;
     if (PromiseHasUserDefinedRejectHandlerRecursive(queue[i + 1].promise)) {
       return true;
     }
   }
   return false;
 }
 
 // Return whether the promise will be handled by a user-defined reject
 // handler somewhere down the promise chain. For this, we do a depth-first
@@ skipping 28 matching lines @@
 $promiseResolve = PromiseResolve;
 $promiseReject = PromiseReject;
 $promiseChain = PromiseChain;
 $promiseCatch = PromiseCatch;
 $promiseThen = PromiseThen;
 $promiseHasUserDefinedRejectHandler = PromiseHasUserDefinedRejectHandler;
 $promiseStatus = promiseStatus;
 $promiseValue = promiseValue;
 
 })