Reland "Clean up promises and fix an edge case bug (patchset #4 id:60001 of https://codereview.chro…

test/mjsunit/es6/promises.js

 // Copyright 2013 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 175 matching lines @@
     assertUnreachable,
     function(r) { assertAsync(r === 6, "rejected/then-nohandler-null") }
   )
   assertAsyncRan()
 })();
 
 (function() {
   var p1 = Promise.accept(5)
   var p2 = Promise.accept(p1)
   var p3 = Promise.accept(p2)
+  // Note: Chain now has then-style semantics, here and in future tests.
   p3.chain(
-    function(x) { assertAsync(x === p2, "resolved/chain") },
+    function(x) { assertAsync(x === 5, "resolved/chain") },
     assertUnreachable
   )
   assertAsyncRan()
 })();
 
 (function() {
   var p1 = Promise.accept(5)
   var p2 = Promise.accept(p1)
   var p3 = Promise.accept(p2)
   p3.then(
     function(x) { assertAsync(x === 5, "resolved/then") },
     assertUnreachable
   )
   assertAsyncRan()
 })();
 
 (function() {
   var p1 = Promise.reject(5)
   var p2 = Promise.accept(p1)
   var p3 = Promise.accept(p2)
   p3.chain(
-    function(x) { assertAsync(x === p2, "rejected/chain") },
-    assertUnreachable
+    assertUnreachable,
+    function(x) { assertAsync(x === 5, "rejected/chain") }
   )
   assertAsyncRan()
 })();
 
 (function() {
   var p1 = Promise.reject(5)
   var p2 = Promise.accept(p1)
   var p3 = Promise.accept(p2)
   p3.then(
     assertUnreachable,
     function(x) { assertAsync(x === 5, "rejected/then") }
   )
   assertAsyncRan()
 })();
 
-/* TODO(caitp): remove tests once PromiseChain is removed, per bug 3237
 (function() {
   var p1 = Promise.accept(5)
   var p2 = Promise.accept(p1)
   var p3 = Promise.accept(p2)
   p3.chain(function(x) { return x }, assertUnreachable).chain(
-    function(x) { assertAsync(x === p1, "resolved/chain/chain") },
+    function(x) { assertAsync(x === 5, "resolved/chain/chain") },
     assertUnreachable
   )
   assertAsyncRan()
-})();*/
+})();
 
 (function() {
   var p1 = Promise.accept(5)
   var p2 = Promise.accept(p1)
   var p3 = Promise.accept(p2)
   p3.chain(function(x) { return x }, assertUnreachable).then(
     function(x) { assertAsync(x === 5, "resolved/chain/then") },
     assertUnreachable
   )
   assertAsyncRan()
@@ skipping 107 matching lines @@
     function(x) { assertAsync(x === 6, "resolved/then-throw/then") }
   )
   assertAsyncRan()
 })();
 
 (function() {
   var p1 = Promise.accept(5)
   var p2 = {then: function(onResolve, onReject) { onResolve(p1) }}
   var p3 = Promise.accept(p2)
   p3.chain(
-    function(x) { assertAsync(x === p2, "resolved/thenable/chain") },
+    function(x) { assertAsync(x === 5, "resolved/thenable/chain") },
     assertUnreachable
   )
   assertAsyncRan()
 })();
 
 (function() {
   var p1 = Promise.accept(5)
   var p2 = {then: function(onResolve, onReject) { onResolve(p1) }}
   var p3 = Promise.accept(p2)
   p3.then(
     function(x) { assertAsync(x === 5, "resolved/thenable/then") },
     assertUnreachable
   )
   assertAsyncRan()
 })();
 
 (function() {
   var p1 = Promise.reject(5)
   var p2 = {then: function(onResolve, onReject) { onResolve(p1) }}
   var p3 = Promise.accept(p2)
   p3.chain(
-    function(x) { assertAsync(x === p2, "rejected/thenable/chain") },
-    assertUnreachable
+    assertUnreachable,
+    function(x) { assertAsync(x === 5, "rejected/thenable/chain") }
   )
   assertAsyncRan()
 })();
 
 (function() {
   var p1 = Promise.reject(5)
   var p2 = {then: function(onResolve, onReject) { onResolve(p1) }}
   var p3 = Promise.accept(p2)
   p3.then(
     assertUnreachable,
     function(x) { assertAsync(x === 5, "rejected/thenable/then") }
   )
   assertAsyncRan()
 })();
 
 (function() {
   var deferred = Promise.defer()
   var p1 = deferred.promise
   var p2 = Promise.accept(p1)
   var p3 = Promise.accept(p2)
   p3.chain(
-    function(x) { assertAsync(x === p2, "chain/resolve") },
+    function(x) { assertAsync(x === 5, "chain/resolve") },
     assertUnreachable
   )
   deferred.resolve(5)
   assertAsyncRan()
 })();
 
 (function() {
   var deferred = Promise.defer()
   var p1 = deferred.promise
-  var p2 = Promise.accept(p1)
-  var p3 = Promise.accept(p2)
+  var p2 = Promise.resolve(p1)
+  var p3 = Promise.resolve(p2)
   p3.then(
     function(x) { assertAsync(x === 5, "then/resolve") },
     assertUnreachable
   )
   deferred.resolve(5)
   assertAsyncRan()
 })();
 
 (function() {
   var deferred = Promise.defer()
   var p1 = deferred.promise
   var p2 = Promise.accept(p1)
   var p3 = Promise.accept(p2)
   p3.chain(
-    function(x) { assertAsync(x === p2, "chain/reject") },
-    assertUnreachable
+    assertUnreachable,
+    function(x) { assertAsync(x === 5, "chain/reject") }
   )
   deferred.reject(5)
   assertAsyncRan()
 })();
 
 (function() {
   var deferred = Promise.defer()
   var p1 = deferred.promise
   var p2 = Promise.accept(p1)
   var p3 = Promise.accept(p2)
@@ skipping 28 matching lines @@
   deferred.reject(5)
   assertAsyncRan()
 })();
 
 (function() {
   var deferred = Promise.defer()
   var p1 = deferred.promise
   var p2 = {then: function(onResolve, onReject) { onResolve(p1) }}
   var p3 = Promise.accept(p2)
   p3.chain(
-    function(x) { assertAsync(x === p2, "chain/resolve/thenable") },
+    function(x) { assertAsync(x === 5, "chain/resolve/thenable") },
     assertUnreachable
   )
   deferred.resolve(5)
   assertAsyncRan()
 })();
 
 (function() {
   var deferred = Promise.defer()
   var p1 = deferred.promise
   var p2 = {then: function(onResolve, onReject) { onResolve(p1) }}
   var p3 = Promise.accept(p2)
   p3.then(
     function(x) { assertAsync(x === 5, "then/resolve/thenable") },
     assertUnreachable
   )
   deferred.resolve(5)
   assertAsyncRan()
 })();
 
 (function() {
   var deferred = Promise.defer()
   var p1 = deferred.promise
   var p2 = {then: function(onResolve, onReject) { onResolve(p1) }}
   var p3 = Promise.accept(p2)
   p3.chain(
-    function(x) { assertAsync(x === p2, "chain/reject/thenable") },
-    assertUnreachable
+    assertUnreachable,
+    function(x) { assertAsync(x === 5, "chain/reject/thenable") }
   )
   deferred.reject(5)
   assertAsyncRan()
 })();
 
 (function() {
   var deferred = Promise.defer()
   var p1 = deferred.promise
   var p2 = {then: function(onResolve, onReject) { onResolve(p1) }}
   var p3 = Promise.accept(p2)
   p3.then(
     assertUnreachable,
     function(x) { assertAsync(x === 5, "then/reject/thenable") }
   )
   deferred.reject(5)
   assertAsyncRan()
 })();
 
-/* TODO(caitp): remove tests once PromiseChain is removed, per bug v8:3237
 (function() {
   var p1 = Promise.accept(5)
   var p2 = Promise.accept(p1)
   var deferred = Promise.defer()
   var p3 = deferred.promise
   p3.chain(
-    function(x) { assertAsync(x === p2, "chain/resolve2") },
+    function(x) { assertAsync(x === 5, "chain/resolve2") },
     assertUnreachable
   )
   deferred.resolve(p2)
   assertAsyncRan()
-})(); */
+})();
 
 (function() {
   var p1 = Promise.accept(5)
   var p2 = Promise.accept(p1)
   var deferred = Promise.defer()
   var p3 = deferred.promise
   p3.then(
     function(x) { assertAsync(x === 5, "then/resolve2") },
     assertUnreachable
   )
@@ skipping 20 matching lines @@
   var deferred = Promise.defer()
   var p3 = deferred.promise
   p3.then(
     assertUnreachable,
     function(x) { assertAsync(x === 5, "then/reject2") }
   )
   deferred.reject(5)
   assertAsyncRan()
 })();
 
-/* TODO(caitp): remove tests once PromiseChain is removed, per bug v8:3237
 (function() {
   var p1 = Promise.accept(5)
   var p2 = {then: function(onResolve, onReject) { onResolve(p1) }}
   var deferred = Promise.defer()
   var p3 = deferred.promise
   p3.chain(
-    function(x) { assertAsync(x === p2, "chain/resolve/thenable2") },
+    function(x) { assertAsync(x === 5, "chain/resolve/thenable2") },
     assertUnreachable
   )
   deferred.resolve(p2)
   assertAsyncRan()
-})(); */
+})();
 
 (function() {
   var p1 = Promise.accept(5)
   var p2 = {then: function(onResolve, onReject) { onResolve(p1) }}
   var deferred = Promise.defer()
   var p3 = deferred.promise
   p3.then(
     function(x) { assertAsync(x === 5, "then/resolve/thenable2") },
     assertUnreachable
   )
@@ skipping 14 matching lines @@
 (function() {
   var p1 = Promise.accept(0)
   var p2 = p1.then(function(x) { return p2 }, assertUnreachable)
   p2.chain(
     assertUnreachable,
     function(r) { assertAsync(r instanceof TypeError, "cyclic/then") }
   )
   assertAsyncRan()
 })();
 
-/* TODO(caitp): remove tests once PromiseChain is removed, per bug v8:3237
 (function() {
   var deferred = Promise.defer()
   var p = deferred.promise
   deferred.resolve(p)
   p.chain(
-    function(x) { assertAsync(x === p, "cyclic/deferred/chain") },
-    assertUnreachable
+    assertUnreachable,
+    function(r) { assertAsync(r instanceof TypeError, "cyclic/deferred/then") }
   )
   assertAsyncRan()
-})();*/
+})();
 
-/* TODO(caitp): remove tests once PromiseChain is removed, per bug v8:3237
 (function() {
   var deferred = Promise.defer()
   var p = deferred.promise
   deferred.resolve(p)
   p.then(
     assertUnreachable,
     function(r) { assertAsync(r instanceof TypeError, "cyclic/deferred/then") }
   )
   assertAsyncRan()
-})();*/
+})();
 
 (function() {
   Promise.all([]).chain(
     function(x) { assertAsync(x.length === 0, "all/resolve/empty") },
     assertUnreachable
   )
   assertAsyncRan()
 })();
 
 (function() {
@@ skipping 82 matching lines @@
   Promise.all([p1, p2, p3]).chain(
     assertUnreachable,
     function(x) { assertAsync(x === 2, "all/reject") }
   )
   deferred1.resolve(1)
   deferred3.resolve(3)
   deferred2.reject(2)
   assertAsyncRan()
 })();
 
-
 (function() {
   'use strict';
   var getCalls = 0;
   var funcCalls = 0;
   var nextCalls = 0;
   defineProperty(numberPrototype, symbolIterator, {
     get: function() {
       assertEquals('number', typeof this);
       getCalls++;
       return function() {
@@ skipping 333 matching lines @@
   var p = Promise.resolve();
   var callCount = 0;
   defineProperty(p, "constructor", {
     get: function() { ++callCount; return Promise; }
   });
   p.then();
   assertEquals(1, callCount);
 })();
 
 assertAsyncDone()