tor-browser

The Tor Browser
git clone https://git.dasho.dev/tor-browser.git
Log | Files | Refs | README | LICENSE

Reflect.js (5536B)

      1 /* This Source Code Form is subject to the terms of the Mozilla Public
      2 * License, v. 2.0. If a copy of the MPL was not distributed with this
      3 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
      4 
      5 // ES2017 draft rev a785b0832b071f505a694e1946182adeab84c972
      6 // 7.3.17 CreateListFromArrayLike (obj [ , elementTypes ] )
      7 function CreateListFromArrayLikeForArgs(obj) {
      8  // Step 1 (not applicable).
      9 
     10  // Step 2.
     11  assert(
     12    IsObject(obj),
     13    "object must be passed to CreateListFromArrayLikeForArgs"
     14  );
     15 
     16  // Step 3.
     17  var len = ToLength(obj.length);
     18 
     19  // This version of CreateListFromArrayLike is only used for argument lists.
     20  if (len > MAX_ARGS_LENGTH) {
     21    ThrowRangeError(JSMSG_TOO_MANY_ARGUMENTS);
     22  }
     23 
     24  // Steps 4-6.
     25  var list = std_Array(len);
     26  for (var i = 0; i < len; i++) {
     27    DefineDataProperty(list, i, obj[i]);
     28  }
     29 
     30  // Step 7.
     31  return list;
     32 }
     33 
     34 // ES2017 draft rev a785b0832b071f505a694e1946182adeab84c972
     35 // 26.1.1 Reflect.apply ( target, thisArgument, argumentsList )
     36 function Reflect_apply(target, thisArgument, argumentsList) {
     37  // Step 1.
     38  if (!IsCallable(target)) {
     39    ThrowTypeError(JSMSG_NOT_FUNCTION, DecompileArg(0, target));
     40  }
     41 
     42  // Step 2.
     43  if (!IsObject(argumentsList)) {
     44    ThrowTypeError(
     45      JSMSG_OBJECT_REQUIRED_ARG,
     46      "`argumentsList`",
     47      "Reflect.apply",
     48      ToSource(argumentsList)
     49    );
     50  }
     51 
     52  // Steps 2-4.
     53  return callFunction(std_Function_apply, target, thisArgument, argumentsList);
     54 }
     55 // This function is only barely too long for normal inlining.
     56 SetIsInlinableLargeFunction(Reflect_apply);
     57 
     58 // ES2017 draft rev a785b0832b071f505a694e1946182adeab84c972
     59 // 26.1.2 Reflect.construct ( target, argumentsList [ , newTarget ] )
     60 function Reflect_construct(target, argumentsList /*, newTarget*/) {
     61  // Step 1.
     62  if (!IsConstructor(target)) {
     63    ThrowTypeError(JSMSG_NOT_CONSTRUCTOR, DecompileArg(0, target));
     64  }
     65 
     66  // Steps 2-3.
     67  var newTarget;
     68  if (ArgumentsLength() > 2) {
     69    newTarget = GetArgument(2);
     70    if (!IsConstructor(newTarget)) {
     71      ThrowTypeError(JSMSG_NOT_CONSTRUCTOR, DecompileArg(2, newTarget));
     72    }
     73  } else {
     74    newTarget = target;
     75  }
     76 
     77  // Step 4.
     78  if (!IsObject(argumentsList)) {
     79    ThrowTypeError(
     80      JSMSG_OBJECT_REQUIRED_ARG,
     81      "`argumentsList`",
     82      "Reflect.construct",
     83      ToSource(argumentsList)
     84    );
     85  }
     86 
     87  // Fast path when we can avoid calling CreateListFromArrayLikeForArgs().
     88  var args =
     89    IsPackedArray(argumentsList) && argumentsList.length <= MAX_ARGS_LENGTH
     90      ? argumentsList
     91      : CreateListFromArrayLikeForArgs(argumentsList);
     92 
     93  // Step 5.
     94  switch (args.length) {
     95    case 0:
     96      return constructContentFunction(target, newTarget);
     97    case 1:
     98      return constructContentFunction(target, newTarget, SPREAD(args, 1));
     99    case 2:
    100      return constructContentFunction(target, newTarget, SPREAD(args, 2));
    101    case 3:
    102      return constructContentFunction(target, newTarget, SPREAD(args, 3));
    103    case 4:
    104      return constructContentFunction(target, newTarget, SPREAD(args, 4));
    105    case 5:
    106      return constructContentFunction(target, newTarget, SPREAD(args, 5));
    107    case 6:
    108      return constructContentFunction(target, newTarget, SPREAD(args, 6));
    109    case 7:
    110      return constructContentFunction(target, newTarget, SPREAD(args, 7));
    111    case 8:
    112      return constructContentFunction(target, newTarget, SPREAD(args, 8));
    113    case 9:
    114      return constructContentFunction(target, newTarget, SPREAD(args, 9));
    115    case 10:
    116      return constructContentFunction(target, newTarget, SPREAD(args, 10));
    117    case 11:
    118      return constructContentFunction(target, newTarget, SPREAD(args, 11));
    119    case 12:
    120      return constructContentFunction(target, newTarget, SPREAD(args, 12));
    121    default:
    122      return ConstructFunction(target, newTarget, args);
    123  }
    124 }
    125 
    126 // ES2017 draft rev 6859bb9ccaea9c6ede81d71e5320e3833b92cb3e
    127 // 26.1.3 Reflect.defineProperty ( target, propertyKey, attributes )
    128 function Reflect_defineProperty(obj, propertyKey, attributes) {
    129  // Steps 1-4.
    130  return ObjectOrReflectDefineProperty(obj, propertyKey, attributes, false);
    131 }
    132 
    133 // ES2017 draft rev 6859bb9ccaea9c6ede81d71e5320e3833b92cb3e
    134 // 26.1.6 Reflect.getOwnPropertyDescriptor ( target, propertyKey )
    135 function Reflect_getOwnPropertyDescriptor(target, propertyKey) {
    136  // Step 1.
    137  if (!IsObject(target)) {
    138    ThrowTypeError(JSMSG_OBJECT_REQUIRED, DecompileArg(0, target));
    139  }
    140 
    141  // Steps 2-3.
    142  // The other steps are identical to Object.getOwnPropertyDescriptor().
    143  return ObjectGetOwnPropertyDescriptor(target, propertyKey);
    144 }
    145 
    146 // ES2017 draft rev a785b0832b071f505a694e1946182adeab84c972
    147 // 26.1.8 Reflect.has ( target, propertyKey )
    148 function Reflect_has(target, propertyKey) {
    149  // Step 1.
    150  if (!IsObject(target)) {
    151    ThrowTypeError(
    152      JSMSG_OBJECT_REQUIRED_ARG,
    153      "`target`",
    154      "Reflect.has",
    155      ToSource(target)
    156    );
    157  }
    158 
    159  // Steps 2-3 are identical to the runtime semantics of the "in" operator.
    160  return propertyKey in target;
    161 }
    162 
    163 // ES2018 draft rev 0525bb33861c7f4e9850f8a222c89642947c4b9c
    164 // 26.1.5 Reflect.get ( target, propertyKey [ , receiver ] )
    165 function Reflect_get(target, propertyKey /*, receiver*/) {
    166  // Step 1.
    167  if (!IsObject(target)) {
    168    ThrowTypeError(
    169      JSMSG_OBJECT_REQUIRED_ARG,
    170      "`target`",
    171      "Reflect.get",
    172      ToSource(target)
    173    );
    174  }
    175 
    176  // Step 3 (reordered).
    177  if (ArgumentsLength() > 2) {
    178    // Steps 2, 4.
    179    return getPropertySuper(target, propertyKey, GetArgument(2));
    180  }
    181 
    182  // Steps 2, 4.
    183  return target[propertyKey];
    184 }