Value.cpp 64 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752
  1. /*
  2. * Copyright (c) 2020, Andreas Kling <kling@serenityos.org>
  3. * Copyright (c) 2020-2022, Linus Groh <linusg@serenityos.org>
  4. * Copyright (c) 2022, David Tuin <davidot@serenityos.org>
  5. *
  6. * SPDX-License-Identifier: BSD-2-Clause
  7. */
  8. #include <AK/AllOf.h>
  9. #include <AK/Assertions.h>
  10. #include <AK/CharacterTypes.h>
  11. #include <AK/DeprecatedString.h>
  12. #include <AK/FloatingPointStringConversions.h>
  13. #include <AK/StringBuilder.h>
  14. #include <AK/StringFloatingPointConversions.h>
  15. #include <AK/Utf8View.h>
  16. #include <LibCrypto/BigInt/SignedBigInteger.h>
  17. #include <LibCrypto/NumberTheory/ModularFunctions.h>
  18. #include <LibJS/Runtime/AbstractOperations.h>
  19. #include <LibJS/Runtime/Accessor.h>
  20. #include <LibJS/Runtime/Array.h>
  21. #include <LibJS/Runtime/BigInt.h>
  22. #include <LibJS/Runtime/BigIntObject.h>
  23. #include <LibJS/Runtime/BooleanObject.h>
  24. #include <LibJS/Runtime/BoundFunction.h>
  25. #include <LibJS/Runtime/Completion.h>
  26. #include <LibJS/Runtime/Error.h>
  27. #include <LibJS/Runtime/FunctionObject.h>
  28. #include <LibJS/Runtime/GlobalObject.h>
  29. #include <LibJS/Runtime/NativeFunction.h>
  30. #include <LibJS/Runtime/NumberObject.h>
  31. #include <LibJS/Runtime/Object.h>
  32. #include <LibJS/Runtime/PrimitiveString.h>
  33. #include <LibJS/Runtime/ProxyObject.h>
  34. #include <LibJS/Runtime/RegExpObject.h>
  35. #include <LibJS/Runtime/StringObject.h>
  36. #include <LibJS/Runtime/StringPrototype.h>
  37. #include <LibJS/Runtime/SymbolObject.h>
  38. #include <LibJS/Runtime/VM.h>
  39. #include <LibJS/Runtime/Value.h>
  40. #include <math.h>
  41. namespace JS {
  42. static inline bool same_type_for_equality(Value const& lhs, Value const& rhs)
  43. {
  44. // If the top two bytes are identical then either:
  45. // both are NaN boxed Values with the same type
  46. // or they are doubles which happen to have the same top bytes.
  47. if ((lhs.encoded() & TAG_EXTRACTION) == (rhs.encoded() & TAG_EXTRACTION))
  48. return true;
  49. if (lhs.is_number() && rhs.is_number())
  50. return true;
  51. // One of the Values is not a number and they do not have the same tag
  52. return false;
  53. }
  54. static const Crypto::SignedBigInteger BIGINT_ZERO { 0 };
  55. ALWAYS_INLINE bool both_number(Value const& lhs, Value const& rhs)
  56. {
  57. return lhs.is_number() && rhs.is_number();
  58. }
  59. ALWAYS_INLINE bool both_bigint(Value const& lhs, Value const& rhs)
  60. {
  61. return lhs.is_bigint() && rhs.is_bigint();
  62. }
  63. // 6.1.6.1.20 Number::toString ( x ), https://tc39.es/ecma262/#sec-numeric-types-number-tostring
  64. // Implementation for radix = 10
  65. DeprecatedString number_to_string(double d, NumberToStringMode mode)
  66. {
  67. auto convert_to_decimal_digits_array = [](auto x, auto& digits, auto& length) {
  68. for (; x; x /= 10)
  69. digits[length++] = x % 10 | '0';
  70. for (i32 i = 0; 2 * i + 1 < length; ++i)
  71. swap(digits[i], digits[length - i - 1]);
  72. };
  73. // 1. If x is NaN, return "NaN".
  74. if (isnan(d))
  75. return "NaN";
  76. // 2. If x is +0𝔽 or -0𝔽, return "0".
  77. if (d == +0.0 || d == -0.0)
  78. return "0";
  79. // 4. If x is +∞𝔽, return "Infinity".
  80. if (isinf(d)) {
  81. if (d > 0)
  82. return "Infinity";
  83. else
  84. return "-Infinity";
  85. }
  86. StringBuilder builder;
  87. // 5. Let n, k, and s be integers such that k ≥ 1, radix ^ (k - 1) ≤ s < radix ^ k,
  88. // 𝔽(s × radix ^ (n - k)) is x, and k is as small as possible. Note that k is the number of
  89. // digits in the representation of s using radix radix, that s is not divisible by radix, and
  90. // that the least significant digit of s is not necessarily uniquely determined by these criteria.
  91. //
  92. // Note: guarantees provided by convert_floating_point_to_decimal_exponential_form satisfy
  93. // requirements of NOTE 2.
  94. auto [sign, mantissa, exponent] = convert_floating_point_to_decimal_exponential_form(d);
  95. i32 k = 0;
  96. AK::Array<char, 20> mantissa_digits;
  97. convert_to_decimal_digits_array(mantissa, mantissa_digits, k);
  98. i32 n = exponent + k; // s = mantissa
  99. // 3. If x < -0𝔽, return the string-concatenation of "-" and Number::toString(-x, radix).
  100. if (sign)
  101. builder.append('-');
  102. // Non-standard: Intl needs number-to-string conversions for extremely large numbers without any
  103. // exponential formatting, as it will handle such formatting itself in a locale-aware way.
  104. bool force_no_exponent = mode == NumberToStringMode::WithoutExponent;
  105. // 6. If radix ≠ 10 or n is in the inclusive interval from -5 to 21, then
  106. if ((n >= -5 && n <= 21) || force_no_exponent) {
  107. // a. If n ≥ k, then
  108. if (n >= k) {
  109. // i. Return the string-concatenation of:
  110. // the code units of the k digits of the representation of s using radix radix
  111. builder.append(mantissa_digits.data(), k);
  112. // n - k occurrences of the code unit 0x0030 (DIGIT ZERO)
  113. builder.append_repeated('0', n - k);
  114. // b. Else if n > 0, then
  115. } else if (n > 0) {
  116. // i. Return the string-concatenation of:
  117. // the code units of the most significant n digits of the representation of s using radix radix
  118. builder.append(mantissa_digits.data(), n);
  119. // the code unit 0x002E (FULL STOP)
  120. builder.append('.');
  121. // the code units of the remaining k - n digits of the representation of s using radix radix
  122. builder.append(mantissa_digits.data() + n, k - n);
  123. // c. Else,
  124. } else {
  125. // i. Assert: n ≤ 0.
  126. VERIFY(n <= 0);
  127. // ii. Return the string-concatenation of:
  128. // the code unit 0x0030 (DIGIT ZERO)
  129. builder.append('0');
  130. // the code unit 0x002E (FULL STOP)
  131. builder.append('.');
  132. // -n occurrences of the code unit 0x0030 (DIGIT ZERO)
  133. builder.append_repeated('0', -n);
  134. // the code units of the k digits of the representation of s using radix radix
  135. builder.append(mantissa_digits.data(), k);
  136. }
  137. return builder.to_deprecated_string();
  138. }
  139. // 7. NOTE: In this case, the input will be represented using scientific E notation, such as 1.2e+3.
  140. // 9. If n < 0, then
  141. // a. Let exponentSign be the code unit 0x002D (HYPHEN-MINUS).
  142. // 10. Else,
  143. // a. Let exponentSign be the code unit 0x002B (PLUS SIGN).
  144. char exponent_sign = n < 0 ? '-' : '+';
  145. AK::Array<char, 5> exponent_digits;
  146. i32 exponent_length = 0;
  147. convert_to_decimal_digits_array(abs(n - 1), exponent_digits, exponent_length);
  148. // 11. If k is 1, then
  149. if (k == 1) {
  150. // a. Return the string-concatenation of:
  151. // the code unit of the single digit of s
  152. builder.append(mantissa_digits[0]);
  153. // the code unit 0x0065 (LATIN SMALL LETTER E)
  154. builder.append('e');
  155. // exponentSign
  156. builder.append(exponent_sign);
  157. // the code units of the decimal representation of abs(n - 1)
  158. builder.append(exponent_digits.data(), exponent_length);
  159. return builder.to_deprecated_string();
  160. }
  161. // 12. Return the string-concatenation of:
  162. // the code unit of the most significant digit of the decimal representation of s
  163. builder.append(mantissa_digits[0]);
  164. // the code unit 0x002E (FULL STOP)
  165. builder.append('.');
  166. // the code units of the remaining k - 1 digits of the decimal representation of s
  167. builder.append(mantissa_digits.data() + 1, k - 1);
  168. // the code unit 0x0065 (LATIN SMALL LETTER E)
  169. builder.append('e');
  170. // exponentSign
  171. builder.append(exponent_sign);
  172. // the code units of the decimal representation of abs(n - 1)
  173. builder.append(exponent_digits.data(), exponent_length);
  174. return builder.to_deprecated_string();
  175. }
  176. // 7.2.2 IsArray ( argument ), https://tc39.es/ecma262/#sec-isarray
  177. ThrowCompletionOr<bool> Value::is_array(VM& vm) const
  178. {
  179. // 1. If argument is not an Object, return false.
  180. if (!is_object())
  181. return false;
  182. auto const& object = as_object();
  183. // 2. If argument is an Array exotic object, return true.
  184. if (is<Array>(object))
  185. return true;
  186. // 3. If argument is a Proxy exotic object, then
  187. if (is<ProxyObject>(object)) {
  188. auto const& proxy = static_cast<ProxyObject const&>(object);
  189. // a. If argument.[[ProxyHandler]] is null, throw a TypeError exception.
  190. if (proxy.is_revoked())
  191. return vm.throw_completion<TypeError>(ErrorType::ProxyRevoked);
  192. // b. Let target be argument.[[ProxyTarget]].
  193. auto const& target = proxy.target();
  194. // c. Return ? IsArray(target).
  195. return Value(&target).is_array(vm);
  196. }
  197. // 4. Return false.
  198. return false;
  199. }
  200. Array& Value::as_array()
  201. {
  202. VERIFY(is_object() && is<Array>(as_object()));
  203. return static_cast<Array&>(as_object());
  204. }
  205. // 7.2.3 IsCallable ( argument ), https://tc39.es/ecma262/#sec-iscallable
  206. bool Value::is_function() const
  207. {
  208. // 1. If argument is not an Object, return false.
  209. // 2. If argument has a [[Call]] internal method, return true.
  210. // 3. Return false.
  211. return is_object() && as_object().is_function();
  212. }
  213. FunctionObject& Value::as_function()
  214. {
  215. VERIFY(is_function());
  216. return static_cast<FunctionObject&>(as_object());
  217. }
  218. FunctionObject const& Value::as_function() const
  219. {
  220. VERIFY(is_function());
  221. return static_cast<FunctionObject const&>(as_object());
  222. }
  223. // 7.2.4 IsConstructor ( argument ), https://tc39.es/ecma262/#sec-isconstructor
  224. bool Value::is_constructor() const
  225. {
  226. // 1. If Type(argument) is not Object, return false.
  227. if (!is_function())
  228. return false;
  229. // 2. If argument has a [[Construct]] internal method, return true.
  230. if (as_function().has_constructor())
  231. return true;
  232. // 3. Return false.
  233. return false;
  234. }
  235. // 7.2.8 IsRegExp ( argument ), https://tc39.es/ecma262/#sec-isregexp
  236. ThrowCompletionOr<bool> Value::is_regexp(VM& vm) const
  237. {
  238. // 1. If argument is not an Object, return false.
  239. if (!is_object())
  240. return false;
  241. // 2. Let matcher be ? Get(argument, @@match).
  242. auto matcher = TRY(as_object().get(*vm.well_known_symbol_match()));
  243. // 3. If matcher is not undefined, return ToBoolean(matcher).
  244. if (!matcher.is_undefined())
  245. return matcher.to_boolean();
  246. // 4. If argument has a [[RegExpMatcher]] internal slot, return true.
  247. // 5. Return false.
  248. return is<RegExpObject>(as_object());
  249. }
  250. // 13.5.3 The typeof Operator, https://tc39.es/ecma262/#sec-typeof-operator
  251. DeprecatedString Value::typeof() const
  252. {
  253. // 9. If val is a Number, return "number".
  254. if (is_number())
  255. return "number";
  256. switch (m_value.tag) {
  257. // 4. If val is undefined, return "undefined".
  258. case UNDEFINED_TAG:
  259. return "undefined";
  260. // 5. If val is null, return "object".
  261. case NULL_TAG:
  262. return "object";
  263. // 6. If val is a String, return "string".
  264. case STRING_TAG:
  265. return "string";
  266. // 7. If val is a Symbol, return "symbol".
  267. case SYMBOL_TAG:
  268. return "symbol";
  269. // 8. If val is a Boolean, return "boolean".
  270. case BOOLEAN_TAG:
  271. return "boolean";
  272. // 10. If val is a BigInt, return "bigint".
  273. case BIGINT_TAG:
  274. return "bigint";
  275. // 11. Assert: val is an Object.
  276. case OBJECT_TAG:
  277. // B.3.6.3 Changes to the typeof Operator, https://tc39.es/ecma262/#sec-IsHTMLDDA-internal-slot-typeof
  278. // 12. If val has an [[IsHTMLDDA]] internal slot, return "undefined".
  279. if (as_object().is_htmldda())
  280. return "undefined";
  281. // 13. If val has a [[Call]] internal slot, return "function".
  282. if (is_function())
  283. return "function";
  284. // 14. Return "object".
  285. return "object";
  286. default:
  287. VERIFY_NOT_REACHED();
  288. }
  289. }
  290. DeprecatedString Value::to_string_without_side_effects() const
  291. {
  292. if (is_double())
  293. return number_to_string(m_value.as_double);
  294. switch (m_value.tag) {
  295. case UNDEFINED_TAG:
  296. return "undefined";
  297. case NULL_TAG:
  298. return "null";
  299. case BOOLEAN_TAG:
  300. return as_bool() ? "true" : "false";
  301. case INT32_TAG:
  302. return DeprecatedString::number(as_i32());
  303. case STRING_TAG:
  304. return as_string().deprecated_string();
  305. case SYMBOL_TAG:
  306. return as_symbol().to_deprecated_string();
  307. case BIGINT_TAG:
  308. return as_bigint().to_deprecated_string();
  309. case OBJECT_TAG:
  310. return DeprecatedString::formatted("[object {}]", as_object().class_name());
  311. case ACCESSOR_TAG:
  312. return "<accessor>";
  313. default:
  314. VERIFY_NOT_REACHED();
  315. }
  316. }
  317. ThrowCompletionOr<PrimitiveString*> Value::to_primitive_string(VM& vm)
  318. {
  319. if (is_string())
  320. return &as_string();
  321. auto string = TRY(to_string(vm));
  322. return PrimitiveString::create(vm, string).ptr();
  323. }
  324. // 7.1.17 ToString ( argument ), https://tc39.es/ecma262/#sec-tostring
  325. ThrowCompletionOr<DeprecatedString> Value::to_string(VM& vm) const
  326. {
  327. if (is_double())
  328. return number_to_string(m_value.as_double);
  329. switch (m_value.tag) {
  330. // 1. If argument is a String, return argument.
  331. case STRING_TAG:
  332. return as_string().deprecated_string();
  333. // 2. If argument is a Symbol, throw a TypeError exception.
  334. case SYMBOL_TAG:
  335. return vm.throw_completion<TypeError>(ErrorType::Convert, "symbol", "string");
  336. // 3. If argument is undefined, return "undefined".
  337. case UNDEFINED_TAG:
  338. return "undefined"sv;
  339. // 4. If argument is null, return "null".
  340. case NULL_TAG:
  341. return "null"sv;
  342. // 5. If argument is true, return "true".
  343. // 6. If argument is false, return "false".
  344. case BOOLEAN_TAG:
  345. return as_bool() ? "true"sv : "false"sv;
  346. // 7. If argument is a Number, return Number::toString(argument, 10).
  347. case INT32_TAG:
  348. return DeprecatedString::number(as_i32());
  349. // 8. If argument is a BigInt, return BigInt::toString(argument, 10).
  350. case BIGINT_TAG:
  351. return as_bigint().big_integer().to_base(10);
  352. // 9. Assert: argument is an Object.
  353. case OBJECT_TAG: {
  354. // 10. Let primValue be ? ToPrimitive(argument, string).
  355. auto primitive_value = TRY(to_primitive(vm, PreferredType::String));
  356. // 11. Assert: primValue is not an Object.
  357. VERIFY(!primitive_value.is_object());
  358. // 12. Return ? ToString(primValue).
  359. return primitive_value.to_string(vm);
  360. }
  361. default:
  362. VERIFY_NOT_REACHED();
  363. }
  364. }
  365. ThrowCompletionOr<Utf16String> Value::to_utf16_string(VM& vm) const
  366. {
  367. if (is_string())
  368. return as_string().utf16_string();
  369. auto utf8_string = TRY(to_string(vm));
  370. return Utf16String(utf8_string);
  371. }
  372. // 7.1.2 ToBoolean ( argument ), https://tc39.es/ecma262/#sec-toboolean
  373. bool Value::to_boolean() const
  374. {
  375. if (is_double()) {
  376. if (is_nan())
  377. return false;
  378. return m_value.as_double != 0;
  379. }
  380. switch (m_value.tag) {
  381. // 1. If argument is a Boolean, return argument.
  382. case BOOLEAN_TAG:
  383. return as_bool();
  384. // 2. If argument is any of undefined, null, +0𝔽, -0𝔽, NaN, 0ℤ, or the empty String, return false.
  385. case UNDEFINED_TAG:
  386. case NULL_TAG:
  387. return false;
  388. case INT32_TAG:
  389. return as_i32() != 0;
  390. case STRING_TAG:
  391. return !as_string().is_empty();
  392. case BIGINT_TAG:
  393. return as_bigint().big_integer() != BIGINT_ZERO;
  394. case OBJECT_TAG:
  395. // B.3.6.1 Changes to ToBoolean, https://tc39.es/ecma262/#sec-IsHTMLDDA-internal-slot-to-boolean
  396. // 3. If argument is an Object and argument has an [[IsHTMLDDA]] internal slot, return false.
  397. if (as_object().is_htmldda())
  398. return false;
  399. // 4. Return true.
  400. return true;
  401. case SYMBOL_TAG:
  402. return true;
  403. default:
  404. VERIFY_NOT_REACHED();
  405. }
  406. }
  407. // 7.1.1 ToPrimitive ( input [ , preferredType ] ), https://tc39.es/ecma262/#sec-toprimitive
  408. ThrowCompletionOr<Value> Value::to_primitive(VM& vm, PreferredType preferred_type) const
  409. {
  410. // 1. If input is an Object, then
  411. if (is_object()) {
  412. // a. Let exoticToPrim be ? GetMethod(input, @@toPrimitive).
  413. auto* exotic_to_primitive = TRY(get_method(vm, *vm.well_known_symbol_to_primitive()));
  414. // b. If exoticToPrim is not undefined, then
  415. if (exotic_to_primitive) {
  416. auto hint = [&]() -> DeprecatedString {
  417. switch (preferred_type) {
  418. // i. If preferredType is not present, let hint be "default".
  419. case PreferredType::Default:
  420. return "default";
  421. // ii. Else if preferredType is string, let hint be "string".
  422. case PreferredType::String:
  423. return "string";
  424. // iii. Else,
  425. // 1. Assert: preferredType is number.
  426. // 2. Let hint be "number".
  427. case PreferredType::Number:
  428. return "number";
  429. default:
  430. VERIFY_NOT_REACHED();
  431. }
  432. }();
  433. // iv. Let result be ? Call(exoticToPrim, input, « hint »).
  434. auto result = TRY(call(vm, *exotic_to_primitive, *this, PrimitiveString::create(vm, hint)));
  435. // v. If result is not an Object, return result.
  436. if (!result.is_object())
  437. return result;
  438. // vi. Throw a TypeError exception.
  439. return vm.throw_completion<TypeError>(ErrorType::ToPrimitiveReturnedObject, to_string_without_side_effects(), hint);
  440. }
  441. // c. If preferredType is not present, let preferredType be number.
  442. if (preferred_type == PreferredType::Default)
  443. preferred_type = PreferredType::Number;
  444. // d. Return ? OrdinaryToPrimitive(input, preferredType).
  445. return as_object().ordinary_to_primitive(preferred_type);
  446. }
  447. // 2. Return input.
  448. return *this;
  449. }
  450. // 7.1.18 ToObject ( argument ), https://tc39.es/ecma262/#sec-toobject
  451. ThrowCompletionOr<Object*> Value::to_object(VM& vm) const
  452. {
  453. auto& realm = *vm.current_realm();
  454. VERIFY(!is_empty());
  455. // Number
  456. if (is_number()) {
  457. // Return a new Number object whose [[NumberData]] internal slot is set to argument. See 21.1 for a description of Number objects.
  458. return NumberObject::create(realm, as_double());
  459. }
  460. switch (m_value.tag) {
  461. // Undefined
  462. // Null
  463. case UNDEFINED_TAG:
  464. case NULL_TAG:
  465. // Throw a TypeError exception.
  466. return vm.throw_completion<TypeError>(ErrorType::ToObjectNullOrUndefined);
  467. // Boolean
  468. case BOOLEAN_TAG:
  469. // Return a new Boolean object whose [[BooleanData]] internal slot is set to argument. See 20.3 for a description of Boolean objects.
  470. return BooleanObject::create(realm, as_bool());
  471. // String
  472. case STRING_TAG:
  473. // Return a new String object whose [[StringData]] internal slot is set to argument. See 22.1 for a description of String objects.
  474. return StringObject::create(realm, const_cast<JS::PrimitiveString&>(as_string()), *realm.intrinsics().string_prototype());
  475. // Symbol
  476. case SYMBOL_TAG:
  477. // Return a new Symbol object whose [[SymbolData]] internal slot is set to argument. See 20.4 for a description of Symbol objects.
  478. return SymbolObject::create(realm, const_cast<JS::Symbol&>(as_symbol()));
  479. // BigInt
  480. case BIGINT_TAG:
  481. // Return a new BigInt object whose [[BigIntData]] internal slot is set to argument. See 21.2 for a description of BigInt objects.
  482. return BigIntObject::create(realm, const_cast<JS::BigInt&>(as_bigint()));
  483. // Object
  484. case OBJECT_TAG:
  485. // Return argument.
  486. return &const_cast<Object&>(as_object());
  487. default:
  488. VERIFY_NOT_REACHED();
  489. }
  490. }
  491. // 7.1.3 ToNumeric ( value ), https://tc39.es/ecma262/#sec-tonumeric
  492. FLATTEN ThrowCompletionOr<Value> Value::to_numeric(VM& vm) const
  493. {
  494. auto primitive = TRY(to_primitive(vm, Value::PreferredType::Number));
  495. if (primitive.is_bigint())
  496. return primitive;
  497. return primitive.to_number(vm);
  498. }
  499. constexpr bool is_ascii_number(u32 code_point)
  500. {
  501. return is_ascii_digit(code_point) || code_point == '.' || (code_point == 'e' || code_point == 'E') || code_point == '+' || code_point == '-';
  502. }
  503. struct NumberParseResult {
  504. StringView literal;
  505. u8 base;
  506. };
  507. static Optional<NumberParseResult> parse_number_text(StringView text)
  508. {
  509. NumberParseResult result {};
  510. auto check_prefix = [&](auto lower_prefix, auto upper_prefix) {
  511. if (text.length() <= 2)
  512. return false;
  513. if (!text.starts_with(lower_prefix) && !text.starts_with(upper_prefix))
  514. return false;
  515. return true;
  516. };
  517. // https://tc39.es/ecma262/#sec-tonumber-applied-to-the-string-type
  518. if (check_prefix("0b"sv, "0B"sv)) {
  519. if (!all_of(text.substring_view(2), is_ascii_binary_digit))
  520. return {};
  521. result.literal = text.substring_view(2);
  522. result.base = 2;
  523. } else if (check_prefix("0o"sv, "0O"sv)) {
  524. if (!all_of(text.substring_view(2), is_ascii_octal_digit))
  525. return {};
  526. result.literal = text.substring_view(2);
  527. result.base = 8;
  528. } else if (check_prefix("0x"sv, "0X"sv)) {
  529. if (!all_of(text.substring_view(2), is_ascii_hex_digit))
  530. return {};
  531. result.literal = text.substring_view(2);
  532. result.base = 16;
  533. } else {
  534. if (!all_of(text, is_ascii_number))
  535. return {};
  536. result.literal = text;
  537. result.base = 10;
  538. }
  539. return result;
  540. }
  541. // 7.1.4.1.1 StringToNumber ( str ), https://tc39.es/ecma262/#sec-stringtonumber
  542. Optional<Value> string_to_number(StringView string)
  543. {
  544. // 1. Let text be StringToCodePoints(str).
  545. DeprecatedString text = Utf8View(string).trim(whitespace_characters, AK::TrimMode::Both).as_string();
  546. // 2. Let literal be ParseText(text, StringNumericLiteral).
  547. if (text.is_empty())
  548. return Value(0);
  549. if (text == "Infinity" || text == "+Infinity")
  550. return js_infinity();
  551. if (text == "-Infinity")
  552. return js_negative_infinity();
  553. auto result = parse_number_text(text);
  554. // 3. If literal is a List of errors, return NaN.
  555. if (!result.has_value())
  556. return js_nan();
  557. // 4. Return StringNumericValue of literal.
  558. if (result->base != 10) {
  559. auto bigint = Crypto::UnsignedBigInteger::from_base(result->base, result->literal);
  560. return Value(bigint.to_double());
  561. }
  562. auto maybe_double = text.to_double(AK::TrimWhitespace::No);
  563. if (!maybe_double.has_value())
  564. return js_nan();
  565. return Value(*maybe_double);
  566. }
  567. // 7.1.4 ToNumber ( argument ), https://tc39.es/ecma262/#sec-tonumber
  568. ThrowCompletionOr<Value> Value::to_number(VM& vm) const
  569. {
  570. VERIFY(!is_empty());
  571. if (is_number())
  572. return *this;
  573. switch (m_value.tag) {
  574. case UNDEFINED_TAG:
  575. return js_nan();
  576. case NULL_TAG:
  577. return Value(0);
  578. case BOOLEAN_TAG:
  579. return Value(as_bool() ? 1 : 0);
  580. case STRING_TAG:
  581. return string_to_number(as_string().deprecated_string().view());
  582. case SYMBOL_TAG:
  583. return vm.throw_completion<TypeError>(ErrorType::Convert, "symbol", "number");
  584. case BIGINT_TAG:
  585. return vm.throw_completion<TypeError>(ErrorType::Convert, "BigInt", "number");
  586. case OBJECT_TAG: {
  587. auto primitive = TRY(to_primitive(vm, PreferredType::Number));
  588. return primitive.to_number(vm);
  589. }
  590. default:
  591. VERIFY_NOT_REACHED();
  592. }
  593. }
  594. static Optional<BigInt*> string_to_bigint(VM& vm, StringView string);
  595. // 7.1.13 ToBigInt ( argument ), https://tc39.es/ecma262/#sec-tobigint
  596. ThrowCompletionOr<BigInt*> Value::to_bigint(VM& vm) const
  597. {
  598. auto primitive = TRY(to_primitive(vm, PreferredType::Number));
  599. VERIFY(!primitive.is_empty());
  600. if (primitive.is_number())
  601. return vm.throw_completion<TypeError>(ErrorType::Convert, "number", "BigInt");
  602. switch (primitive.m_value.tag) {
  603. case UNDEFINED_TAG:
  604. return vm.throw_completion<TypeError>(ErrorType::Convert, "undefined", "BigInt");
  605. case NULL_TAG:
  606. return vm.throw_completion<TypeError>(ErrorType::Convert, "null", "BigInt");
  607. case BOOLEAN_TAG: {
  608. auto value = primitive.as_bool() ? 1 : 0;
  609. return BigInt::create(vm, Crypto::SignedBigInteger { value }).ptr();
  610. }
  611. case BIGINT_TAG:
  612. return &primitive.as_bigint();
  613. case STRING_TAG: {
  614. // 1. Let n be ! StringToBigInt(prim).
  615. auto bigint = string_to_bigint(vm, primitive.as_string().deprecated_string());
  616. // 2. If n is undefined, throw a SyntaxError exception.
  617. if (!bigint.has_value())
  618. return vm.throw_completion<SyntaxError>(ErrorType::BigIntInvalidValue, primitive);
  619. // 3. Return n.
  620. return bigint.release_value();
  621. }
  622. case SYMBOL_TAG:
  623. return vm.throw_completion<TypeError>(ErrorType::Convert, "symbol", "BigInt");
  624. default:
  625. VERIFY_NOT_REACHED();
  626. }
  627. }
  628. struct BigIntParseResult {
  629. StringView literal;
  630. u8 base { 10 };
  631. bool is_negative { false };
  632. };
  633. static Optional<BigIntParseResult> parse_bigint_text(StringView text)
  634. {
  635. BigIntParseResult result {};
  636. auto parse_for_prefixed_base = [&](auto lower_prefix, auto upper_prefix, auto validator) {
  637. if (text.length() <= 2)
  638. return false;
  639. if (!text.starts_with(lower_prefix) && !text.starts_with(upper_prefix))
  640. return false;
  641. return all_of(text.substring_view(2), validator);
  642. };
  643. if (parse_for_prefixed_base("0b"sv, "0B"sv, is_ascii_binary_digit)) {
  644. result.literal = text.substring_view(2);
  645. result.base = 2;
  646. } else if (parse_for_prefixed_base("0o"sv, "0O"sv, is_ascii_octal_digit)) {
  647. result.literal = text.substring_view(2);
  648. result.base = 8;
  649. } else if (parse_for_prefixed_base("0x"sv, "0X"sv, is_ascii_hex_digit)) {
  650. result.literal = text.substring_view(2);
  651. result.base = 16;
  652. } else {
  653. if (text.starts_with('-')) {
  654. text = text.substring_view(1);
  655. result.is_negative = true;
  656. } else if (text.starts_with('+')) {
  657. text = text.substring_view(1);
  658. }
  659. if (!all_of(text, is_ascii_digit))
  660. return {};
  661. result.literal = text;
  662. result.base = 10;
  663. }
  664. return result;
  665. }
  666. // 7.1.14 StringToBigInt ( str ), https://tc39.es/ecma262/#sec-stringtobigint
  667. static Optional<BigInt*> string_to_bigint(VM& vm, StringView string)
  668. {
  669. // 1. Let text be StringToCodePoints(str).
  670. auto text = Utf8View(string).trim(whitespace_characters, AK::TrimMode::Both).as_string();
  671. // 2. Let literal be ParseText(text, StringIntegerLiteral).
  672. auto result = parse_bigint_text(text);
  673. // 3. If literal is a List of errors, return undefined.
  674. if (!result.has_value())
  675. return {};
  676. // 4. Let mv be the MV of literal.
  677. // 5. Assert: mv is an integer.
  678. auto bigint = Crypto::SignedBigInteger::from_base(result->base, result->literal);
  679. if (result->is_negative && (bigint != BIGINT_ZERO))
  680. bigint.negate();
  681. // 6. Return ℤ(mv).
  682. return BigInt::create(vm, move(bigint));
  683. }
  684. // 7.1.15 ToBigInt64 ( argument ), https://tc39.es/ecma262/#sec-tobigint64
  685. ThrowCompletionOr<i64> Value::to_bigint_int64(VM& vm) const
  686. {
  687. auto* bigint = TRY(to_bigint(vm));
  688. return static_cast<i64>(bigint->big_integer().to_u64());
  689. }
  690. // 7.1.16 ToBigUint64 ( argument ), https://tc39.es/ecma262/#sec-tobiguint64
  691. ThrowCompletionOr<u64> Value::to_bigint_uint64(VM& vm) const
  692. {
  693. auto* bigint = TRY(to_bigint(vm));
  694. return bigint->big_integer().to_u64();
  695. }
  696. ThrowCompletionOr<double> Value::to_double(VM& vm) const
  697. {
  698. return TRY(to_number(vm)).as_double();
  699. }
  700. // 7.1.19 ToPropertyKey ( argument ), https://tc39.es/ecma262/#sec-topropertykey
  701. ThrowCompletionOr<PropertyKey> Value::to_property_key(VM& vm) const
  702. {
  703. if (is_int32() && as_i32() >= 0)
  704. return PropertyKey { as_i32() };
  705. auto key = TRY(to_primitive(vm, PreferredType::String));
  706. if (key.is_symbol())
  707. return &key.as_symbol();
  708. return TRY(key.to_string(vm));
  709. }
  710. ThrowCompletionOr<i32> Value::to_i32_slow_case(VM& vm) const
  711. {
  712. VERIFY(!is_int32());
  713. double value = TRY(to_number(vm)).as_double();
  714. if (!isfinite(value) || value == 0)
  715. return 0;
  716. auto abs = fabs(value);
  717. auto int_val = floor(abs);
  718. if (signbit(value))
  719. int_val = -int_val;
  720. auto remainder = fmod(int_val, 4294967296.0);
  721. auto int32bit = remainder >= 0.0 ? remainder : remainder + 4294967296.0; // The notation “x modulo y” computes a value k of the same sign as y
  722. if (int32bit >= 2147483648.0)
  723. int32bit -= 4294967296.0;
  724. return static_cast<i32>(int32bit);
  725. }
  726. ThrowCompletionOr<i32> Value::to_i32(VM& vm) const
  727. {
  728. if (is_int32())
  729. return as_i32();
  730. return to_i32_slow_case(vm);
  731. }
  732. // 7.1.7 ToUint32 ( argument ), https://tc39.es/ecma262/#sec-touint32
  733. ThrowCompletionOr<u32> Value::to_u32(VM& vm) const
  734. {
  735. double value = TRY(to_number(vm)).as_double();
  736. if (!isfinite(value) || value == 0)
  737. return 0;
  738. auto int_val = floor(fabs(value));
  739. if (signbit(value))
  740. int_val = -int_val;
  741. auto int32bit = fmod(int_val, NumericLimits<u32>::max() + 1.0);
  742. // Cast to i64 here to ensure that the double --> u32 cast doesn't invoke undefined behavior
  743. // Otherwise, negative numbers cause a UBSAN warning.
  744. return static_cast<u32>(static_cast<i64>(int32bit));
  745. }
  746. // 7.1.8 ToInt16 ( argument ), https://tc39.es/ecma262/#sec-toint16
  747. ThrowCompletionOr<i16> Value::to_i16(VM& vm) const
  748. {
  749. double value = TRY(to_number(vm)).as_double();
  750. if (!isfinite(value) || value == 0)
  751. return 0;
  752. auto abs = fabs(value);
  753. auto int_val = floor(abs);
  754. if (signbit(value))
  755. int_val = -int_val;
  756. auto remainder = fmod(int_val, 65536.0);
  757. auto int16bit = remainder >= 0.0 ? remainder : remainder + 65536.0; // The notation “x modulo y” computes a value k of the same sign as y
  758. if (int16bit >= 32768.0)
  759. int16bit -= 65536.0;
  760. return static_cast<i16>(int16bit);
  761. }
  762. // 7.1.9 ToUint16 ( argument ), https://tc39.es/ecma262/#sec-touint16
  763. ThrowCompletionOr<u16> Value::to_u16(VM& vm) const
  764. {
  765. double value = TRY(to_number(vm)).as_double();
  766. if (!isfinite(value) || value == 0)
  767. return 0;
  768. auto int_val = floor(fabs(value));
  769. if (signbit(value))
  770. int_val = -int_val;
  771. auto int16bit = fmod(int_val, NumericLimits<u16>::max() + 1.0);
  772. if (int16bit < 0)
  773. int16bit += NumericLimits<u16>::max() + 1.0;
  774. return static_cast<u16>(int16bit);
  775. }
  776. // 7.1.10 ToInt8 ( argument ), https://tc39.es/ecma262/#sec-toint8
  777. ThrowCompletionOr<i8> Value::to_i8(VM& vm) const
  778. {
  779. double value = TRY(to_number(vm)).as_double();
  780. if (!isfinite(value) || value == 0)
  781. return 0;
  782. auto abs = fabs(value);
  783. auto int_val = floor(abs);
  784. if (signbit(value))
  785. int_val = -int_val;
  786. auto remainder = fmod(int_val, 256.0);
  787. auto int8bit = remainder >= 0.0 ? remainder : remainder + 256.0; // The notation “x modulo y” computes a value k of the same sign as y
  788. if (int8bit >= 128.0)
  789. int8bit -= 256.0;
  790. return static_cast<i8>(int8bit);
  791. }
  792. // 7.1.11 ToUint8 ( argument ), https://tc39.es/ecma262/#sec-touint8
  793. ThrowCompletionOr<u8> Value::to_u8(VM& vm) const
  794. {
  795. double value = TRY(to_number(vm)).as_double();
  796. if (!isfinite(value) || value == 0)
  797. return 0;
  798. auto int_val = floor(fabs(value));
  799. if (signbit(value))
  800. int_val = -int_val;
  801. auto int8bit = fmod(int_val, NumericLimits<u8>::max() + 1.0);
  802. if (int8bit < 0)
  803. int8bit += NumericLimits<u8>::max() + 1.0;
  804. return static_cast<u8>(int8bit);
  805. }
  806. // 7.1.12 ToUint8Clamp ( argument ), https://tc39.es/ecma262/#sec-touint8clamp
  807. ThrowCompletionOr<u8> Value::to_u8_clamp(VM& vm) const
  808. {
  809. auto number = TRY(to_number(vm));
  810. if (number.is_nan())
  811. return 0;
  812. double value = number.as_double();
  813. if (value <= 0.0)
  814. return 0;
  815. if (value >= 255.0)
  816. return 255;
  817. auto int_val = floor(value);
  818. if (int_val + 0.5 < value)
  819. return static_cast<u8>(int_val + 1.0);
  820. if (value < int_val + 0.5)
  821. return static_cast<u8>(int_val);
  822. if (fmod(int_val, 2.0) == 1.0)
  823. return static_cast<u8>(int_val + 1.0);
  824. return static_cast<u8>(int_val);
  825. }
  826. // 7.1.20 ToLength ( argument ), https://tc39.es/ecma262/#sec-tolength
  827. ThrowCompletionOr<size_t> Value::to_length(VM& vm) const
  828. {
  829. auto len = TRY(to_integer_or_infinity(vm));
  830. if (len <= 0)
  831. return 0;
  832. // FIXME: The spec says that this function's output range is 0 - 2^53-1. But we don't want to overflow the size_t.
  833. constexpr double length_limit = sizeof(void*) == 4 ? NumericLimits<size_t>::max() : MAX_ARRAY_LIKE_INDEX;
  834. return min(len, length_limit);
  835. }
  836. // 7.1.22 ToIndex ( argument ), https://tc39.es/ecma262/#sec-toindex
  837. ThrowCompletionOr<size_t> Value::to_index(VM& vm) const
  838. {
  839. if (is_undefined())
  840. return 0;
  841. auto integer_index = TRY(to_integer_or_infinity(vm));
  842. if (integer_index < 0)
  843. return vm.throw_completion<RangeError>(ErrorType::InvalidIndex);
  844. auto index = MUST(Value(integer_index).to_length(vm));
  845. if (integer_index != index)
  846. return vm.throw_completion<RangeError>(ErrorType::InvalidIndex);
  847. return index;
  848. }
  849. // 7.1.5 ToIntegerOrInfinity ( argument ), https://tc39.es/ecma262/#sec-tointegerorinfinity
  850. ThrowCompletionOr<double> Value::to_integer_or_infinity(VM& vm) const
  851. {
  852. auto number = TRY(to_number(vm));
  853. if (number.is_nan() || number.as_double() == 0)
  854. return 0;
  855. if (number.is_infinity())
  856. return number.as_double();
  857. auto integer = floor(fabs(number.as_double()));
  858. if (number.as_double() < 0 && integer != 0)
  859. integer = -integer;
  860. return integer;
  861. }
  862. // Standalone variant using plain doubles for cases where we already got numbers and know the AO won't throw.
  863. double to_integer_or_infinity(double number)
  864. {
  865. // 1. Let number be ? ToNumber(argument).
  866. // 2. If number is NaN, +0𝔽, or -0𝔽, return 0.
  867. if (isnan(number) || number == 0)
  868. return 0;
  869. // 3. If number is +∞𝔽, return +∞.
  870. if (__builtin_isinf_sign(number) > 0)
  871. return static_cast<double>(INFINITY);
  872. // 4. If number is -∞𝔽, return -∞.
  873. if (__builtin_isinf_sign(number) < 0)
  874. return static_cast<double>(-INFINITY);
  875. // 5. Let integer be floor(abs(ℝ(number))).
  876. auto integer = floor(fabs(number));
  877. // 6. If number < -0𝔽, set integer to -integer.
  878. if (number < 0 && integer != 0)
  879. integer = -integer;
  880. // 7. Return integer.
  881. return integer;
  882. }
  883. // 7.3.3 GetV ( V, P ), https://tc39.es/ecma262/#sec-getv
  884. ThrowCompletionOr<Value> Value::get(VM& vm, PropertyKey const& property_key) const
  885. {
  886. // 1. Assert: IsPropertyKey(P) is true.
  887. VERIFY(property_key.is_valid());
  888. // 2. Let O be ? ToObject(V).
  889. auto* object = TRY(to_object(vm));
  890. // 3. Return ? O.[[Get]](P, V).
  891. return TRY(object->internal_get(property_key, *this));
  892. }
  893. // 7.3.11 GetMethod ( V, P ), https://tc39.es/ecma262/#sec-getmethod
  894. ThrowCompletionOr<FunctionObject*> Value::get_method(VM& vm, PropertyKey const& property_key) const
  895. {
  896. // 1. Assert: IsPropertyKey(P) is true.
  897. VERIFY(property_key.is_valid());
  898. // 2. Let func be ? GetV(V, P).
  899. auto function = TRY(get(vm, property_key));
  900. // 3. If func is either undefined or null, return undefined.
  901. if (function.is_nullish())
  902. return nullptr;
  903. // 4. If IsCallable(func) is false, throw a TypeError exception.
  904. if (!function.is_function())
  905. return vm.throw_completion<TypeError>(ErrorType::NotAFunction, function.to_string_without_side_effects());
  906. // 5. Return func.
  907. return &function.as_function();
  908. }
  909. // 13.10 Relational Operators, https://tc39.es/ecma262/#sec-relational-operators
  910. ThrowCompletionOr<Value> greater_than(VM& vm, Value lhs, Value rhs)
  911. {
  912. if (lhs.is_int32() && rhs.is_int32())
  913. return lhs.as_i32() > rhs.as_i32();
  914. TriState relation = TRY(is_less_than(vm, lhs, rhs, false));
  915. if (relation == TriState::Unknown)
  916. return Value(false);
  917. return Value(relation == TriState::True);
  918. }
  919. // 13.10 Relational Operators, https://tc39.es/ecma262/#sec-relational-operators
  920. ThrowCompletionOr<Value> greater_than_equals(VM& vm, Value lhs, Value rhs)
  921. {
  922. if (lhs.is_int32() && rhs.is_int32())
  923. return lhs.as_i32() >= rhs.as_i32();
  924. TriState relation = TRY(is_less_than(vm, lhs, rhs, true));
  925. if (relation == TriState::Unknown || relation == TriState::True)
  926. return Value(false);
  927. return Value(true);
  928. }
  929. // 13.10 Relational Operators, https://tc39.es/ecma262/#sec-relational-operators
  930. ThrowCompletionOr<Value> less_than(VM& vm, Value lhs, Value rhs)
  931. {
  932. if (lhs.is_int32() && rhs.is_int32())
  933. return lhs.as_i32() < rhs.as_i32();
  934. TriState relation = TRY(is_less_than(vm, lhs, rhs, true));
  935. if (relation == TriState::Unknown)
  936. return Value(false);
  937. return Value(relation == TriState::True);
  938. }
  939. // 13.10 Relational Operators, https://tc39.es/ecma262/#sec-relational-operators
  940. ThrowCompletionOr<Value> less_than_equals(VM& vm, Value lhs, Value rhs)
  941. {
  942. if (lhs.is_int32() && rhs.is_int32())
  943. return lhs.as_i32() <= rhs.as_i32();
  944. TriState relation = TRY(is_less_than(vm, lhs, rhs, false));
  945. if (relation == TriState::Unknown || relation == TriState::True)
  946. return Value(false);
  947. return Value(true);
  948. }
  949. // 13.12 Binary Bitwise Operators, https://tc39.es/ecma262/#sec-binary-bitwise-operators
  950. ThrowCompletionOr<Value> bitwise_and(VM& vm, Value lhs, Value rhs)
  951. {
  952. auto lhs_numeric = TRY(lhs.to_numeric(vm));
  953. auto rhs_numeric = TRY(rhs.to_numeric(vm));
  954. if (both_number(lhs_numeric, rhs_numeric)) {
  955. if (!lhs_numeric.is_finite_number() || !rhs_numeric.is_finite_number())
  956. return Value(0);
  957. return Value(TRY(lhs_numeric.to_i32(vm)) & TRY(rhs_numeric.to_i32(vm)));
  958. }
  959. if (both_bigint(lhs_numeric, rhs_numeric))
  960. return BigInt::create(vm, lhs_numeric.as_bigint().big_integer().bitwise_and(rhs_numeric.as_bigint().big_integer()));
  961. return vm.throw_completion<TypeError>(ErrorType::BigIntBadOperatorOtherType, "bitwise AND");
  962. }
  963. // 13.12 Binary Bitwise Operators, https://tc39.es/ecma262/#sec-binary-bitwise-operators
  964. ThrowCompletionOr<Value> bitwise_or(VM& vm, Value lhs, Value rhs)
  965. {
  966. auto lhs_numeric = TRY(lhs.to_numeric(vm));
  967. auto rhs_numeric = TRY(rhs.to_numeric(vm));
  968. if (both_number(lhs_numeric, rhs_numeric)) {
  969. if (!lhs_numeric.is_finite_number() && !rhs_numeric.is_finite_number())
  970. return Value(0);
  971. if (!lhs_numeric.is_finite_number())
  972. return rhs_numeric;
  973. if (!rhs_numeric.is_finite_number())
  974. return lhs_numeric;
  975. return Value(TRY(lhs_numeric.to_i32(vm)) | TRY(rhs_numeric.to_i32(vm)));
  976. }
  977. if (both_bigint(lhs_numeric, rhs_numeric))
  978. return BigInt::create(vm, lhs_numeric.as_bigint().big_integer().bitwise_or(rhs_numeric.as_bigint().big_integer()));
  979. return vm.throw_completion<TypeError>(ErrorType::BigIntBadOperatorOtherType, "bitwise OR");
  980. }
  981. // 13.12 Binary Bitwise Operators, https://tc39.es/ecma262/#sec-binary-bitwise-operators
  982. ThrowCompletionOr<Value> bitwise_xor(VM& vm, Value lhs, Value rhs)
  983. {
  984. auto lhs_numeric = TRY(lhs.to_numeric(vm));
  985. auto rhs_numeric = TRY(rhs.to_numeric(vm));
  986. if (both_number(lhs_numeric, rhs_numeric)) {
  987. if (!lhs_numeric.is_finite_number() && !rhs_numeric.is_finite_number())
  988. return Value(0);
  989. if (!lhs_numeric.is_finite_number())
  990. return rhs_numeric;
  991. if (!rhs_numeric.is_finite_number())
  992. return lhs_numeric;
  993. return Value(TRY(lhs_numeric.to_i32(vm)) ^ TRY(rhs_numeric.to_i32(vm)));
  994. }
  995. if (both_bigint(lhs_numeric, rhs_numeric))
  996. return BigInt::create(vm, lhs_numeric.as_bigint().big_integer().bitwise_xor(rhs_numeric.as_bigint().big_integer()));
  997. return vm.throw_completion<TypeError>(ErrorType::BigIntBadOperatorOtherType, "bitwise XOR");
  998. }
  999. // 13.5.6 Bitwise NOT Operator ( ~ ), https://tc39.es/ecma262/#sec-bitwise-not-operator
  1000. ThrowCompletionOr<Value> bitwise_not(VM& vm, Value lhs)
  1001. {
  1002. auto lhs_numeric = TRY(lhs.to_numeric(vm));
  1003. if (lhs_numeric.is_number())
  1004. return Value(~TRY(lhs_numeric.to_i32(vm)));
  1005. return BigInt::create(vm, lhs_numeric.as_bigint().big_integer().bitwise_not());
  1006. }
  1007. // 13.5.4 Unary + Operator, https://tc39.es/ecma262/#sec-unary-plus-operator
  1008. ThrowCompletionOr<Value> unary_plus(VM& vm, Value lhs)
  1009. {
  1010. return TRY(lhs.to_number(vm));
  1011. }
  1012. // 13.5.5 Unary - Operator, https://tc39.es/ecma262/#sec-unary-minus-operator
  1013. ThrowCompletionOr<Value> unary_minus(VM& vm, Value lhs)
  1014. {
  1015. auto lhs_numeric = TRY(lhs.to_numeric(vm));
  1016. if (lhs_numeric.is_number()) {
  1017. if (lhs_numeric.is_nan())
  1018. return js_nan();
  1019. return Value(-lhs_numeric.as_double());
  1020. }
  1021. if (lhs_numeric.as_bigint().big_integer() == BIGINT_ZERO)
  1022. return BigInt::create(vm, BIGINT_ZERO);
  1023. auto big_integer_negated = lhs_numeric.as_bigint().big_integer();
  1024. big_integer_negated.negate();
  1025. return BigInt::create(vm, big_integer_negated);
  1026. }
  1027. // 13.9.1 The Left Shift Operator ( << ), https://tc39.es/ecma262/#sec-left-shift-operator
  1028. ThrowCompletionOr<Value> left_shift(VM& vm, Value lhs, Value rhs)
  1029. {
  1030. auto lhs_numeric = TRY(lhs.to_numeric(vm));
  1031. auto rhs_numeric = TRY(rhs.to_numeric(vm));
  1032. if (both_number(lhs_numeric, rhs_numeric)) {
  1033. if (!lhs_numeric.is_finite_number())
  1034. return Value(0);
  1035. if (!rhs_numeric.is_finite_number())
  1036. return lhs_numeric;
  1037. // Ok, so this performs toNumber() again but that "can't" throw
  1038. auto lhs_i32 = MUST(lhs_numeric.to_i32(vm));
  1039. auto rhs_u32 = MUST(rhs_numeric.to_u32(vm)) % 32;
  1040. return Value(lhs_i32 << rhs_u32);
  1041. }
  1042. if (both_bigint(lhs_numeric, rhs_numeric)) {
  1043. // 6.1.6.2.9 BigInt::leftShift ( x, y ), https://tc39.es/ecma262/#sec-numeric-types-bigint-leftShift
  1044. auto multiplier_divisor = Crypto::SignedBigInteger { Crypto::NumberTheory::Power(Crypto::UnsignedBigInteger(2), rhs_numeric.as_bigint().big_integer().unsigned_value()) };
  1045. // 1. If y < 0ℤ, then
  1046. if (rhs_numeric.as_bigint().big_integer().is_negative()) {
  1047. // a. Return the BigInt value that represents ℝ(x) / 2^-y, rounding down to the nearest integer, including for negative numbers.
  1048. // NOTE: Since y is negative we can just do ℝ(x) / 2^|y|
  1049. auto const& big_integer = lhs_numeric.as_bigint().big_integer();
  1050. auto division_result = big_integer.divided_by(multiplier_divisor);
  1051. // For positive initial values and no remainder just return quotient
  1052. if (division_result.remainder.is_zero() || !big_integer.is_negative())
  1053. return BigInt::create(vm, division_result.quotient);
  1054. // For negative round "down" to the next negative number
  1055. return BigInt::create(vm, division_result.quotient.minus(Crypto::SignedBigInteger { 1 }));
  1056. }
  1057. // 2. Return the BigInt value that represents ℝ(x) × 2^y.
  1058. return Value(BigInt::create(vm, lhs_numeric.as_bigint().big_integer().multiplied_by(multiplier_divisor)));
  1059. }
  1060. return vm.throw_completion<TypeError>(ErrorType::BigIntBadOperatorOtherType, "left-shift");
  1061. }
  1062. // 13.9.2 The Signed Right Shift Operator ( >> ), https://tc39.es/ecma262/#sec-signed-right-shift-operator
  1063. ThrowCompletionOr<Value> right_shift(VM& vm, Value lhs, Value rhs)
  1064. {
  1065. auto lhs_numeric = TRY(lhs.to_numeric(vm));
  1066. auto rhs_numeric = TRY(rhs.to_numeric(vm));
  1067. if (both_number(lhs_numeric, rhs_numeric)) {
  1068. if (!lhs_numeric.is_finite_number())
  1069. return Value(0);
  1070. if (!rhs_numeric.is_finite_number())
  1071. return lhs_numeric;
  1072. auto lhs_i32 = MUST(lhs_numeric.to_i32(vm));
  1073. auto rhs_u32 = MUST(rhs_numeric.to_u32(vm)) % 32;
  1074. return Value(lhs_i32 >> rhs_u32);
  1075. }
  1076. if (both_bigint(lhs_numeric, rhs_numeric)) {
  1077. auto rhs_negated = rhs_numeric.as_bigint().big_integer();
  1078. rhs_negated.negate();
  1079. return left_shift(vm, lhs, BigInt::create(vm, rhs_negated));
  1080. }
  1081. return vm.throw_completion<TypeError>(ErrorType::BigIntBadOperatorOtherType, "right-shift");
  1082. }
  1083. // 13.9.3 The Unsigned Right Shift Operator ( >>> ), https://tc39.es/ecma262/#sec-unsigned-right-shift-operator
  1084. ThrowCompletionOr<Value> unsigned_right_shift(VM& vm, Value lhs, Value rhs)
  1085. {
  1086. auto lhs_numeric = TRY(lhs.to_numeric(vm));
  1087. auto rhs_numeric = TRY(rhs.to_numeric(vm));
  1088. if (both_number(lhs_numeric, rhs_numeric)) {
  1089. if (!lhs_numeric.is_finite_number())
  1090. return Value(0);
  1091. if (!rhs_numeric.is_finite_number())
  1092. return lhs_numeric;
  1093. // Ok, so this performs toNumber() again but that "can't" throw
  1094. auto lhs_u32 = MUST(lhs_numeric.to_u32(vm));
  1095. auto rhs_u32 = MUST(rhs_numeric.to_u32(vm)) % 32;
  1096. return Value(lhs_u32 >> rhs_u32);
  1097. }
  1098. return vm.throw_completion<TypeError>(ErrorType::BigIntBadOperator, "unsigned right-shift");
  1099. }
  1100. // 13.8.1 The Addition Operator ( + ), https://tc39.es/ecma262/#sec-addition-operator-plus
  1101. ThrowCompletionOr<Value> add(VM& vm, Value lhs, Value rhs)
  1102. {
  1103. if (both_number(lhs, rhs)) {
  1104. if (lhs.is_int32() && rhs.is_int32()) {
  1105. Checked<i32> result;
  1106. result = MUST(lhs.to_i32(vm));
  1107. result += MUST(rhs.to_i32(vm));
  1108. if (!result.has_overflow())
  1109. return Value(result.value());
  1110. }
  1111. return Value(lhs.as_double() + rhs.as_double());
  1112. }
  1113. auto lhs_primitive = TRY(lhs.to_primitive(vm));
  1114. auto rhs_primitive = TRY(rhs.to_primitive(vm));
  1115. if (lhs_primitive.is_string() || rhs_primitive.is_string()) {
  1116. auto lhs_string = TRY(lhs_primitive.to_primitive_string(vm));
  1117. auto rhs_string = TRY(rhs_primitive.to_primitive_string(vm));
  1118. return PrimitiveString::create(vm, *lhs_string, *rhs_string);
  1119. }
  1120. auto lhs_numeric = TRY(lhs_primitive.to_numeric(vm));
  1121. auto rhs_numeric = TRY(rhs_primitive.to_numeric(vm));
  1122. if (both_number(lhs_numeric, rhs_numeric))
  1123. return Value(lhs_numeric.as_double() + rhs_numeric.as_double());
  1124. if (both_bigint(lhs_numeric, rhs_numeric))
  1125. return BigInt::create(vm, lhs_numeric.as_bigint().big_integer().plus(rhs_numeric.as_bigint().big_integer()));
  1126. return vm.throw_completion<TypeError>(ErrorType::BigIntBadOperatorOtherType, "addition");
  1127. }
  1128. // 13.8.2 The Subtraction Operator ( - ), https://tc39.es/ecma262/#sec-subtraction-operator-minus
  1129. ThrowCompletionOr<Value> sub(VM& vm, Value lhs, Value rhs)
  1130. {
  1131. auto lhs_numeric = TRY(lhs.to_numeric(vm));
  1132. auto rhs_numeric = TRY(rhs.to_numeric(vm));
  1133. if (both_number(lhs_numeric, rhs_numeric)) {
  1134. double lhsd = lhs_numeric.as_double();
  1135. double rhsd = rhs_numeric.as_double();
  1136. double interm = lhsd - rhsd;
  1137. return Value(interm);
  1138. }
  1139. if (both_bigint(lhs_numeric, rhs_numeric))
  1140. return BigInt::create(vm, lhs_numeric.as_bigint().big_integer().minus(rhs_numeric.as_bigint().big_integer()));
  1141. return vm.throw_completion<TypeError>(ErrorType::BigIntBadOperatorOtherType, "subtraction");
  1142. }
  1143. // 13.7 Multiplicative Operators, https://tc39.es/ecma262/#sec-multiplicative-operators
  1144. ThrowCompletionOr<Value> mul(VM& vm, Value lhs, Value rhs)
  1145. {
  1146. auto lhs_numeric = TRY(lhs.to_numeric(vm));
  1147. auto rhs_numeric = TRY(rhs.to_numeric(vm));
  1148. if (both_number(lhs_numeric, rhs_numeric))
  1149. return Value(lhs_numeric.as_double() * rhs_numeric.as_double());
  1150. if (both_bigint(lhs_numeric, rhs_numeric))
  1151. return BigInt::create(vm, lhs_numeric.as_bigint().big_integer().multiplied_by(rhs_numeric.as_bigint().big_integer()));
  1152. return vm.throw_completion<TypeError>(ErrorType::BigIntBadOperatorOtherType, "multiplication");
  1153. }
  1154. // 13.7 Multiplicative Operators, https://tc39.es/ecma262/#sec-multiplicative-operators
  1155. ThrowCompletionOr<Value> div(VM& vm, Value lhs, Value rhs)
  1156. {
  1157. auto lhs_numeric = TRY(lhs.to_numeric(vm));
  1158. auto rhs_numeric = TRY(rhs.to_numeric(vm));
  1159. if (both_number(lhs_numeric, rhs_numeric))
  1160. return Value(lhs_numeric.as_double() / rhs_numeric.as_double());
  1161. if (both_bigint(lhs_numeric, rhs_numeric)) {
  1162. if (rhs_numeric.as_bigint().big_integer() == BIGINT_ZERO)
  1163. return vm.throw_completion<RangeError>(ErrorType::DivisionByZero);
  1164. return BigInt::create(vm, lhs_numeric.as_bigint().big_integer().divided_by(rhs_numeric.as_bigint().big_integer()).quotient);
  1165. }
  1166. return vm.throw_completion<TypeError>(ErrorType::BigIntBadOperatorOtherType, "division");
  1167. }
  1168. // 13.7 Multiplicative Operators, https://tc39.es/ecma262/#sec-multiplicative-operators
  1169. ThrowCompletionOr<Value> mod(VM& vm, Value lhs, Value rhs)
  1170. {
  1171. auto lhs_numeric = TRY(lhs.to_numeric(vm));
  1172. auto rhs_numeric = TRY(rhs.to_numeric(vm));
  1173. if (both_number(lhs_numeric, rhs_numeric)) {
  1174. // 6.1.6.1.6 Number::remainder ( n, d ), https://tc39.es/ecma262/#sec-numeric-types-number-remainder
  1175. // The ECMA specification is describing the mathematical definition of modulus
  1176. // implemented by fmod.
  1177. auto n = lhs_numeric.as_double();
  1178. auto d = rhs_numeric.as_double();
  1179. return Value(fmod(n, d));
  1180. }
  1181. if (both_bigint(lhs_numeric, rhs_numeric)) {
  1182. if (rhs_numeric.as_bigint().big_integer() == BIGINT_ZERO)
  1183. return vm.throw_completion<RangeError>(ErrorType::DivisionByZero);
  1184. return BigInt::create(vm, lhs_numeric.as_bigint().big_integer().divided_by(rhs_numeric.as_bigint().big_integer()).remainder);
  1185. }
  1186. return vm.throw_completion<TypeError>(ErrorType::BigIntBadOperatorOtherType, "modulo");
  1187. }
  1188. static Value exp_double(Value base, Value exponent)
  1189. {
  1190. VERIFY(both_number(base, exponent));
  1191. if (exponent.is_nan())
  1192. return js_nan();
  1193. if (exponent.is_positive_zero() || exponent.is_negative_zero())
  1194. return Value(1);
  1195. if (base.is_nan())
  1196. return js_nan();
  1197. if (base.is_positive_infinity())
  1198. return exponent.as_double() > 0 ? js_infinity() : Value(0);
  1199. if (base.is_negative_infinity()) {
  1200. auto is_odd_integral_number = exponent.is_integral_number() && (static_cast<i32>(exponent.as_double()) % 2 != 0);
  1201. if (exponent.as_double() > 0)
  1202. return is_odd_integral_number ? js_negative_infinity() : js_infinity();
  1203. else
  1204. return is_odd_integral_number ? Value(-0.0) : Value(0);
  1205. }
  1206. if (base.is_positive_zero())
  1207. return exponent.as_double() > 0 ? Value(0) : js_infinity();
  1208. if (base.is_negative_zero()) {
  1209. auto is_odd_integral_number = exponent.is_integral_number() && (static_cast<i32>(exponent.as_double()) % 2 != 0);
  1210. if (exponent.as_double() > 0)
  1211. return is_odd_integral_number ? Value(-0.0) : Value(0);
  1212. else
  1213. return is_odd_integral_number ? js_negative_infinity() : js_infinity();
  1214. }
  1215. VERIFY(base.is_finite_number() && !base.is_positive_zero() && !base.is_negative_zero());
  1216. if (exponent.is_positive_infinity()) {
  1217. auto absolute_base = fabs(base.as_double());
  1218. if (absolute_base > 1)
  1219. return js_infinity();
  1220. else if (absolute_base == 1)
  1221. return js_nan();
  1222. else if (absolute_base < 1)
  1223. return Value(0);
  1224. }
  1225. if (exponent.is_negative_infinity()) {
  1226. auto absolute_base = fabs(base.as_double());
  1227. if (absolute_base > 1)
  1228. return Value(0);
  1229. else if (absolute_base == 1)
  1230. return js_nan();
  1231. else if (absolute_base < 1)
  1232. return js_infinity();
  1233. }
  1234. VERIFY(exponent.is_finite_number() && !exponent.is_positive_zero() && !exponent.is_negative_zero());
  1235. if (base.as_double() < 0 && !exponent.is_integral_number())
  1236. return js_nan();
  1237. return Value(::pow(base.as_double(), exponent.as_double()));
  1238. }
  1239. // 13.6 Exponentiation Operator, https://tc39.es/ecma262/#sec-exp-operator
  1240. ThrowCompletionOr<Value> exp(VM& vm, Value lhs, Value rhs)
  1241. {
  1242. auto lhs_numeric = TRY(lhs.to_numeric(vm));
  1243. auto rhs_numeric = TRY(rhs.to_numeric(vm));
  1244. if (both_number(lhs_numeric, rhs_numeric))
  1245. return exp_double(lhs_numeric, rhs_numeric);
  1246. if (both_bigint(lhs_numeric, rhs_numeric)) {
  1247. if (rhs_numeric.as_bigint().big_integer().is_negative())
  1248. return vm.throw_completion<RangeError>(ErrorType::NegativeExponent);
  1249. return BigInt::create(vm, Crypto::NumberTheory::Power(lhs_numeric.as_bigint().big_integer(), rhs_numeric.as_bigint().big_integer()));
  1250. }
  1251. return vm.throw_completion<TypeError>(ErrorType::BigIntBadOperatorOtherType, "exponentiation");
  1252. }
  1253. ThrowCompletionOr<Value> in(VM& vm, Value lhs, Value rhs)
  1254. {
  1255. if (!rhs.is_object())
  1256. return vm.throw_completion<TypeError>(ErrorType::InOperatorWithObject);
  1257. auto lhs_property_key = TRY(lhs.to_property_key(vm));
  1258. return Value(TRY(rhs.as_object().has_property(lhs_property_key)));
  1259. }
  1260. // 13.10.2 InstanceofOperator ( V, target ), https://tc39.es/ecma262/#sec-instanceofoperator
  1261. ThrowCompletionOr<Value> instance_of(VM& vm, Value lhs, Value rhs)
  1262. {
  1263. if (!rhs.is_object())
  1264. return vm.throw_completion<TypeError>(ErrorType::NotAnObject, rhs.to_string_without_side_effects());
  1265. auto has_instance_method = TRY(rhs.get_method(vm, *vm.well_known_symbol_has_instance()));
  1266. if (has_instance_method) {
  1267. auto has_instance_result = TRY(call(vm, *has_instance_method, rhs, lhs));
  1268. return Value(has_instance_result.to_boolean());
  1269. }
  1270. if (!rhs.is_function())
  1271. return vm.throw_completion<TypeError>(ErrorType::NotAFunction, rhs.to_string_without_side_effects());
  1272. return TRY(ordinary_has_instance(vm, lhs, rhs));
  1273. }
  1274. // 7.3.22 OrdinaryHasInstance ( C, O ), https://tc39.es/ecma262/#sec-ordinaryhasinstance
  1275. ThrowCompletionOr<Value> ordinary_has_instance(VM& vm, Value lhs, Value rhs)
  1276. {
  1277. if (!rhs.is_function())
  1278. return Value(false);
  1279. auto& rhs_function = rhs.as_function();
  1280. if (is<BoundFunction>(rhs_function)) {
  1281. auto& bound_target = static_cast<BoundFunction const&>(rhs_function);
  1282. return instance_of(vm, lhs, Value(&bound_target.bound_target_function()));
  1283. }
  1284. if (!lhs.is_object())
  1285. return Value(false);
  1286. Object* lhs_object = &lhs.as_object();
  1287. auto rhs_prototype = TRY(rhs_function.get(vm.names.prototype));
  1288. if (!rhs_prototype.is_object())
  1289. return vm.throw_completion<TypeError>(ErrorType::InstanceOfOperatorBadPrototype, rhs.to_string_without_side_effects());
  1290. while (true) {
  1291. lhs_object = TRY(lhs_object->internal_get_prototype_of());
  1292. if (!lhs_object)
  1293. return Value(false);
  1294. if (same_value(rhs_prototype, lhs_object))
  1295. return Value(true);
  1296. }
  1297. }
  1298. // 7.2.10 SameValue ( x, y ), https://tc39.es/ecma262/#sec-samevalue
  1299. bool same_value(Value lhs, Value rhs)
  1300. {
  1301. if (!same_type_for_equality(lhs, rhs))
  1302. return false;
  1303. if (lhs.is_number()) {
  1304. if (lhs.is_nan() && rhs.is_nan())
  1305. return true;
  1306. if (lhs.is_positive_zero() && rhs.is_negative_zero())
  1307. return false;
  1308. if (lhs.is_negative_zero() && rhs.is_positive_zero())
  1309. return false;
  1310. return lhs.as_double() == rhs.as_double();
  1311. }
  1312. if (lhs.is_bigint()) {
  1313. auto lhs_big_integer = lhs.as_bigint().big_integer();
  1314. auto rhs_big_integer = rhs.as_bigint().big_integer();
  1315. if (lhs_big_integer == BIGINT_ZERO && rhs_big_integer == BIGINT_ZERO && lhs_big_integer.is_negative() != rhs_big_integer.is_negative())
  1316. return false;
  1317. return lhs_big_integer == rhs_big_integer;
  1318. }
  1319. return same_value_non_numeric(lhs, rhs);
  1320. }
  1321. // 7.2.11 SameValueZero ( x, y ), https://tc39.es/ecma262/#sec-samevaluezero
  1322. bool same_value_zero(Value lhs, Value rhs)
  1323. {
  1324. if (!same_type_for_equality(lhs, rhs))
  1325. return false;
  1326. if (lhs.is_number()) {
  1327. if (lhs.is_nan() && rhs.is_nan())
  1328. return true;
  1329. return lhs.as_double() == rhs.as_double();
  1330. }
  1331. if (lhs.is_bigint())
  1332. return lhs.as_bigint().big_integer() == rhs.as_bigint().big_integer();
  1333. return same_value_non_numeric(lhs, rhs);
  1334. }
  1335. // 7.2.12 SameValueNonNumeric ( x, y ), https://tc39.es/ecma262/#sec-samevaluenonnumeric
  1336. bool same_value_non_numeric(Value lhs, Value rhs)
  1337. {
  1338. VERIFY(!lhs.is_number() && !lhs.is_bigint());
  1339. VERIFY(same_type_for_equality(lhs, rhs));
  1340. if (lhs.is_string())
  1341. return lhs.as_string().deprecated_string() == rhs.as_string().deprecated_string();
  1342. return lhs.m_value.encoded == rhs.m_value.encoded;
  1343. }
  1344. // 7.2.15 IsStrictlyEqual ( x, y ), https://tc39.es/ecma262/#sec-isstrictlyequal
  1345. bool is_strictly_equal(Value lhs, Value rhs)
  1346. {
  1347. if (!same_type_for_equality(lhs, rhs))
  1348. return false;
  1349. if (lhs.is_number()) {
  1350. if (lhs.is_nan() || rhs.is_nan())
  1351. return false;
  1352. if (lhs.as_double() == rhs.as_double())
  1353. return true;
  1354. return false;
  1355. }
  1356. if (lhs.is_bigint())
  1357. return lhs.as_bigint().big_integer() == rhs.as_bigint().big_integer();
  1358. return same_value_non_numeric(lhs, rhs);
  1359. }
  1360. // 7.2.14 IsLooselyEqual ( x, y ), https://tc39.es/ecma262/#sec-islooselyequal
  1361. ThrowCompletionOr<bool> is_loosely_equal(VM& vm, Value lhs, Value rhs)
  1362. {
  1363. // 1. If Type(x) is the same as Type(y), then
  1364. if (same_type_for_equality(lhs, rhs)) {
  1365. // a. Return IsStrictlyEqual(x, y).
  1366. return is_strictly_equal(lhs, rhs);
  1367. }
  1368. // 2. If x is null and y is undefined, return true.
  1369. // 3. If x is undefined and y is null, return true.
  1370. if (lhs.is_nullish() && rhs.is_nullish())
  1371. return true;
  1372. // 4. NOTE: This step is replaced in section B.3.6.2.
  1373. // B.3.6.2 Changes to IsLooselyEqual, https://tc39.es/ecma262/#sec-IsHTMLDDA-internal-slot-aec
  1374. // 4. Perform the following steps:
  1375. // a. If Type(x) is Object and x has an [[IsHTMLDDA]] internal slot and y is either null or undefined, return true.
  1376. if (lhs.is_object() && lhs.as_object().is_htmldda() && rhs.is_nullish())
  1377. return true;
  1378. // b. If x is either null or undefined and Type(y) is Object and y has an [[IsHTMLDDA]] internal slot, return true.
  1379. if (lhs.is_nullish() && rhs.is_object() && rhs.as_object().is_htmldda())
  1380. return true;
  1381. // == End of B.3.6.2 ==
  1382. // 5. If Type(x) is Number and Type(y) is String, return ! IsLooselyEqual(x, ! ToNumber(y)).
  1383. if (lhs.is_number() && rhs.is_string())
  1384. return is_loosely_equal(vm, lhs, MUST(rhs.to_number(vm)));
  1385. // 6. If Type(x) is String and Type(y) is Number, return ! IsLooselyEqual(! ToNumber(x), y).
  1386. if (lhs.is_string() && rhs.is_number())
  1387. return is_loosely_equal(vm, MUST(lhs.to_number(vm)), rhs);
  1388. // 7. If Type(x) is BigInt and Type(y) is String, then
  1389. if (lhs.is_bigint() && rhs.is_string()) {
  1390. // a. Let n be StringToBigInt(y).
  1391. auto bigint = string_to_bigint(vm, rhs.as_string().deprecated_string());
  1392. // b. If n is undefined, return false.
  1393. if (!bigint.has_value())
  1394. return false;
  1395. // c. Return ! IsLooselyEqual(x, n).
  1396. return is_loosely_equal(vm, lhs, *bigint);
  1397. }
  1398. // 8. If Type(x) is String and Type(y) is BigInt, return ! IsLooselyEqual(y, x).
  1399. if (lhs.is_string() && rhs.is_bigint())
  1400. return is_loosely_equal(vm, rhs, lhs);
  1401. // 9. If Type(x) is Boolean, return ! IsLooselyEqual(! ToNumber(x), y).
  1402. if (lhs.is_boolean())
  1403. return is_loosely_equal(vm, MUST(lhs.to_number(vm)), rhs);
  1404. // 10. If Type(y) is Boolean, return ! IsLooselyEqual(x, ! ToNumber(y)).
  1405. if (rhs.is_boolean())
  1406. return is_loosely_equal(vm, lhs, MUST(rhs.to_number(vm)));
  1407. // 11. If Type(x) is either String, Number, BigInt, or Symbol and Type(y) is Object, return ! IsLooselyEqual(x, ? ToPrimitive(y)).
  1408. if ((lhs.is_string() || lhs.is_number() || lhs.is_bigint() || lhs.is_symbol()) && rhs.is_object()) {
  1409. auto rhs_primitive = TRY(rhs.to_primitive(vm));
  1410. return is_loosely_equal(vm, lhs, rhs_primitive);
  1411. }
  1412. // 12. If Type(x) is Object and Type(y) is either String, Number, BigInt, or Symbol, return ! IsLooselyEqual(? ToPrimitive(x), y).
  1413. if (lhs.is_object() && (rhs.is_string() || rhs.is_number() || rhs.is_bigint() || rhs.is_symbol())) {
  1414. auto lhs_primitive = TRY(lhs.to_primitive(vm));
  1415. return is_loosely_equal(vm, lhs_primitive, rhs);
  1416. }
  1417. // 13. If Type(x) is BigInt and Type(y) is Number, or if Type(x) is Number and Type(y) is BigInt, then
  1418. if ((lhs.is_bigint() && rhs.is_number()) || (lhs.is_number() && rhs.is_bigint())) {
  1419. // a. If x or y are any of NaN, +∞𝔽, or -∞𝔽, return false.
  1420. if (lhs.is_nan() || lhs.is_infinity() || rhs.is_nan() || rhs.is_infinity())
  1421. return false;
  1422. // b. If ℝ(x) = ℝ(y), return true; otherwise return false.
  1423. if ((lhs.is_number() && !lhs.is_integral_number()) || (rhs.is_number() && !rhs.is_integral_number()))
  1424. return false;
  1425. VERIFY(!lhs.is_nan() && !rhs.is_nan());
  1426. auto& number_side = lhs.is_number() ? lhs : rhs;
  1427. auto& bigint_side = lhs.is_number() ? rhs : lhs;
  1428. return bigint_side.as_bigint().big_integer().compare_to_double(number_side.as_double()) == Crypto::UnsignedBigInteger::CompareResult::DoubleEqualsBigInt;
  1429. }
  1430. // 14. Return false.
  1431. return false;
  1432. }
  1433. // 7.2.13 IsLessThan ( x, y, LeftFirst ), https://tc39.es/ecma262/#sec-islessthan
  1434. ThrowCompletionOr<TriState> is_less_than(VM& vm, Value lhs, Value rhs, bool left_first)
  1435. {
  1436. Value x_primitive;
  1437. Value y_primitive;
  1438. if (left_first) {
  1439. x_primitive = TRY(lhs.to_primitive(vm, Value::PreferredType::Number));
  1440. y_primitive = TRY(rhs.to_primitive(vm, Value::PreferredType::Number));
  1441. } else {
  1442. y_primitive = TRY(lhs.to_primitive(vm, Value::PreferredType::Number));
  1443. x_primitive = TRY(rhs.to_primitive(vm, Value::PreferredType::Number));
  1444. }
  1445. if (x_primitive.is_string() && y_primitive.is_string()) {
  1446. auto x_string = x_primitive.as_string().deprecated_string();
  1447. auto y_string = y_primitive.as_string().deprecated_string();
  1448. Utf8View x_code_points { x_string };
  1449. Utf8View y_code_points { y_string };
  1450. for (auto k = x_code_points.begin(), l = y_code_points.begin();
  1451. k != x_code_points.end() && l != y_code_points.end();
  1452. ++k, ++l) {
  1453. if (*k != *l) {
  1454. if (*k < *l) {
  1455. return TriState::True;
  1456. } else {
  1457. return TriState::False;
  1458. }
  1459. }
  1460. }
  1461. return x_code_points.length() < y_code_points.length()
  1462. ? TriState::True
  1463. : TriState::False;
  1464. }
  1465. if (x_primitive.is_bigint() && y_primitive.is_string()) {
  1466. auto y_bigint = string_to_bigint(vm, y_primitive.as_string().deprecated_string());
  1467. if (!y_bigint.has_value())
  1468. return TriState::Unknown;
  1469. if (x_primitive.as_bigint().big_integer() < (*y_bigint)->big_integer())
  1470. return TriState::True;
  1471. return TriState::False;
  1472. }
  1473. if (x_primitive.is_string() && y_primitive.is_bigint()) {
  1474. auto x_bigint = string_to_bigint(vm, x_primitive.as_string().deprecated_string());
  1475. if (!x_bigint.has_value())
  1476. return TriState::Unknown;
  1477. if ((*x_bigint)->big_integer() < y_primitive.as_bigint().big_integer())
  1478. return TriState::True;
  1479. return TriState::False;
  1480. }
  1481. auto x_numeric = TRY(x_primitive.to_numeric(vm));
  1482. auto y_numeric = TRY(y_primitive.to_numeric(vm));
  1483. if (x_numeric.is_nan() || y_numeric.is_nan())
  1484. return TriState::Unknown;
  1485. if (x_numeric.is_positive_infinity() || y_numeric.is_negative_infinity())
  1486. return TriState::False;
  1487. if (x_numeric.is_negative_infinity() || y_numeric.is_positive_infinity())
  1488. return TriState::True;
  1489. if (x_numeric.is_number() && y_numeric.is_number()) {
  1490. if (x_numeric.as_double() < y_numeric.as_double())
  1491. return TriState::True;
  1492. else
  1493. return TriState::False;
  1494. }
  1495. if (x_numeric.is_bigint() && y_numeric.is_bigint()) {
  1496. if (x_numeric.as_bigint().big_integer() < y_numeric.as_bigint().big_integer())
  1497. return TriState::True;
  1498. else
  1499. return TriState::False;
  1500. }
  1501. VERIFY((x_numeric.is_number() && y_numeric.is_bigint()) || (x_numeric.is_bigint() && y_numeric.is_number()));
  1502. bool x_lower_than_y;
  1503. VERIFY(!x_numeric.is_nan() && !y_numeric.is_nan());
  1504. if (x_numeric.is_number()) {
  1505. x_lower_than_y = y_numeric.as_bigint().big_integer().compare_to_double(x_numeric.as_double())
  1506. == Crypto::UnsignedBigInteger::CompareResult::DoubleLessThanBigInt;
  1507. } else {
  1508. x_lower_than_y = x_numeric.as_bigint().big_integer().compare_to_double(y_numeric.as_double())
  1509. == Crypto::UnsignedBigInteger::CompareResult::DoubleGreaterThanBigInt;
  1510. }
  1511. if (x_lower_than_y)
  1512. return TriState::True;
  1513. else
  1514. return TriState::False;
  1515. }
  1516. // 7.3.21 Invoke ( V, P [ , argumentsList ] ), https://tc39.es/ecma262/#sec-invoke
  1517. ThrowCompletionOr<Value> Value::invoke_internal(VM& vm, PropertyKey const& property_key, Optional<MarkedVector<Value>> arguments)
  1518. {
  1519. auto property = TRY(get(vm, property_key));
  1520. if (!property.is_function())
  1521. return vm.throw_completion<TypeError>(ErrorType::NotAFunction, property.to_string_without_side_effects());
  1522. return call(vm, property.as_function(), *this, move(arguments));
  1523. }
  1524. }