runtime/JSPromiseFunctions.cpp

   1 /*
   2  * Copyright (C) 2013 Apple Inc. All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  * 1. Redistributions of source code must retain the above copyright
   8  *    notice, this list of conditions and the following disclaimer.
   9  * 2. Redistributions in binary form must reproduce the above copyright
  10  *    notice, this list of conditions and the following disclaimer in the
  11  *    documentation and/or other materials provided with the distribution.
  12  *
  13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
  14  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
  15  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  16  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
  17  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  18  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  19  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  20  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  21  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  22  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
  23  * THE POSSIBILITY OF SUCH DAMAGE.
  24  */
  25
  26 #include "config.h"
  27 #include "JSPromiseFunctions.h"
  28
  29 #if ENABLE(PROMISES)
  30
  31 #include "Error.h"
  32 #include "JSCJSValueInlines.h"
  33 #include "JSCellInlines.h"
  34 #include "JSPromise.h"
  35 #include "JSPromiseConstructor.h"
  36 #include "JSPromiseDeferred.h"
  37 #include "NumberObject.h"
  38 #include "StructureInlines.h"
  39
  40 namespace JSC {
  41
  42 // Deferred Construction Functions
  43 static EncodedJSValue JSC_HOST_CALL deferredConstructionFunction(ExecState* exec)
  44 {
  45     JSObject* F = exec->callee();
  46
  47     VM& vm = exec->vm();
  48
  49     // 1. Set F's [[Resolve]] internal slot to resolve.
  50     F->putDirect(vm, vm.propertyNames->resolvePrivateName, exec->argument(0));
  51
  52     // 2. Set F's [[Reject]] internal slot to reject.
  53     F->putDirect(vm, vm.propertyNames->rejectPrivateName, exec->argument(1));
  54
  55     // 3. Return.
  56     return JSValue::encode(jsUndefined());
  57 }
  58
  59 JSFunction* createDeferredConstructionFunction(VM& vm, JSGlobalObject* globalObject)
  60 {
  61     return JSFunction::create(vm, globalObject, 2, ASCIILiteral("DeferredConstructionFunction"), deferredConstructionFunction);
  62 }
  63
  64 // Identity Functions
  65
  66 static EncodedJSValue JSC_HOST_CALL identifyFunction(ExecState* exec)
  67 {
  68     return JSValue::encode(exec->argument(0));
  69 }
  70
  71 JSFunction* createIdentifyFunction(VM& vm, JSGlobalObject* globalObject)
  72 {
  73     return JSFunction::create(vm, globalObject, 1, ASCIILiteral("IdentityFunction"), identifyFunction);
  74 }
  75
  76 // Promise.All Countdown Functions
  77
  78 static EncodedJSValue JSC_HOST_CALL promiseAllCountdownFunction(ExecState* exec)
  79 {
  80     JSValue x = exec->argument(0);
  81     VM& vm = exec->vm();
  82     JSObject* F = exec->callee();
  83
  84     // 1. Let 'index' be the value of F's [[Index]] internal slot.
  85     uint32_t index = F->get(exec, vm.propertyNames->indexPrivateName).asUInt32();
  86
  87     // 2. Let 'values' be the value of F's [[Values]] internal slot..
  88     JSArray* values = jsCast<JSArray*>(F->get(exec, vm.propertyNames->valuesPrivateName));
  89
  90     // 3. Let 'deferred' be the value of F's [[Deferred]] internal slot.
  91     JSPromiseDeferred* deferred = jsCast<JSPromiseDeferred*>(F->get(exec, vm.propertyNames->deferredPrivateName));
  92
  93     // 4. Let 'countdownHolder' be the value of F's [[CountdownHolder]] internal slot.
  94     NumberObject* countdownHolder = jsCast<NumberObject*>(F->get(exec, vm.propertyNames->countdownHolderPrivateName));
  95
  96     // 5. Let 'result' be the result of calling the [[DefineOwnProperty]] internal method
  97     //    of 'values' with arguments 'index' and Property Descriptor { [[Value]]: x,
  98     //    [[Writable]]: true, [[Enumerable]]: true, [[Configurable]]: true }.
  99     values->putDirectIndex(exec, index, x);
 100
 101     // 6. RejectIfAbrupt(result, deferred).
 102     if (exec->hadException())
 103         abruptRejection(exec, deferred);
 104
 105     // 7. Set countdownHolder.[[Countdown]] to countdownHolder.[[Countdown]] - 1.
 106     uint32_t newCountdownValue = countdownHolder->internalValue().asUInt32() - 1;
 107     countdownHolder->setInternalValue(vm, JSValue(newCountdownValue));
 108
 109     // 8. If countdownHolder.[[Countdown]] is 0,
 110     if (!newCountdownValue) {
 111         // i. Return the result of calling the [[Call]] internal method of deferred.[[Resolve]]
 112         //    with undefined as thisArgument and a List containing 'values' as argumentsList.
 113         performDeferredResolve(exec, deferred, values);
 114     }
 115
 116     // 9. Return.
 117     return JSValue::encode(jsUndefined());
 118 }
 119
 120 JSFunction* createPromiseAllCountdownFunction(VM& vm, JSGlobalObject* globalObject)
 121 {
 122     return JSFunction::create(vm, globalObject, 1, ASCIILiteral("PromiseAllCountdownFunction"), promiseAllCountdownFunction);
 123 }
 124
 125 // Promise Resolution Handler Functions
 126
 127 static EncodedJSValue JSC_HOST_CALL promiseResolutionHandlerFunction(ExecState* exec)
 128 {
 129     JSValue x = exec->argument(0);
 130     VM& vm = exec->vm();
 131     JSObject* F = exec->callee();
 132
 133     // 1. Let 'promise' be the value of F's [[Promise]] internal slot
 134     JSPromise* promise = jsCast<JSPromise*>(F->get(exec, vm.propertyNames->promisePrivateName));
 135
 136     // 2. Let 'fulfillmentHandler' be the value of F's [[FulfillmentHandler]] internal slot.
 137     JSValue fulfillmentHandler = F->get(exec, vm.propertyNames->fulfillmentHandlerPrivateName);
 138
 139     // 3. Let 'rejectionHandler' be the value of F's [[RejectionHandler]] internal slot.
 140     JSValue rejectionHandler = F->get(exec, vm.propertyNames->rejectionHandlerPrivateName);
 141
 142     // 4. If SameValue(x, promise) is true,
 143     if (sameValue(exec, x, promise)) {
 144         // i. Let 'selfResolutionError' be a newly-created TypeError object.
 145         JSObject* selfResolutionError = createTypeError(exec, ASCIILiteral("Resolve a promise with itself"));
 146         // ii. Return the result of calling the [[Call]] internal method of rejectionHandler with
 147         //     undefined as thisArgument and a List containing selfResolutionError as argumentsList.
 148         CallData rejectCallData;
 149         CallType rejectCallType = getCallData(rejectionHandler, rejectCallData);
 150         ASSERT(rejectCallType != CallTypeNone);
 151
 152         MarkedArgumentBuffer rejectArguments;
 153         rejectArguments.append(selfResolutionError);
 154
 155         return JSValue::encode(call(exec, rejectionHandler, rejectCallType, rejectCallData, jsUndefined(), rejectArguments));
 156     }
 157
 158     // 5. Let 'C' be the value of promise's [[PromiseConstructor]] internal slot.
 159     JSValue C = promise->constructor();
 160
 161     // 6. Let 'deferred' be the result of calling GetDeferred(C)
 162     JSValue deferredValue = createJSPromiseDeferredFromConstructor(exec, C);
 163
 164     // 7. ReturnIfAbrupt(deferred).
 165     if (exec->hadException())
 166         return JSValue::encode(jsUndefined());
 167
 168     JSPromiseDeferred* deferred = jsCast<JSPromiseDeferred*>(deferredValue);
 169
 170     // 8. Let 'updateResult' be the result of calling UpdateDeferredFromPotentialThenable(x, deferred).
 171     ThenableStatus updateResult = updateDeferredFromPotentialThenable(exec, x, deferred);
 172
 173     // 9. ReturnIfAbrupt(updateResult).
 174     if (exec->hadException())
 175         return JSValue::encode(jsUndefined());
 176
 177     // 10. If 'updateResult' is not "not a thenable", return the result of calling
 178     //     Invoke(deferred.[[Promise]], "then", (fulfillmentHandler, rejectionHandler)).
 179     // NOTE: Invoke does not seem to be defined anywhere, so I am guessing here.
 180     if (updateResult != NotAThenable) {
 181         JSObject* deferredPromise = deferred->promise();
 182
 183         JSValue thenValue = deferredPromise->get(exec, exec->vm().propertyNames->then);
 184         if (exec->hadException())
 185             return JSValue::encode(jsUndefined());
 186
 187         CallData thenCallData;
 188         CallType thenCallType = getCallData(thenValue, thenCallData);
 189         if (thenCallType == CallTypeNone)
 190             return JSValue::encode(throwTypeError(exec));
 191
 192         MarkedArgumentBuffer arguments;
 193         arguments.append(fulfillmentHandler);
 194         arguments.append(rejectionHandler);
 195
 196         return JSValue::encode(call(exec, thenValue, thenCallType, thenCallData, deferredPromise, arguments));
 197     }
 198
 199     // 11. Return the result of calling the [[Call]] internal method of fulfillmentHandler
 200     //     with undefined as thisArgument and a List containing x as argumentsList.
 201     CallData fulfillmentHandlerCallData;
 202     CallType fulfillmentHandlerCallType = getCallData(fulfillmentHandler, fulfillmentHandlerCallData);
 203     ASSERT(fulfillmentHandlerCallType != CallTypeNone);
 204
 205     MarkedArgumentBuffer fulfillmentHandlerArguments;
 206     fulfillmentHandlerArguments.append(x);
 207
 208     return JSValue::encode(call(exec, fulfillmentHandler, fulfillmentHandlerCallType, fulfillmentHandlerCallData, jsUndefined(), fulfillmentHandlerArguments));
 209 }
 210
 211 JSFunction* createPromiseResolutionHandlerFunction(VM& vm, JSGlobalObject* globalObject)
 212 {
 213     return JSFunction::create(vm, globalObject, 1, ASCIILiteral("PromiseResolutionHandlerFunction"), promiseResolutionHandlerFunction);
 214 }
 215
 216 // Reject Promise Functions
 217
 218 static EncodedJSValue JSC_HOST_CALL rejectPromiseFunction(ExecState* exec)
 219 {
 220     JSValue reason = exec->argument(0);
 221     JSObject* F = exec->callee();
 222     VM& vm = exec->vm();
 223
 224     // 1. Let 'promise' be the value of F's [[Promise]] internal slot.
 225     JSPromise* promise = jsCast<JSPromise*>(F->get(exec, exec->vm().propertyNames->promisePrivateName));
 226
 227     // 2. Return the result of calling PromiseReject(promise, reason);
 228     promise->reject(vm, reason);
 229
 230     return JSValue::encode(jsUndefined());
 231 }
 232
 233 JSFunction* createRejectPromiseFunction(VM& vm, JSGlobalObject* globalObject)
 234 {
 235     return JSFunction::create(vm, globalObject, 1, ASCIILiteral("RejectPromiseFunction"), rejectPromiseFunction);
 236 }
 237
 238 // Resolve Promise Functions
 239
 240 static EncodedJSValue JSC_HOST_CALL resolvePromiseFunction(ExecState* exec)
 241 {
 242     JSValue resolution = exec->argument(0);
 243     JSObject* F = exec->callee();
 244     VM& vm = exec->vm();
 245
 246     // 1. Let 'promise' be the value of F's [[Promise]] internal slot.
 247     JSPromise* promise = jsCast<JSPromise*>(F->get(exec, vm.propertyNames->promisePrivateName));
 248
 249     // 2. Return the result of calling PromiseResolve(promise, resolution);
 250     promise->resolve(vm, resolution);
 251
 252     return JSValue::encode(jsUndefined());
 253 }
 254
 255 JSFunction* createResolvePromiseFunction(VM& vm, JSGlobalObject* globalObject)
 256 {
 257     return JSFunction::create(vm, globalObject, 1, ASCIILiteral("ResolvePromiseFunction"), resolvePromiseFunction);
 258 }
 259
 260 // Thrower Functions
 261
 262 static EncodedJSValue JSC_HOST_CALL throwerFunction(ExecState* exec)
 263 {
 264     return JSValue::encode(exec->vm().throwException(exec, exec->argument(0)));
 265 }
 266
 267 JSFunction* createThrowerFunction(VM& vm, JSGlobalObject* globalObject)
 268 {
 269     return JSFunction::create(vm, globalObject, 1, ASCIILiteral("ThrowerFunction"), throwerFunction);
 270 }
 271
 272
 273 } // namespace JSC
 274
 275 #endif // ENABLE(PROMISES)