implement Promise.any

Author: devsnek

.eslintrc.js

@@ -54,6 +54,7 @@ module.exports = {
     'no-use-before-define': 'off',
     'no-continue': 'off',
     'no-unused-vars': ['error', { vars: 'all', args: 'after-used', argsIgnorePattern: '^_' }],
+    'no-empty': ['error', { allowEmptyCatch: true }],
     'import/no-cycle': 'off',
     'import/extensions': 'off',
     'import/prefer-default-export': 'off',

scripts/transform.js

@@ -19,14 +19,14 @@ function findParentStatementPath(path) {
   return path;
 }
 
-function isInsideConditionalExpression(path) {
+function getEnclosingConditionalExpression(path) {
   while (path && !path.isStatement()) {
     if (path.isConditionalExpression()) {
-      return true;
+      return path;
     }
     path = path.parentPath;
   }
-  return false;
+  return null;
 }
 
 module.exports = ({ types: t, template }) => {
@@ -143,8 +143,23 @@ module.exports = ({ types: t, template }) => {
 
         const macroName = path.node.callee.name;
         if (MACRO_NAMES.includes(macroName)) {
-          if (isInsideConditionalExpression(path)) {
-            throw path.buildCodeFrameError('Macros may not be used within conditional expressions');
+          const enclosingConditional = getEnclosingConditionalExpression(path);
+          if (enclosingConditional !== null) {
+            if (enclosingConditional.parentPath.isVariableDeclarator()) {
+              const declaration = enclosingConditional.parentPath.parentPath;
+              const id = enclosingConditional.parentPath.get('id');
+              declaration.replaceWithMultiple(template.ast(`
+              let ${id};
+              if (${enclosingConditional.get('test')}) {
+                ${id} = ${enclosingConditional.get('consequent')}
+              } else {
+                ${id} = ${enclosingConditional.get('alternate')}
+              }
+              `));
+              return;
+            } else {
+              throw path.buildCodeFrameError('Macros may not be used within conditional expressions');
+            }
           }
 
           const macro = MACROS[macroName];

src/engine.mjs

@@ -41,6 +41,10 @@ export const FEATURES = Object.freeze([
     name: 'LogicalAssignment',
     url: 'https://github.com/tc39/proposal-logical-assignment',
   },
+  {
+    name: 'Promise.any',
+    url: 'https://github.com/tc39/proposal-promise-any',
+  },
 ].map(Object.freeze));
 
 // #sec-agents
@@ -109,8 +113,15 @@ export class Agent {
     }
     const message = messages[template](...templateArgs);
     const cons = this.currentRealmRecord.Intrinsics[`%${type}%`];
-    const error = Construct(cons, [new Value(message)]);
-    Assert(!(error instanceof AbruptCompletion));
+    let error;
+    if (type === 'AggregateError') {
+      error = X(Construct(cons, [
+        Symbol.for('engine262.placeholder'),
+        new Value(message),
+      ]));
+    } else {
+      error = X(Construct(cons, [new Value(message)]));
+    }
     return new ThrowCompletion(error);
   }
 

src/inspect.mjs

@@ -9,15 +9,21 @@ import { Q, X } from './completion.mjs';
 const bareKeyRe = /^[a-zA-Z_][a-zA-Z_0-9]*$/;
 
 const getObjectTag = (value, wrap) => {
+  let s;
   try {
-    const s = X(Get(value, wellKnownSymbols.toStringTag)).stringValue();
+    s = X(Get(value, wellKnownSymbols.toStringTag)).stringValue();
+  } catch {}
+  try {
+    const c = X(Get(value, new Value('constructor')));
+    s = X(Get(c, new Value('name'))).stringValue();
+  } catch {}
+  if (s) {
     if (wrap) {
       return `[${s}] `;
     }
     return s;
-  } catch {
-    return '';
   }
+  return '';
 };
 
 const compactObject = (realm, value) => {
@@ -109,7 +115,6 @@ const INSPECTORS = {
     ctx.inspected.push(v);
 
     try {
-      const tag = getObjectTag(v);
       const isArray = IsArray(v) === Value.true;
       const isTypedArray = 'TypedArrayName' in v;
       if (isArray || isTypedArray) {
@@ -147,7 +152,8 @@ const INSPECTORS = {
         }
       }
 
-      let out = tag ? `${tag} {` : '{';
+      const tag = getObjectTag(v);
+      let out = tag && tag !== 'Object' ? `${tag} {` : '{';
       if (cache.length > 5) {
         cache.forEach((c) => {
           out = `${out}\n${'  '.repeat(ctx.indent)}${c[0]}: ${c[1]},`;

src/intrinsics/AggregateError.mjs

@@ -0,0 +1,52 @@
+import { surroundingAgent } from '../engine.mjs';
+import { Value } from '../value.mjs';
+import {
+  CreateMethodProperty,
+  ToString,
+  IterableToList,
+  OrdinaryCreateFromConstructor,
+} from '../abstract-ops/all.mjs';
+import { Q, X } from '../completion.mjs';
+import { captureStack } from '../helpers.mjs';
+import { BootstrapConstructor } from './Bootstrap.mjs';
+
+// https://tc39.es/proposal-promise-any/#sec-aggregate-error
+function AggregateErrorConstructor([errors = Value.undefined, message = Value.undefined], { NewTarget }) {
+  // 1. If NewTarget is undefined, let newTarget be the active function object, else let newTarget be NewTarget.
+  let newTarget;
+  if (NewTarget === Value.undefined) {
+    newTarget = surroundingAgent.activeFunctionObject;
+  } else {
+    newTarget = NewTarget;
+  }
+  // 2. Let O be ? OrdinaryCreateFromConstructor(newTarget, "%AggregateError.prototype%", « [[ErrorData]], [[AggregateErrors]] »).
+  const O = Q(OrdinaryCreateFromConstructor(newTarget, '%AggregateError.prototype%', [
+    'ErrorData',
+    'AggregateErrors',
+  ]));
+  // 3. Let errorsList be ? IterableToList(errors).
+  const errorsList = errors === Symbol.for('engine262.placeholder')
+    ? []
+    : Q(IterableToList(errors));
+  // 4. Set O.[[AggregateErrors]] to errorsList.
+  O.AggregateErrors = errorsList;
+  // 5. If message is not undefined, then
+  if (message !== Value.undefined) {
+    // a. Let msg be ? ToString(message).
+    const msg = Q(ToString(message));
+    // b. Perform ! CreateMethodProperty(O, "message", msg).
+    X(CreateMethodProperty(O, new Value('message'), msg));
+  }
+
+  // NON-SPEC
+  X(captureStack(O));
+
+  // 6. Return O.
+  return O;
+}
+
+export function BootstrapAggregateError(realmRec) {
+  const c = BootstrapConstructor(realmRec, AggregateErrorConstructor, 'AggregateError', 2, realmRec.Intrinsics['%AggregateError.prototype%'], []);
+  c.Prototype = realmRec.Intrinsics['%Error%'];
+  realmRec.Intrinsics['%AggregateError%'] = c;
+}

src/intrinsics/AggregateErrorPrototype.mjs

@@ -0,0 +1,26 @@
+import { Value } from '../value.mjs';
+import { RequireInternalSlot, CreateArrayFromList } from '../abstract-ops/all.mjs';
+import { Q, X } from '../completion.mjs';
+import { BootstrapPrototype } from './Bootstrap.mjs';
+
+// https://tc39.es/proposal-promise-any/#sec-aggregate-error.prototype.name
+function AggregateErrorProto_errors(args, { thisValue }) {
+  // 1. Let E be the this value.
+  const E = thisValue;
+  // 2. If Type(E) is not Object, throw a TypeError exception.
+  // 3. If E does not have an [[ErrorData]] internal slot, throw a TypeError exception.
+  // 4. If E does not have an [[AggregateErrors]] internal slot, throw a TypeError exception.
+  Q(RequireInternalSlot(E, 'AggregateErrors'));
+  // 5. Return ! CreateArrayFromList(E.[[AggregateErrors]]).
+  return X(CreateArrayFromList(E.AggregateErrors));
+}
+
+export function BootstrapAggregateErrorPrototype(realmRec) {
+  const proto = BootstrapPrototype(realmRec, [
+    ['name', new Value('AggregateError')],
+    ['message', new Value('')],
+    ['errors', [AggregateErrorProto_errors]],
+  ], realmRec.Intrinsics['%Error.prototype%'], 'AggregateError');
+
+  realmRec.Intrinsics['%AggregateError.prototype%'] = proto;
+}

src/intrinsics/Promise.mjs

@@ -31,14 +31,13 @@ import {
 } from '../abstract-ops/all.mjs';
 import {
   AbruptCompletion, Completion,
+  ThrowCompletion,
   IfAbruptRejectPromise,
-  Q,
   ReturnIfAbrupt,
-  X,
+  Q, X,
 } from '../completion.mjs';
 import { BootstrapConstructor } from './Bootstrap.mjs';
 
-
 function PromiseConstructor([executor = Value.undefined], { NewTarget }) {
   if (NewTarget === Value.undefined) {
     return surroundingAgent.Throw('TypeError', 'ConstructorNonCallable', this);
@@ -277,6 +276,149 @@ function Promise_allSettled([iterable = Value.undefined], { thisValue }) {
   return Completion(result);
 }
 
+// https://tc39.es/proposal-promise-any/#sec-promise.any-reject-element-functions
+function PromiseAnyRejectElementFunctions([x = Value.undefined]) {
+  // 1. Let F be the active function object.
+  const F = surroundingAgent.activeFunctionObject;
+  // 2. Let alreadyCalled be F.[[AlreadyCalled]].
+  const alreadyCalled = F.AlreadyCalled;
+  // 3. If alreadyCalled.[[Value]] is true, return undefined.
+  if (alreadyCalled.Value) {
+    return Value.undefined;
+  }
+  // 4. Set alreadyCalled.[[Value]] to true.
+  alreadyCalled.Value = true;
+  // 5. Let index be F.[[Index]].
+  const index = F.Index;
+  // 6. Let errors be F.[[Errors]].
+  const errors = F.Errors;
+  // 7. Let promiseCapability be F.[[Capability]].
+  const promiseCapability = F.Capability;
+  // 8. Let remainingElementsCount be F.[[RemainingElements]].
+  const remainingElementsCount = F.RemainingElements;
+  // 9. Set errors[index] to x.
+  errors[index] = x;
+  // 10. Set remainingElementsCount.[[Value]] to remainingElementsCount.[[Value]] - 1.
+  remainingElementsCount.Value -= 1;
+  // 11. If remainingElementsCount.[[Value]] is 0, then
+  if (remainingElementsCount.Value === 0) {
+    // a. Let error be a newly created AggregateError object.
+    const error = surroundingAgent.Throw('AggregateError', 'PromiseAnyRejected').Value;
+    // b. Set error.[[AggregateErrors]] to errors.
+    error.AggregateErrors = errors;
+    // c. Return ? Call(promiseCapability.[[Reject]], undefined, « error »).
+    return Q(Call(promiseCapability.Reject, Value.undefined, [error]));
+  }
+  // 12. Return undefined.
+  return Value.undefined;
+}
+
+// https://tc39.es/proposal-promise-any/#sec-performpromiseany
+function PerformPromiseAny(iteratorRecord, constructor, resultCapability) {
+  // 1. Assert: ! IsConstructor(constructor) is true.
+  Assert(X(IsConstructor(constructor)) === Value.true);
+  // 2. Assert: resultCapability is a PromiseCapability Record.
+  Assert(resultCapability instanceof PromiseCapabilityRecord);
+  // 3. Let errors be a new empty List.
+  const errors = [];
+  // 4. Let remainingElementsCount be a new Record { [[Value]]: 1 }.
+  const remainingElementsCount = { Value: 1 };
+  // 5. Let index be 0.
+  let index = 0;
+  // 6. Let promiseResolve be ? Get(constructor, "resolve").
+  const promiseResolve = Q(Get(constructor, new Value('resolve')));
+  // 7. If ! IsCallable(promiseResolve) is false, throw a TypeError exception.
+  if (X(IsCallable(promiseResolve)) === Value.false) {
+    return surroundingAgent.Throw('TypeError', 'NotAFunction', promiseResolve);
+  }
+  // 8. Repeat,
+  while (true) {
+    // a. Let next be IteratorStep(iteratorRecord).
+    const next = IteratorStep(iteratorRecord);
+    // b. If next is an abrupt completion, set iteratorRecord.[[Done]] to true.
+    if (next instanceof AbruptCompletion) {
+      iteratorRecord.Done = Value.true;
+    }
+    // c. ReturnIfAbrupt(next).
+    ReturnIfAbrupt(next);
+    // d. If next is false, then
+    if (next === Value.false) {
+      // i. Set iteratorRecord.[[Done]] to true.
+      iteratorRecord.Done = Value.true;
+      // ii. Set remainingElementsCount.[[Value]] to remainingElementsCount.[[Value]] - 1.
+      remainingElementsCount.Value -= 1;
+      // iii. If remainingElementsCount.[[Value]] is 0, then
+      if (remainingElementsCount.Value === 0) {
+        // 1. Let error be a newly created AggregateError object.
+        const error = surroundingAgent.Throw('AggregateError', 'PromiseAnyRejected').Value;
+        // 2. Set error.[[AggregateErrors]] to errors.
+        error.AggregateErrors = errors;
+        // 3. Return ThrowCompletion(error).
+        return ThrowCompletion(error);
+      }
+      // iv. Return resultCapability.[[Promise]].
+      return resultCapability.Promise;
+    }
+    // e. Let nextValue be IteratorValue(next).
+    const nextValue = IteratorValue(next);
+    // f. If nextValue is an abrupt completion, set iteratorRecord.[[Done]] to true.
+    if (nextValue instanceof AbruptCompletion) {
+      iteratorRecord.Done = Value.true;
+    }
+    // g. ReturnIfAbrupt(nextValue).
+    ReturnIfAbrupt(nextValue);
+    // h. Append undefined to errors.
+    errors.push(Value.undefined);
+    // i. Let nextPromise be ? Call(promiseResolve, constructor, « nextValue »).
+    const nextPromise = Q(Call(promiseResolve, constructor, [nextValue]));
+    // j. Let steps be the algorithm steps defined in Promise.any Reject Element Functions.
+    const steps = PromiseAnyRejectElementFunctions;
+    // k. Let rejectElement be ! CreateBuiltinFunction(steps, « [[AlreadyCalled]], [[Index]], [[Errors]], [[Capability]], [[RemainingElements]] »).
+    const rejectElement = X(CreateBuiltinFunction(steps, ['AlreadyCalled', 'Index', 'Errors', 'Capability', 'RemainingElements']));
+    // l. Set rejectElement.[[AlreadyCalled]] to a new Record { [[Value]]: false }.
+    rejectElement.AlreadyCalled = { Value: false };
+    // m. Set rejectElement.[[Index]] to index.
+    rejectElement.Index = index;
+    // n. Set rejectElement.[[Errors]] to errors.
+    rejectElement.Errors = errors;
+    // o. Set rejectElement.[[Capability]] to resultCapability.
+    rejectElement.Capability = resultCapability;
+    // p. Set rejectElement.[[RemainingElements]] to remainingElementsCount.
+    rejectElement.RemainingElements = remainingElementsCount;
+    // q. Set remainingElementsCount.[[Value]] to remainingElementsCount.[[Value]] + 1.
+    remainingElementsCount.Value += 1;
+    // r. Perform ? Invoke(nextPromise, "then", « resultCapability.[[Resolve]], rejectElement »).
+    Q(Invoke(nextPromise, new Value('then'), [resultCapability.Resolve, rejectElement]));
+    // s. Increase index by 1.
+    index += 1;
+  }
+}
+
+// https://tc39.es/proposal-promise-any/#sec-promise.any
+function Promise_any([iterable = Value.undefined], { thisValue }) {
+  // 1. Let C be the this value.
+  const C = thisValue;
+  // 2. Let promiseCapability be ? NewPromiseCapability(C).
+  const promiseCapability = Q(NewPromiseCapability(C));
+  // 3. Let iteratorRecord be GetIterator(iterable).
+  const iteratorRecord = GetIterator(iterable);
+  // 4. IfAbruptRejectPromise(iteratorRecord, promiseCapability).
+  IfAbruptRejectPromise(iteratorRecord, promiseCapability);
+  // 5. Let result be PerformPromiseAny(iteratorRecord, C, promiseCapability).
+  let result = PerformPromiseAny(iteratorRecord, C, promiseCapability);
+  // 6. If result is an abrupt completion, then
+  if (result instanceof AbruptCompletion) {
+    // a. If iteratorRecord.[[Done]] is false, set result to IteratorClose(iteratorRecord, result).
+    if (iteratorRecord.Done === Value.false) {
+      result = IteratorClose(iteratorRecord, result);
+    }
+    // b. IfAbruptRejectPromise(result, promiseCapability).
+    IfAbruptRejectPromise(result, promiseCapability);
+  }
+  // 1. Return Completion(result).
+  return Completion(result);
+}
+
 function PerformPromiseRace(iteratorRecord, constructor, resultCapability) {
   Assert(IsConstructor(constructor) === Value.true);
   Assert(resultCapability instanceof PromiseCapabilityRecord);
@@ -342,6 +484,9 @@ export function BootstrapPromise(realmRec) {
   const promiseConstructor = BootstrapConstructor(realmRec, PromiseConstructor, 'Promise', 1, realmRec.Intrinsics['%Promise.prototype%'], [
     ['all', Promise_all, 1],
     ['allSettled', Promise_allSettled, 1],
+    surroundingAgent.feature('Promise.any')
+      ? ['any', Promise_any, 1]
+      : undefined,
     ['race', Promise_race, 1],
     ['reject', Promise_reject, 1],
     ['resolve', Promise_resolve, 1],

src/messages.mjs

@@ -69,6 +69,7 @@ export const ObjectToPrimitive = () => 'Cannot convert object to primitive value
 export const ObjectPrototypeType = () => 'Object prototype must be an Object or null';
 export const ObjectSetPrototype = () => 'Could not set prototype of object';
 export const OutOfRange = (n) => `${n} is out of range`;
+export const PromiseAnyRejected = () => 'No promises passed to Promise.any were fulfilled';
 export const PromiseCapabilityFunctionAlreadySet = (f) => `Promise ${f} function already set`;
 export const PromiseRejectFunction = (v) => `Promise reject function ${i(v)} is not callable`;
 export const PromiseResolveFunction = (v) => `Promise resolve function ${i(v)} is not callable`;