Stowage/ladybird
2
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2025-10-31 21:30:58 +00:00
Code Issues Projects Releases Packages Wiki Activity
ladybird/Userland/Libraries/LibJS/Runtime/CommonPropertyNames.h

562 lines
25 KiB
C
Raw Normal View History

LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 23:49:19 +02:00
/*
* Copyright (c) 2020, Andreas Kling <kling@serenityos.org>
*
Everything: Move to SPDX license identifiers in all files. SPDX License Identifiers are a more compact / standardized way of representing file license information. See: https://spdx.dev/resources/use/#identifiers This was done with the `ambr` search and replace tool. ambr --no-parent-ignore --key-from-file --rep-from-file key.txt rep.txt *
2021-04-22 01:24:48 -07:00
* SPDX-License-Identifier: BSD-2-Clause
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 23:49:19 +02:00
*/
#pragma once
#include <AK/FlyString.h>
#include <LibJS/Forward.h>
LibJS: Rename PropertyName to PropertyKey Let's use the same name as the spec. :^)
2021-10-24 16:01:24 +02:00
#include <LibJS/Runtime/PropertyKey.h>
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 23:49:19 +02:00
namespace JS {
#define ENUMERATE_STANDARD_PROPERTY_NAMES(P) \
LibJS: Add the Object.prototype.__proto__ native accessor property This is part of the Annex B extension of the specification.
2021-06-17 14:12:38 +03:00
P(__proto__) \
LibJS: Add the Object.prototype.__define{Getter, Setter}__ methods These are a part of the Annex B extension of the specification.
2021-06-17 14:14:09 +03:00
P(__defineGetter__) \
P(__defineSetter__) \
LibJS: Add the Object.prototype.__lookup{Getter, Setter}__ methods These are a part of the Annex B extension of the specification.
2021-06-17 14:15:14 +03:00
P(__lookupGetter__) \
P(__lookupSetter__) \
LibJS: Begin implementing Atomics This adds the Atomics object to the global object and sets up only its @@toStringTag property.
2021-07-10 22:53:54 -04:00
P(Atomics) \
LibJS: Add TypedArray.BYTES_PER_ELEMENT
2020-12-02 09:58:48 +00:00
P(BYTES_PER_ELEMENT) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 23:49:19 +02:00
P(BigInt) \
P(Boolean) \
P(E) \
P(EPSILON) \
LibJS: Rename Function => FunctionObject
2021-06-27 21:48:34 +02:00
P(Function) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 23:49:19 +02:00
P(Infinity) \
LibJS: Add the Intl namespace object :^) This is the start of implementing ECMA-402 in LibJS, better known as the ECMAScript Internationalization API. Much like Temporal this gets its own subdirectory (Runtime/Intl/) as well as a new C++ namespace (JS::Intl) so we don't have to prefix all the files and classes with "Intl". https://tc39.es/ecma402/
2021-08-08 18:27:28 +01:00
P(Intl) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 23:49:19 +02:00
P(JSON) \
P(LN10) \
P(LN2) \
P(LOG10E) \
P(LOG2E) \
P(MAX_SAFE_INTEGER) \
LibJS: Add the Number.{MAX, MIN}_VALUE constants
2021-06-05 00:56:43 +03:00
P(MAX_VALUE) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 23:49:19 +02:00
P(MIN_SAFE_INTEGER) \
LibJS: Add the Number.{MAX, MIN}_VALUE constants
2021-06-05 00:56:43 +03:00
P(MIN_VALUE) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 23:49:19 +02:00
P(Math) \
P(NEGATIVE_INFINITY) \
P(NaN) \
LibJS: Rename Temporal.now => Temporal.Now See: - https://github.com/tc39/proposal-temporal/commit/d0acb66 - https://github.com/tc39/proposal-temporal/commit/0097fdd
2021-07-19 00:25:22 +01:00
P(Now) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 23:49:19 +02:00
P(Number) \
P(PI) \
P(POSITIVE_INFINITY) \
P(Proxy) \
P(Reflect) \
P(RegExp) \
P(SQRT1_2) \
P(SQRT2) \
P(String) \
P(Symbol) \
LibJS: Add the Temporal namespace object :^) Currently empty, but we gotta start somewhere! This is the start of implementing the Temporal proposal (currently stage 3). I have decided to start a new subdirectory (Runtime/Temporal/) as well as a new C++ namespace (JS::Temporal) for this so we don't have to prefix all the files and classes with "Temporal" - there will be a lot. https://tc39.es/proposal-temporal/
2021-07-06 19:14:47 +01:00
P(Temporal) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 23:49:19 +02:00
P(UTC) \
P(abs) \
LibJS: Add Math.acos() and Math.asin()
2020-12-08 16:22:07 +01:00
P(acos) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 23:49:19 +02:00
P(acosh) \
LibJS: Add most of the Set.prototype methods Specifically all aside from "values" and "entries" which require an implementation of the SetIterator object.
2021-06-09 00:14:08 +03:00
P(add) \
LibJS: Add initial support for Promises Almost a year after first working on this, it's finally done: an implementation of Promises for LibJS! :^) The core functionality is working and closely following the spec [1]. I mostly took the pseudo code and transformed it into C++ - if you read and understand it, you will know how the spec implements Promises; and if you read the spec first, the code will look very familiar. Implemented functions are: - Promise() constructor - Promise.prototype.then() - Promise.prototype.catch() - Promise.prototype.finally() - Promise.resolve() - Promise.reject() For the tests I added a new function to test-js's global object, runQueuedPromiseJobs(), which calls vm.run_queued_promise_jobs(). By design, queued jobs normally only run after the script was fully executed, making it improssible to test handlers in individual test() calls by default [2]. Subsequent commits include integrations into LibWeb and js(1) - pretty-printing, running queued promise jobs when necessary. This has an unusual amount of dbgln() statements, all hidden behind the PROMISE_DEBUG flag - I'm leaving them in for now as they've been very useful while debugging this, things can get quite complex with so many asynchronously executed functions. I've not extensively explored use of these APIs for promise-based functionality in LibWeb (fetch(), Notification.requestPermission() etc.), but we'll get there in due time. [1]: https://tc39.es/ecma262/#sec-promise-objects [2]: https://tc39.es/ecma262/#sec-jobs-and-job-queues
2021-04-01 22:13:29 +02:00
P(all) \
P(allSettled) \
LibJS: Add String.prototype.anchor & friends Adds an implementation of the following StringPrototype methods: anchor, big, blink, bold, fixed, fontcolor, fontsize, italics, link, small, strike, sub, sup.
2021-05-30 01:44:18 +03:00
P(anchor) \
LibJS: Add initial support for Promises Almost a year after first working on this, it's finally done: an implementation of Promises for LibJS! :^) The core functionality is working and closely following the spec [1]. I mostly took the pseudo code and transformed it into C++ - if you read and understand it, you will know how the spec implements Promises; and if you read the spec first, the code will look very familiar. Implemented functions are: - Promise() constructor - Promise.prototype.then() - Promise.prototype.catch() - Promise.prototype.finally() - Promise.resolve() - Promise.reject() For the tests I added a new function to test-js's global object, runQueuedPromiseJobs(), which calls vm.run_queued_promise_jobs(). By design, queued jobs normally only run after the script was fully executed, making it improssible to test handlers in individual test() calls by default [2]. Subsequent commits include integrations into LibWeb and js(1) - pretty-printing, running queued promise jobs when necessary. This has an unusual amount of dbgln() statements, all hidden behind the PROMISE_DEBUG flag - I'm leaving them in for now as they've been very useful while debugging this, things can get quite complex with so many asynchronously executed functions. I've not extensively explored use of these APIs for promise-based functionality in LibWeb (fetch(), Notification.requestPermission() etc.), but we'll get there in due time. [1]: https://tc39.es/ecma262/#sec-promise-objects [2]: https://tc39.es/ecma262/#sec-jobs-and-job-queues
2021-04-01 22:13:29 +02:00
P(any) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 23:49:19 +02:00
P(apply) \
LibJS: Implement a very hackish "arguments" object We now lazily create an "arguments" array inside functions when code tries to access it. This doesn't follow the spec at all but still covers a lot of the basic uses of arguments, i.e "arguments.length" and "arguments[n]"
2020-12-05 16:38:29 +01:00
P(arguments) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 23:49:19 +02:00
P(asIntN) \
P(asUintN) \
LibJS: Add Math.acos() and Math.asin()
2020-12-08 16:22:07 +01:00
P(asin) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 23:49:19 +02:00
P(asinh) \
LibJS: Implement console.assert()
2021-04-18 17:08:14 +02:00
P(assert) \
LibJS: Implement Object.assign()
2021-06-12 11:35:53 +01:00
P(assign) \
LibJS: Implement 'Relative Indexing Method' proposal (.at()) Still stage 3, but already implemented in major engines and unlikely to change - there isn't much to change here anyway. :^) See: - https://github.com/tc39/proposal-relative-indexing-method - https://tc39.es/proposal-relative-indexing-method/ - https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/at
2021-03-12 18:13:12 +01:00
P(at) \
LibJS: Add Math.atan()
2020-12-08 09:52:33 +01:00
P(atan) \
LibJS: Add almost all Math functions
2020-12-28 17:34:51 +03:00
P(atan2) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 23:49:19 +02:00
P(atanh) \
LibJS: Implement Intl.Locale.prototype.baseName
2021-09-01 22:39:40 -04:00
P(baseName) \
LibJS: Add String.prototype.anchor & friends Adds an implementation of the following StringPrototype methods: anchor, big, blink, bold, fixed, fontcolor, fontsize, italics, link, small, strike, sub, sup.
2021-05-30 01:44:18 +03:00
P(big) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 23:49:19 +02:00
P(bind) \
LibJS: Implement Temporal.Duration.prototype.blank
2021-07-16 00:15:56 +01:00
P(blank) \
LibJS: Add String.prototype.anchor & friends Adds an implementation of the following StringPrototype methods: anchor, big, blink, bold, fixed, fontcolor, fontsize, italics, link, small, strike, sub, sup.
2021-05-30 01:44:18 +03:00
P(blink) \
P(bold) \
LibJS: Expose TypedArray.prototype.buffer
2021-05-21 21:26:18 +01:00
P(buffer) \
LibJS: Add ArrayBuffer
2020-12-02 20:49:31 +00:00
P(byteLength) \
LibJS: Expose TypedArray.prototype.byteOffset
2021-05-21 21:45:47 +01:00
P(byteOffset) \
LibJS: Start implementing Temporal.PlainDate This commit adds the PlainDate object itself, its constructor and prototype (currently empty), and several required abstract operations.
2021-07-19 00:29:26 +03:00
P(calendar) \
LibJS: Implement Temporal.PlainDate.prototype.toString()
2021-08-18 21:15:04 +01:00
P(calendarName) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 23:49:19 +02:00
P(call) \
LibJS: Add arguments.callee to our hack arguments object arguments.callee refers to the currently executing function.
2021-03-14 16:41:00 +01:00
P(callee) \
LibJS: Add and use the %ThrowTypeError% intrinsic
2021-06-28 03:53:35 +03:00
P(caller) \
LibJS: Implement the Intl.Locale constructor
2021-09-01 22:08:15 -04:00
P(caseFirst) \
LibJS: Implement the Error Cause proposal Currently stage 3. https://github.com/tc39/proposal-error-cause
2021-06-11 20:40:08 +01:00
P(cause) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 23:49:19 +02:00
P(cbrt) \
P(ceil) \
P(charAt) \
P(charCodeAt) \
LibJS: Add all of the FinalizationRegistry.prototype methods More specifically: cleanupSome, register & unregister. FinalizationRegistery.prototype.cleanupSome is actually still a stage 2 proposal, but since test262 test cases already exist for it, i decided to go for it :)
2021-06-15 22:21:24 +03:00
P(cleanupSome) \
LibJS: Add some more items to CommonPropertyNames that I missed
2020-10-14 00:03:58 +02:00
P(clear) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 23:49:19 +02:00
P(clz32) \
LibJS: Add the String.prototype.codePointAt() method This commit also brings charAt & charCodeAt closer to the specification
2021-06-16 17:30:41 +03:00
P(codePointAt) \
LibJS: Implement the Intl.Locale constructor
2021-09-01 22:08:15 -04:00
P(collation) \
LibJS: Implement the Intl.NumberFormat constructor
2021-09-10 11:04:54 -04:00
P(compactDisplay) \
LibJS: Implement Atomics.compareExchange
2021-07-12 08:59:34 -04:00
P(compareExchange) \
LibJS: Implement RegExp.prototype.compile This is an Annex B extension to RegExp.prototype.
2021-08-20 10:41:27 -04:00
P(compile) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 23:49:19 +02:00
P(concat) \
LibJS: Add some more items to CommonPropertyNames that I missed
2020-10-14 00:03:58 +02:00
P(configurable) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 23:49:19 +02:00
P(console) \
P(construct) \
P(constructor) \
LibJS: Implement Intl %SegmentsPrototype%.containing
2022-01-30 21:12:42 +02:00
P(containing) \
LibJS: Add Temporal.Instant.compare()
2021-07-11 21:18:48 +03:00
P(compare) \
LibJS: Implement Array.prototype.copyWithin generically
2021-06-13 18:09:34 +02:00
P(copyWithin) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 23:49:19 +02:00
P(cos) \
LibJS: Add almost all Math functions
2020-12-28 17:34:51 +03:00
P(cosh) \
LibJS: Add some more items to CommonPropertyNames that I missed
2020-10-14 00:03:58 +02:00
P(count) \
P(countReset) \
LibJS: Implement Object.create()
2021-04-10 18:40:12 +02:00
P(create) \
LibJS: Implement the Intl.NumberFormat constructor
2021-09-10 11:04:54 -04:00
P(currency) \
P(currencyDisplay) \
P(currencySign) \
LibJS: Implement Temporal.Calendar.prototype.dateAdd()
2021-08-30 20:44:05 +01:00
P(dateAdd) \
LibJS: Add Temporal.Calendar.prototype.dateFromFields & required AOs This is required for implementing the DateFromFields PlainDate AO.
2021-07-21 22:17:40 +03:00
P(dateFromFields) \
LibJS+LibUnicode: Implement the Intl.DateTimeFormat constructor
2021-11-28 17:55:47 -05:00
P(dateStyle) \
LibJS: Implement Temporal.Calendar.prototype.dateUntil()
2021-10-10 22:46:10 +01:00
P(dateUntil) \
LibJS: Add Temporal.Calendar.prototype.dateFromFields & required AOs This is required for implementing the DateFromFields PlainDate AO.
2021-07-21 22:17:40 +03:00
P(day) \
LibJS: Implement Temporal.Calendar.prototype.dayOfWeek
2021-07-23 17:46:20 +03:00
P(dayOfWeek) \
LibJS: Implement Temporal.Calendar.prototype.dayOfYear
2021-07-23 17:58:44 +03:00
P(dayOfYear) \
LibJS+LibUnicode: Implement the Intl.DateTimeFormat constructor
2021-11-28 17:55:47 -05:00
P(dayPeriod) \
LibJS: Implement Temporal.Duration.prototype.days
2021-07-15 23:47:04 +01:00
P(days) \
LibJS: Implement Temporal.Calendar.prototype.daysInMonth
2021-07-23 18:36:34 +03:00
P(daysInMonth) \
LibJS: Implement Temporal.Calendar.prototype.daysInWeek
2021-07-23 18:27:47 +03:00
P(daysInWeek) \
LibJS: Implement Temporal.Calendar.prototype.daysInYear
2021-07-23 18:46:49 +03:00
P(daysInYear) \
LibJS: Add some more items to CommonPropertyNames that I missed
2020-10-14 00:03:58 +02:00
P(debug) \
LibJS: Implement the encode/decodeURI(Component) family of functions These are generally useful and in particular needed for twitter.com
2021-04-13 22:50:29 +03:00
P(decodeURI) \
P(decodeURIComponent) \
LibJS: Implement Object.defineProperties()
2021-04-10 18:39:11 +02:00
P(defineProperties) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 23:49:19 +02:00
P(defineProperty) \
P(deleteProperty) \
LibJS: Add the WeakRef built-in object
2021-06-12 17:38:34 +03:00
P(deref) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 23:49:19 +02:00
P(description) \
LibJS: Implement Temporal.TimeZone.prototype.getInstantFor()
2021-11-01 14:20:06 +01:00
P(disambiguation) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 23:49:19 +02:00
P(done) \
LibJS: Hook up Regex<ECMA262> to RegExpObject and implement `test()' This makes RegExpObject compile and store a Regex<ECMA262>, adds all flag-related properties, and implements `RegExpPrototype.test()` (complete with 'lastIndex' support) :^) It should be noted that this only implements `test()' using the builtin `exec()'.
2020-11-19 01:50:00 +03:30
P(dotAll) \
LibJS: Implement the encode/decodeURI(Component) family of functions These are generally useful and in particular needed for twitter.com
2021-04-13 22:50:29 +03:00
P(encodeURI) \
P(encodeURIComponent) \
LibJS: Implement String.prototype.endsWith()
2020-12-25 12:58:34 +11:00
P(endsWith) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 23:49:19 +02:00
P(entries) \
LibJS: Add some more items to CommonPropertyNames that I missed
2020-10-14 00:03:58 +02:00
P(enumerable) \
LibJS: Implement Temporal.Instant.prototype.epochMicroseconds
2021-07-08 22:11:51 +01:00
P(epochMicroseconds) \
LibJS: Implement Temporal.Instant.prototype.epochMilliseconds
2021-07-08 21:56:03 +01:00
P(epochMilliseconds) \
LibJS: Implement Temporal.Instant.prototype.epochNanoseconds
2021-07-08 22:20:49 +01:00
P(epochNanoseconds) \
LibJS: Implement Temporal.Instant.prototype.epochSeconds
2021-07-08 21:47:28 +01:00
P(epochSeconds) \
LibJS: Add Temporal.Instant.prototype.equals()
2021-07-11 21:23:38 +03:00
P(equals) \
LibJS: Implement Temporal.Calendar.prototype.era()
2021-08-27 19:45:10 +01:00
P(era) \
LibJS: Implement Temporal.Calendar.prototype.eraYear()
2021-08-27 19:52:41 +01:00
P(eraYear) \
LibJS: Add some more items to CommonPropertyNames that I missed
2020-10-14 00:03:58 +02:00
P(error) \
LibJS: Implement AggregateError
2021-06-11 18:06:20 +01:00
P(errors) \
LibJS: Add the global escape() & unescape() methods
2021-06-05 19:21:15 +03:00
P(escape) \
LibJS: Add naive implementation of eval() :^) This parses and executes a code string in the caller's lexical scope.
2021-03-14 16:20:01 +01:00
P(eval) \
LibJS: Implement ShadowRealm.prototype.evaluate()
2021-10-13 21:40:33 +01:00
P(evaluate) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 23:49:19 +02:00
P(every) \
LibJS: Implement Atomics.exchange
2021-07-12 08:08:13 -04:00
P(exchange) \
LibJS: Implement `RegExpPrototype::exec()' This implements *only* the builtin exec() function.
2020-11-22 14:18:49 +03:30
P(exec) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 23:49:19 +02:00
P(exp) \
P(expm1) \
LibJS: Implement the Intl.DisplayNames constructor There is notably FIXME notations in this commit regarding Unicode locale extensions. We are not parsing extensions (or private use extensions) at all yet.
2021-08-24 22:58:45 -04:00
P(fallback) \
LibJS: Implement the ToTemporalDate Abstract Operation This is required by most Temporal.PlainDate.prototype methods.
2021-07-21 22:20:57 +03:00
P(fields) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 23:49:19 +02:00
P(fill) \
P(filter) \
LibJS: Add initial support for Promises Almost a year after first working on this, it's finally done: an implementation of Promises for LibJS! :^) The core functionality is working and closely following the spec [1]. I mostly took the pseudo code and transformed it into C++ - if you read and understand it, you will know how the spec implements Promises; and if you read the spec first, the code will look very familiar. Implemented functions are: - Promise() constructor - Promise.prototype.then() - Promise.prototype.catch() - Promise.prototype.finally() - Promise.resolve() - Promise.reject() For the tests I added a new function to test-js's global object, runQueuedPromiseJobs(), which calls vm.run_queued_promise_jobs(). By design, queued jobs normally only run after the script was fully executed, making it improssible to test handlers in individual test() calls by default [2]. Subsequent commits include integrations into LibWeb and js(1) - pretty-printing, running queued promise jobs when necessary. This has an unusual amount of dbgln() statements, all hidden behind the PROMISE_DEBUG flag - I'm leaving them in for now as they've been very useful while debugging this, things can get quite complex with so many asynchronously executed functions. I've not extensively explored use of these APIs for promise-based functionality in LibWeb (fetch(), Notification.requestPermission() etc.), but we'll get there in due time. [1]: https://tc39.es/ecma262/#sec-promise-objects [2]: https://tc39.es/ecma262/#sec-jobs-and-job-queues
2021-04-01 22:13:29 +02:00
P(finally) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 23:49:19 +02:00
P(find) \
LibJS: Implement proposed Array.prototype.findLast{,Index} Proposal: https://tc39.es/proposal-array-find-from-last/
2021-08-03 14:12:47 +02:00
P(findLast) \
P(findLastIndex) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 23:49:19 +02:00
P(findIndex) \
LibJS: Add String.prototype.anchor & friends Adds an implementation of the following StringPrototype methods: anchor, big, blink, bold, fixed, fontcolor, fontsize, italics, link, small, strike, sub, sup.
2021-05-30 01:44:18 +03:00
P(fixed) \
LibJS: Hook up Regex<ECMA262> to RegExpObject and implement `test()' This makes RegExpObject compile and store a Regex<ECMA262>, adds all flag-related properties, and implements `RegExpPrototype.test()` (complete with 'lastIndex' support) :^) It should be noted that this only implements `test()' using the builtin `exec()'.
2020-11-19 01:50:00 +03:30
P(flags) \
LibJS: Implement Array.prototype.flat
2021-02-16 17:16:13 -03:00
P(flat) \
LibJS: Implement Array.prototype.flatMap Also made recursive_array_flat more compliant with the spec So renamed it to flatten_into_array
2021-06-13 16:21:59 +02:00
P(flatMap) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 23:49:19 +02:00
P(floor) \
LibJS: Add String.prototype.anchor & friends Adds an implementation of the following StringPrototype methods: anchor, big, blink, bold, fixed, fontcolor, fontsize, italics, link, small, strike, sub, sup.
2021-05-30 01:44:18 +03:00
P(fontcolor) \
P(fontsize) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 23:49:19 +02:00
P(forEach) \
LibJS: Implement Intl.ListFormat.prototype.format
2021-09-06 14:37:23 -04:00
P(format) \
LibJS+LibUnicode: Implement the Intl.DateTimeFormat constructor
2021-11-28 17:55:47 -05:00
P(formatMatcher) \
LibJS: Implement Intl.DateTimeFormat.prototype.formatRange
2021-12-08 19:57:21 -05:00
P(formatRange) \
LibJS: Implement Intl.DateTimeFormat.prototype.formatRangeToParts
2021-12-09 13:35:59 -05:00
P(formatRangeToParts) \
LibJS: Implement Intl.ListFormat.prototype.formatToParts
2021-09-06 14:57:57 -04:00
P(formatToParts) \
LibJS: Implement Temporal.Instant.prototype.toString()
2021-08-31 00:15:36 +01:00
P(fractionalSecondDigits) \
LibJS: Implement Object.freeze() and Object.seal()
2021-04-06 22:06:11 +02:00
P(freeze) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 23:49:19 +02:00
P(from) \
P(fromCharCode) \
LibJS: Add the String.fromCodePoint() method
2021-06-16 11:36:23 +03:00
P(fromCodePoint) \
LibJS: Add the Object.fromEntries method
2021-06-15 12:46:14 +03:00
P(fromEntries) \
LibJS: Implement Temporal.Instant.fromEpochMicroseconds()
2021-07-09 12:10:16 +01:00
P(fromEpochMicroseconds) \
LibJS: Implement Temporal.Instant.fromEpochMilliseconds()
2021-07-09 12:00:31 +01:00
P(fromEpochMilliseconds) \
LibJS: Implement Temporal.Instant.fromEpochNanoseconds()
2021-07-09 12:20:11 +01:00
P(fromEpochNanoseconds) \
LibJS: Implement Temporal.Instant.fromEpochSeconds()
2021-07-09 11:51:23 +01:00
P(fromEpochSeconds) \
LibJS: Add almost all Math functions
2020-12-28 17:34:51 +03:00
P(fround) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 23:49:19 +02:00
P(gc) \
P(get) \
LibJS: Add all of the DataView.prototype.get* methods
2021-06-14 01:57:15 +03:00
P(getBigInt64) \
P(getBigUint64) \
LibJS: Implement Intl.getCanonicalLocales
2021-08-25 09:41:25 -04:00
P(getCanonicalLocales) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 23:49:19 +02:00
P(getDate) \
P(getDay) \
LibJS: Add all of the DataView.prototype.get* methods
2021-06-14 01:57:15 +03:00
P(getFloat32) \
P(getFloat64) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 23:49:19 +02:00
P(getFullYear) \
P(getHours) \
LibJS: Implement Temporal.TimeZone.prototype.getInstantFor()
2021-11-01 14:20:06 +01:00
P(getInstantFor) \
LibJS: Add all of the DataView.prototype.get* methods
2021-06-14 01:57:15 +03:00
P(getInt8) \
P(getInt16) \
P(getInt32) \
LibJS: Implement Temporal.PlainDateTime.prototype.getISOFields()
2021-07-23 01:04:10 +01:00
P(getISOFields) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 23:49:19 +02:00
P(getMilliseconds) \
P(getMinutes) \
P(getMonth) \
LibJS: Implement Temporal.TimeZone.prototype.getNextTransition()
2021-10-30 10:26:42 +02:00
P(getNextTransition) \
LibJS: Implement Temporal.TimeZone.prototype.getOffsetNanosecondsFor()
2021-07-25 20:19:37 +01:00
P(getOffsetNanosecondsFor) \
LibJS: Implement Temporal.TimeZone.prototype.getOffsetStringFor()
2021-07-31 21:54:35 +01:00
P(getOffsetStringFor) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 23:49:19 +02:00
P(getOwnPropertyDescriptor) \
LibJS: Implement Object.getOwnPropertyDescriptors()
2021-07-06 19:41:54 +03:00
P(getOwnPropertyDescriptors) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 23:49:19 +02:00
P(getOwnPropertyNames) \
LibJS: Add the Object.getOwnPropertySymbols method
2021-06-12 17:41:13 +03:00
P(getOwnPropertySymbols) \
LibJS: Implement Temporal.TimeZone.prototype.getPlainDateTimeFor()
2021-07-31 22:21:53 +01:00
P(getPlainDateTimeFor) \
LibJS: Implement Temporal.TimeZone.prototype.getPossibleInstantsFor()
2021-10-30 10:22:19 +02:00
P(getPossibleInstantsFor) \
LibJS: Implement Temporal.TimeZone.prototype.getPreviousTransition()
2021-10-30 10:28:12 +02:00
P(getPreviousTransition) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 23:49:19 +02:00
P(getPrototypeOf) \
P(getSeconds) \
P(getTime) \
LibJS: Stub out Date.prototype.getTimezoneOffset() We only support UTC currently, so this always returns 0 as long as the date is not invalid.
2021-06-06 15:53:52 +03:00
P(getTimezoneOffset) \
LibJS: Add all of the DataView.prototype.get* methods
2021-06-14 01:57:15 +03:00
P(getUint8) \
P(getUint16) \
P(getUint32) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 23:49:19 +02:00
P(getUTCDate) \
P(getUTCDay) \
P(getUTCFullYear) \
P(getUTCHours) \
P(getUTCMilliseconds) \
P(getUTCMinutes) \
P(getUTCMonth) \
P(getUTCSeconds) \
LibJS: Add Date.prototype.{get, set}Year()
2021-05-29 23:52:17 +03:00
P(getYear) \
LibJS: Hook up Regex<ECMA262> to RegExpObject and implement `test()' This makes RegExpObject compile and store a Regex<ECMA262>, adds all flag-related properties, and implements `RegExpPrototype.test()` (complete with 'lastIndex' support) :^) It should be noted that this only implements `test()' using the builtin `exec()'.
2020-11-19 01:50:00 +03:30
P(global) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 23:49:19 +02:00
P(globalThis) \
LibJS: Start implementing Intl.Segmenter
2022-01-29 23:47:29 +02:00
P(granularity) \
LibJS+WebContent+Browser+js: Implement console.group() methods This implements: - console.group() - console.groupCollapsed() - console.groupEnd() In the Browser, we use `<details>` for the groups, which is not actually implemented yet, so groups are always open. In the REPL, groups are non-interactive, but still indent any output. This looks weird since the console prompt and return values remain on the far left, but this matches what Node does so it's probably fine. :^) I expect `console.group()` is not used much outside of browsers.
2021-12-22 12:32:15 +00:00
P(group) \
P(groupCollapsed) \
P(groupEnd) \
LibJS: Implement `RegExpPrototype::exec()' This implements *only* the builtin exec() function.
2020-11-22 14:18:49 +03:30
P(groups) \
LibJS: Rename Array.prototype.groupBy{,ToMap} => group{,ToMap} This is a normative change in the Array Grouping spec. See: https://github.com/tc39/proposal-array-grouping/commit/0cf4077
2022-06-13 19:47:04 +01:00
P(groupToMap) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 23:49:19 +02:00
P(has) \
LibJS: Parse the RegExp.prototype.hasIndices flag
2021-07-09 16:10:17 -04:00
P(hasIndices) \
LibJS: Implement Object.hasOwn() :^) This is currently a TC39 Stage 2 proposal, but let's go for it! https://github.com/tc39/proposal-accessible-object-hasownproperty I wrote the C++, @linusg found bugs and wrote the test.
2021-05-18 11:15:49 +02:00
P(hasOwn) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 23:49:19 +02:00
P(hasOwnProperty) \
LibJS: Implement Temporal.PlainTime.prototype.hour
2021-07-28 18:53:05 +01:00
P(hour) \
LibJS+LibUnicode: Implement the Intl.DateTimeFormat constructor
2021-11-28 17:55:47 -05:00
P(hour12) \
LibJS: Implement the Intl.Locale constructor
2021-09-01 22:08:15 -04:00
P(hourCycle) \
LibJS: Implement Temporal.Duration.prototype.hours
2021-07-15 23:48:59 +01:00
P(hours) \
LibJS: Implement Temporal.ZonedDateTime.prototype.hoursInDay
2021-11-03 16:21:58 +00:00
P(hoursInDay) \
LibJS: Add almost all Math functions
2020-12-28 17:34:51 +03:00
P(hypot) \
LibJS: Implement Temporal.TimeZone.prototype.id
2021-07-08 20:51:57 +01:00
P(id) \
LibJS: Hook up Regex<ECMA262> to RegExpObject and implement `test()' This makes RegExpObject compile and store a Regex<ECMA262>, adds all flag-related properties, and implements `RegExpPrototype.test()` (complete with 'lastIndex' support) :^) It should be noted that this only implements `test()' using the builtin `exec()'.
2020-11-19 01:50:00 +03:30
P(ignoreCase) \
LibJS: Implement the Intl.Collator constructor
2022-01-29 11:31:39 -05:00
P(ignorePunctuation) \
LibJS: Add almost all Math functions
2020-12-28 17:34:51 +03:00
P(imul) \
LibJS: Implement ShadowRealm.prototype.importValue() Well... sort of. This adds the function itself and all the scaffolding from the ShadowRealm API (and basically completes its implementation). However, we do not nearly have enough support for modules and imports, so we currently pretend whatever was attempted to be imported failed - once we have HostImportModuleDynamically it should be relatively easy to complete the implementation.
2021-10-15 01:10:05 +01:00
P(importValue) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 23:49:19 +02:00
P(includes) \
LibJS: Implement `RegExpPrototype::exec()' This implements *only* the builtin exec() function.
2020-11-22 14:18:49 +03:30
P(index) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 23:49:19 +02:00
P(indexOf) \
LibJS: Implement RegExp.prototype.hasIndices proposal https://tc39.es/proposal-regexp-match-indices/
2021-07-09 19:51:56 -04:00
P(indices) \
LibJS: Add some more items to CommonPropertyNames that I missed
2020-10-14 00:03:58 +02:00
P(info) \
LibJS: Implement Temporal.Calendar.prototype.inLeapYear
2021-07-23 19:03:19 +03:00
P(inLeapYear) \
LibJS: Implement `RegExpPrototype::exec()' This implements *only* the builtin exec() function.
2020-11-22 14:18:49 +03:30
P(input) \
LibJS: Implement Temporal.now.instant()
2021-07-07 17:42:21 +01:00
P(instant) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 23:49:19 +02:00
P(is) \
P(isArray) \
P(isExtensible) \
P(isFinite) \
LibJS: Implement Object.isFrozen() and Object.isSealed()
2021-04-06 22:45:12 +02:00
P(isFrozen) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 23:49:19 +02:00
P(isInteger) \
LibJS: Implement Atomics.isLockFree
2021-07-12 10:35:14 -04:00
P(isLockFree) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 23:49:19 +02:00
P(isNaN) \
LibJS: Implement Object.prototype.isPrototypeOf Spec: https://tc39.es/ecma262/#sec-object.prototype.isprototypeof
2020-12-28 01:22:38 +00:00
P(isPrototypeOf) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 23:49:19 +02:00
P(isSafeInteger) \
LibJS: Implement Object.isFrozen() and Object.isSealed()
2021-04-06 22:45:12 +02:00
P(isSealed) \
LibJS: Add ArrayBuffer
2020-12-02 20:49:31 +00:00
P(isView) \
LibJS: Implement Temporal.PlainDateTime.prototype.getISOFields()
2021-07-23 01:04:10 +01:00
P(isoDay) \
P(isoHour) \
P(isoMicrosecond) \
P(isoMillisecond) \
P(isoMinute) \
P(isoMonth) \
P(isoNanosecond) \
P(isoSecond) \
P(isoYear) \
LibJS: Implement the Intl CreateSegmentDataObject AO
2022-01-30 20:50:23 +02:00
P(isWordLike) \
LibJS: Add String.prototype.anchor & friends Adds an implementation of the following StringPrototype methods: anchor, big, blink, bold, fixed, fontcolor, fontsize, italics, link, small, strike, sub, sup.
2021-05-30 01:44:18 +03:00
P(italics) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 23:49:19 +02:00
P(join) \
P(keyFor) \
P(keys) \
LibJS: Implement the Intl.Locale constructor
2021-09-01 22:08:15 -04:00
P(language) \
LibJS: Parse new Intl.DisplayNames "type" and "languageDisplay" options Intl.DisplayNames v2 adds "calendar" and "dateTimeField" types, as well as a "languageDisplay" option for the "language" type. This just adds these options to the constructor.
2022-01-12 13:52:51 -05:00
P(languageDisplay) \
LibJS: Add a bunch of Temporal Abstract Operations These will allow us to (partially) implement Temporal.Instant.prototype.{until, since}
2021-09-06 21:21:57 +03:00
P(largestUnit) \
LibJS: Hook up Regex<ECMA262> to RegExpObject and implement `test()' This makes RegExpObject compile and store a Regex<ECMA262>, adds all flag-related properties, and implements `RegExpPrototype.test()` (complete with 'lastIndex' support) :^) It should be noted that this only implements `test()' using the builtin `exec()'.
2020-11-19 01:50:00 +03:30
P(lastIndex) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 23:49:19 +02:00
P(lastIndexOf) \
P(length) \
LibJS: Add String.prototype.anchor & friends Adds an implementation of the following StringPrototype methods: anchor, big, blink, bold, fixed, fontcolor, fontsize, italics, link, small, strike, sub, sup.
2021-05-30 01:44:18 +03:00
P(link) \
LibJS: Implement Atomics.load
2021-07-11 11:45:21 -04:00
P(load) \
LibJS: Implement Intl.DisplayNames.prototype.resolvedOptions
2021-08-24 23:26:44 -04:00
P(locale) \
LibJS: Implement a naive String.prototype.localeCompare
2021-07-26 00:23:39 +02:00
P(localeCompare) \
LibJS: Implement the Intl.DisplayNames constructor There is notably FIXME notations in this commit regarding Unicode locale extensions. We are not parsing extensions (or private use extensions) at all yet.
2021-08-24 22:58:45 -04:00
P(localeMatcher) \
LibJS: Add some more items to CommonPropertyNames that I missed
2020-10-14 00:03:58 +02:00
P(log) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 23:49:19 +02:00
P(log1p) \
LibJS: Add almost all Math functions
2020-12-28 17:34:51 +03:00
P(log2) \
P(log10) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 23:49:19 +02:00
P(map) \
P(max) \
LibJS: Accept ArrayBuffer constructor options argument Test262 seems to test the changes in the "Resizable ArrayBuffer and growable SharedArrayBuffer" proposal. Begin implementing this proposal by accepting the new options object argument to the ArrayBuffer constructor. https://tc39.es/proposal-resizablearraybuffer https://github.com/tc39/test262/blob/main/test/built-ins/ArrayBuffer/options-maxbytelength-diminuitive.js
2022-03-02 11:44:32 -05:00
P(maxByteLength) \
LibJS: Implement Intl.Locale.prototype.maximize
2021-09-02 19:03:41 -04:00
P(maximize) \
LibJS: Implement Temporal.Calendar.prototype.mergeFields()
2021-08-16 22:23:52 +01:00
P(mergeFields) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 23:49:19 +02:00
P(message) \
LibJS: Implement Temporal.PlainTime.prototype.microsecond
2021-07-28 19:05:30 +01:00
P(microsecond) \
LibJS: Implement Temporal.Duration.prototype.microseconds
2021-07-15 23:57:07 +01:00
P(microseconds) \
LibJS: Implement Temporal.PlainTime.prototype.millisecond
2021-07-28 19:02:44 +01:00
P(millisecond) \
LibJS: Implement Temporal.Duration.prototype.milliseconds
2021-07-15 23:54:58 +01:00
P(milliseconds) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 23:49:19 +02:00
P(min) \
LibJS: Implement Intl.Locale.prototype.minimize
2021-09-02 21:45:42 -04:00
P(minimize) \
LibJS: Implement the Intl.NumberFormat constructor
2021-09-10 11:04:54 -04:00
P(maximumFractionDigits) \
P(maximumSignificantDigits) \
P(minimumFractionDigits) \
P(minimumIntegerDigits) \
P(minimumSignificantDigits) \
LibJS: Implement Temporal.PlainTime.prototype.minute
2021-07-28 18:55:29 +01:00
P(minute) \
LibJS: Implement Temporal.Duration.prototype.minutes
2021-07-15 23:51:02 +01:00
P(minutes) \
LibJS: Add Temporal.Calendar.prototype.dateFromFields & required AOs This is required for implementing the DateFromFields PlainDate AO.
2021-07-21 22:17:40 +03:00
P(month) \
P(monthCode) \
LibJS: Implement Temporal.Calendar.prototype.monthDayFromFields()
2021-08-16 18:04:58 +01:00
P(monthDayFromFields) \
LibJS: Implement Temporal.Duration.prototype.months
2021-07-15 23:41:55 +01:00
P(months) \
LibJS: Implement Temporal.Calendar.prototype.monthsInYear
2021-07-23 18:52:55 +03:00
P(monthsInYear) \
LibJS: Hook up Regex<ECMA262> to RegExpObject and implement `test()' This makes RegExpObject compile and store a Regex<ECMA262>, adds all flag-related properties, and implements `RegExpPrototype.test()` (complete with 'lastIndex' support) :^) It should be noted that this only implements `test()' using the builtin `exec()'.
2020-11-19 01:50:00 +03:30
P(multiline) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 23:49:19 +02:00
P(name) \
LibJS: Implement Temporal.PlainTime.prototype.nanosecond
2021-07-28 19:07:29 +01:00
P(nanosecond) \
LibJS: Implement Temporal.Duration.prototype.nanoseconds
2021-07-16 00:07:49 +01:00
P(nanoseconds) \
LibJS: Implement Temporal.Duration.prototype.negated()
2021-07-16 19:41:37 +01:00
P(negated) \
LibJS: Add some more items to CommonPropertyNames that I missed
2020-10-14 00:03:58 +02:00
P(next) \
LibJS: Stub out String.prototype.normalize
2022-06-02 01:37:15 +02:00
P(normalize) \
LibJS: Implement the Intl.NumberFormat constructor
2021-09-10 11:04:54 -04:00
P(notation) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 23:49:19 +02:00
P(now) \
LibJS: Implement the Intl.Locale constructor
2021-09-01 22:08:15 -04:00
P(numberingSystem) \
P(numeric) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 23:49:19 +02:00
P(of) \
LibJS: Implement Temporal.ZonedDateTime.prototype.offset
2021-08-04 23:18:19 +01:00
P(offset) \
LibJS: Implement Temporal.ZonedDateTime.prototype.offsetNanoseconds
2021-08-04 23:17:07 +01:00
P(offsetNanoseconds) \
LibJS: Make Temporal's get_option() take a PropertyName directly Instead of constructing a String and converting that to a PropertyName on the fly, we can just leverage CommonPropertyNames, add a couple more and directly pass ready-to-use PropertyNames with pre-allocated Strings.
2021-08-18 20:27:44 +01:00
P(overflow) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 23:49:19 +02:00
P(ownKeys) \
P(padEnd) \
P(padStart) \
P(parse) \
P(parseFloat) \
LibJS: Implement parseInt() Here's a reasonably faithful implementation of ECMAScript 2021 18.2.5. Some corner cases are not covered, I've left them as FIXME's in the included unit test. Also I had to tweak JS::Value::to_i32() to always convert infinity to zero, which is in accordance with ToInt32 AFAICT.
2020-12-05 13:51:09 +01:00
P(parseInt) \
LibJS: Implement Temporal.Now.plainDate() ...and ten required AOs we didn't have yet: - BalanceISODate - BalanceISODateTime - BalanceISOYearMonth - BalanceTime - BuiltinTimeZoneGetPlainDateTimeFor - GetISOPartsFromEpoch - GetOffsetNanosecondsFor - ParseTemporalTimeZone - SystemDateTime - ToTemporalTimeZone
2021-07-27 00:21:16 +01:00
P(plainDate) \
LibJS: Implement Temporal.Now.plainDateISO()
2021-07-27 00:30:10 +01:00
P(plainDateISO) \
LibJS: Implement Temporal.Now.plainDateTime()
2021-07-27 00:49:52 +01:00
P(plainDateTime) \
LibJS: Implement Temporal.Now.plainDateTimeISO()
2021-07-27 00:58:57 +01:00
P(plainDateTimeISO) \
LibJS: Implement Temporal.PlainDate.prototype.toZonedDateTime()
2021-11-02 17:47:23 +01:00
P(plainTime) \
LibJS: Implement Temporal.Now.plainTimeISO()
2021-07-28 19:29:16 +01:00
P(plainTimeISO) \
LibJS: Implement Intl.PluralRules.prototype.resolvedOptions
2022-01-28 13:42:20 -05:00
P(pluralCategories) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 23:49:19 +02:00
P(pop) \
P(pow) \
P(preventExtensions) \
LibJS: Implement Object.prototype.propertyIsEnumerable Spec: https://tc39.es/ecma262/#sec-object.prototype.propertyisenumerable This is used by core-js, which is used by frameworks such as Vue.
2020-12-24 17:51:28 +00:00
P(propertyIsEnumerable) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 23:49:19 +02:00
P(prototype) \
LibJS: Implement Proxy.revocable()
2021-06-08 21:48:43 +01:00
P(proxy) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 23:49:19 +02:00
P(push) \
LibJS: Add initial support for Promises Almost a year after first working on this, it's finally done: an implementation of Promises for LibJS! :^) The core functionality is working and closely following the spec [1]. I mostly took the pseudo code and transformed it into C++ - if you read and understand it, you will know how the spec implements Promises; and if you read the spec first, the code will look very familiar. Implemented functions are: - Promise() constructor - Promise.prototype.then() - Promise.prototype.catch() - Promise.prototype.finally() - Promise.resolve() - Promise.reject() For the tests I added a new function to test-js's global object, runQueuedPromiseJobs(), which calls vm.run_queued_promise_jobs(). By design, queued jobs normally only run after the script was fully executed, making it improssible to test handlers in individual test() calls by default [2]. Subsequent commits include integrations into LibWeb and js(1) - pretty-printing, running queued promise jobs when necessary. This has an unusual amount of dbgln() statements, all hidden behind the PROMISE_DEBUG flag - I'm leaving them in for now as they've been very useful while debugging this, things can get quite complex with so many asynchronously executed functions. I've not extensively explored use of these APIs for promise-based functionality in LibWeb (fetch(), Notification.requestPermission() etc.), but we'll get there in due time. [1]: https://tc39.es/ecma262/#sec-promise-objects [2]: https://tc39.es/ecma262/#sec-jobs-and-job-queues
2021-04-01 22:13:29 +02:00
P(race) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 23:49:19 +02:00
P(random) \
P(raw) \
LibJS: Implement Promise.allSettled on the Promise constructor
2021-08-21 17:00:48 -04:00
P(reason) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 23:49:19 +02:00
P(reduce) \
P(reduceRight) \
LibJS: Implement the Intl.Locale constructor
2021-09-01 22:08:15 -04:00
P(region) \
LibJS: Add initial support for Promises Almost a year after first working on this, it's finally done: an implementation of Promises for LibJS! :^) The core functionality is working and closely following the spec [1]. I mostly took the pseudo code and transformed it into C++ - if you read and understand it, you will know how the spec implements Promises; and if you read the spec first, the code will look very familiar. Implemented functions are: - Promise() constructor - Promise.prototype.then() - Promise.prototype.catch() - Promise.prototype.finally() - Promise.resolve() - Promise.reject() For the tests I added a new function to test-js's global object, runQueuedPromiseJobs(), which calls vm.run_queued_promise_jobs(). By design, queued jobs normally only run after the script was fully executed, making it improssible to test handlers in individual test() calls by default [2]. Subsequent commits include integrations into LibWeb and js(1) - pretty-printing, running queued promise jobs when necessary. This has an unusual amount of dbgln() statements, all hidden behind the PROMISE_DEBUG flag - I'm leaving them in for now as they've been very useful while debugging this, things can get quite complex with so many asynchronously executed functions. I've not extensively explored use of these APIs for promise-based functionality in LibWeb (fetch(), Notification.requestPermission() etc.), but we'll get there in due time. [1]: https://tc39.es/ecma262/#sec-promise-objects [2]: https://tc39.es/ecma262/#sec-jobs-and-job-queues
2021-04-01 22:13:29 +02:00
P(reject) \
LibJS: Implement the required AOs for Temporal.Duration.compare
2021-11-09 17:19:28 +00:00
P(relativeTo) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 23:49:19 +02:00
P(repeat) \
LibJS: Implement and test ArrayBuffer.prototype.resize
2022-03-02 11:24:46 -05:00
P(resize) \
LibJS: Implement and test getters added by resizable ArrayBuffer
2022-03-02 11:45:26 -05:00
P(resizable) \
LibJS: Add initial support for Promises Almost a year after first working on this, it's finally done: an implementation of Promises for LibJS! :^) The core functionality is working and closely following the spec [1]. I mostly took the pseudo code and transformed it into C++ - if you read and understand it, you will know how the spec implements Promises; and if you read the spec first, the code will look very familiar. Implemented functions are: - Promise() constructor - Promise.prototype.then() - Promise.prototype.catch() - Promise.prototype.finally() - Promise.resolve() - Promise.reject() For the tests I added a new function to test-js's global object, runQueuedPromiseJobs(), which calls vm.run_queued_promise_jobs(). By design, queued jobs normally only run after the script was fully executed, making it improssible to test handlers in individual test() calls by default [2]. Subsequent commits include integrations into LibWeb and js(1) - pretty-printing, running queued promise jobs when necessary. This has an unusual amount of dbgln() statements, all hidden behind the PROMISE_DEBUG flag - I'm leaving them in for now as they've been very useful while debugging this, things can get quite complex with so many asynchronously executed functions. I've not extensively explored use of these APIs for promise-based functionality in LibWeb (fetch(), Notification.requestPermission() etc.), but we'll get there in due time. [1]: https://tc39.es/ecma262/#sec-promise-objects [2]: https://tc39.es/ecma262/#sec-jobs-and-job-queues
2021-04-01 22:13:29 +02:00
P(resolve) \
LibJS: Implement Intl.DisplayNames.prototype.resolvedOptions
2021-08-24 23:26:44 -04:00
P(resolvedOptions) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 23:49:19 +02:00
P(reverse) \
LibJS: Implement Proxy.revocable()
2021-06-08 21:48:43 +01:00
P(revocable) \
P(revoke) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 23:49:19 +02:00
P(round) \
LibJS: Make Temporal's get_option() take a PropertyName directly Instead of constructing a String and converting that to a PropertyName on the fly, we can just leverage CommonPropertyNames, add a couple more and directly pass ready-to-use PropertyNames with pre-allocated Strings.
2021-08-18 20:27:44 +01:00
P(roundingIncrement) \
P(roundingMode) \
LibJS: Implement the Intl.Locale constructor
2021-09-01 22:08:15 -04:00
P(script) \
LibJS: Implement Object.freeze() and Object.seal()
2021-04-06 22:06:11 +02:00
P(seal) \
LibJS: Implement Temporal.PlainTime.prototype.second
2021-07-28 18:59:27 +01:00
P(second) \
LibJS: Implement Temporal.Duration.prototype.seconds
2021-07-15 23:53:19 +01:00
P(seconds) \
LibJS: Implement Intl.Segmenter.prototype.segment
2022-01-30 01:31:59 +02:00
P(segment) \
LibJS: Implement the Intl.Collator constructor
2022-01-29 11:31:39 -05:00
P(sensitivity) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 23:49:19 +02:00
P(set) \
LibJS: Add all of the DataView.prototype.set* methods
2021-06-14 02:02:53 +03:00
P(setBigInt64) \
P(setBigUint64) \
LibJS: Add Date.prototype.setDate()
2021-06-06 16:25:33 +03:00
P(setDate) \
LibJS: Add all of the DataView.prototype.set* methods
2021-06-14 02:02:53 +03:00
P(setFloat32) \
P(setFloat64) \
LibJS: Partial support for Date.prototype.setFullYear()
2021-03-14 16:23:46 +01:00
P(setFullYear) \
LibJS: Add Date methods: setHours, setMinutes, setSeconds, setMilliseconds
2021-03-19 22:12:08 +03:00
P(setHours) \
LibJS: Add all of the DataView.prototype.set* methods
2021-06-14 02:02:53 +03:00
P(setInt8) \
P(setInt16) \
P(setInt32) \
LibJS: Add Date methods: setHours, setMinutes, setSeconds, setMilliseconds
2021-03-19 22:12:08 +03:00
P(setMilliseconds) \
P(setMinutes) \
LibJS: Add Date.prototype.setMonth()
2021-06-06 16:26:29 +03:00
P(setMonth) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 23:49:19 +02:00
P(setPrototypeOf) \
LibJS: Add Date methods: setHours, setMinutes, setSeconds, setMilliseconds
2021-03-19 22:12:08 +03:00
P(setSeconds) \
LibJS: Add Date.prototype.setTime()
2021-06-06 16:27:21 +03:00
P(setTime) \
LibJS: Add all of the DataView.prototype.set* methods
2021-06-14 02:02:53 +03:00
P(setUint8) \
P(setUint16) \
P(setUint32) \
LibJS: Add Date.setUTC{Date, Month, Hours, ...}() aliases These are a bit hacky, since they are supposed to be separate methods, but since serenity only supports UTC currently, they are equivalent.
2021-06-06 17:34:04 +03:00
P(setUTCDate) \
P(setUTCFullYear) \
P(setUTCHours) \
P(setUTCMilliseconds) \
P(setUTCMinutes) \
P(setUTCMonth) \
P(setUTCSeconds) \
LibJS: Add Date.prototype.{get, set}Year()
2021-05-29 23:52:17 +03:00
P(setYear) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 23:49:19 +02:00
P(shift) \
P(sign) \
LibJS: Implement the Intl.NumberFormat constructor
2021-09-10 11:04:54 -04:00
P(signDisplay) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 23:49:19 +02:00
P(sin) \
LibJS: Implement Temporal.Instant.prototype.since
2021-09-06 21:36:54 +03:00
P(since) \
LibJS: Add almost all Math functions
2020-12-28 17:34:51 +03:00
P(sinh) \
LibJS: Add the Set built-in object
2021-06-09 00:08:47 +03:00
P(size) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 23:49:19 +02:00
P(slice) \
LibJS: Add String.prototype.anchor & friends Adds an implementation of the following StringPrototype methods: anchor, big, blink, bold, fixed, fontcolor, fontsize, italics, link, small, strike, sub, sup.
2021-05-30 01:44:18 +03:00
P(small) \
LibJS: Make Temporal's get_option() take a PropertyName directly Instead of constructing a String and converting that to a PropertyName on the fly, we can just leverage CommonPropertyNames, add a couple more and directly pass ready-to-use PropertyNames with pre-allocated Strings.
2021-08-18 20:27:44 +01:00
P(smallestUnit) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 23:49:19 +02:00
P(some) \
LibJS: Implement Array.prototype.sort()
2020-12-26 22:14:14 +11:00
P(sort) \
LibJS: Hook up Regex<ECMA262> to RegExpObject and implement `test()' This makes RegExpObject compile and store a Regex<ECMA262>, adds all flag-related properties, and implements `RegExpPrototype.test()` (complete with 'lastIndex' support) :^) It should be noted that this only implements `test()' using the builtin `exec()'.
2020-11-19 01:50:00 +03:30
P(source) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 23:49:19 +02:00
P(splice) \
P(sqrt) \
LibJS: Implement non standard error.stack attribute All other browser already support this feature. There is a Stage 1 proposal to standardize this, but it does not seem to be active.
2022-02-06 17:00:28 +01:00
P(stack) \
LibJS: Implement Temporal.ZonedDateTime.prototype.startOfDay
2021-11-03 20:22:55 +00:00
P(startOfDay) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 23:49:19 +02:00
P(startsWith) \
LibJS: Implement Promise.allSettled on the Promise constructor
2021-08-21 17:00:48 -04:00
P(status) \
LibJS: Hook up Regex<ECMA262> to RegExpObject and implement `test()' This makes RegExpObject compile and store a Regex<ECMA262>, adds all flag-related properties, and implements `RegExpPrototype.test()` (complete with 'lastIndex' support) :^) It should be noted that this only implements `test()' using the builtin `exec()'.
2020-11-19 01:50:00 +03:30
P(sticky) \
LibJS: Implement Atomics.store
2021-07-11 14:37:54 -04:00
P(store) \
LibJS: Add String.prototype.anchor & friends Adds an implementation of the following StringPrototype methods: anchor, big, blink, bold, fixed, fontcolor, fontsize, italics, link, small, strike, sub, sup.
2021-05-30 01:44:18 +03:00
P(strike) \
LibJS: Add a basic implementation of String.prototype.substr()
2020-11-29 20:28:10 +01:00
P(stringify) \
LibJS: Implement the Intl.DisplayNames constructor There is notably FIXME notations in this commit regarding Unicode locale extensions. We are not parsing extensions (or private use extensions) at all yet.
2021-08-24 22:58:45 -04:00
P(style) \
LibJS: Add String.prototype.anchor & friends Adds an implementation of the following StringPrototype methods: anchor, big, blink, bold, fixed, fontcolor, fontsize, italics, link, small, strike, sub, sup.
2021-05-30 01:44:18 +03:00
P(sub) \
LibJS: Add %TypedArray%.prototype.subarray
2021-07-09 17:17:10 +03:00
P(subarray) \
LibJS: Add a basic implementation of String.prototype.substr()
2020-11-29 20:28:10 +01:00
P(substr) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 23:49:19 +02:00
P(substring) \
LibJS: Implement Temporal.Instant.prototype.subtract()
2021-08-07 00:38:21 +01:00
P(subtract) \
LibJS: Add String.prototype.anchor & friends Adds an implementation of the following StringPrototype methods: anchor, big, blink, bold, fixed, fontcolor, fontsize, italics, link, small, strike, sub, sup.
2021-05-30 01:44:18 +03:00
P(sup) \
LibJS: Implement Intl.DisplayNames.supportedLocalesOf()
2021-09-04 17:08:57 +01:00
P(supportedLocalesOf) \
LibJS: Implement Intl.supportedValuesOf This is a stage 3 ECMA-402 proposal: https://tc39.es/proposal-intl-enumeration/
2022-01-30 17:36:23 -05:00
P(supportedValuesOf) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 23:49:19 +02:00
P(tan) \
LibJS: Add almost all Math functions
2020-12-28 17:34:51 +03:00
P(tanh) \
LibJS: Hook up Regex<ECMA262> to RegExpObject and implement `test()' This makes RegExpObject compile and store a Regex<ECMA262>, adds all flag-related properties, and implements `RegExpPrototype.test()` (complete with 'lastIndex' support) :^) It should be noted that this only implements `test()' using the builtin `exec()'.
2020-11-19 01:50:00 +03:30
P(test) \
LibJS: Add initial support for Promises Almost a year after first working on this, it's finally done: an implementation of Promises for LibJS! :^) The core functionality is working and closely following the spec [1]. I mostly took the pseudo code and transformed it into C++ - if you read and understand it, you will know how the spec implements Promises; and if you read the spec first, the code will look very familiar. Implemented functions are: - Promise() constructor - Promise.prototype.then() - Promise.prototype.catch() - Promise.prototype.finally() - Promise.resolve() - Promise.reject() For the tests I added a new function to test-js's global object, runQueuedPromiseJobs(), which calls vm.run_queued_promise_jobs(). By design, queued jobs normally only run after the script was fully executed, making it improssible to test handlers in individual test() calls by default [2]. Subsequent commits include integrations into LibWeb and js(1) - pretty-printing, running queued promise jobs when necessary. This has an unusual amount of dbgln() statements, all hidden behind the PROMISE_DEBUG flag - I'm leaving them in for now as they've been very useful while debugging this, things can get quite complex with so many asynchronously executed functions. I've not extensively explored use of these APIs for promise-based functionality in LibWeb (fetch(), Notification.requestPermission() etc.), but we'll get there in due time. [1]: https://tc39.es/ecma262/#sec-promise-objects [2]: https://tc39.es/ecma262/#sec-jobs-and-job-queues
2021-04-01 22:13:29 +02:00
P(then) \
LibJS: Implement console.time/timeLog/timeEnd() methods
2021-12-22 16:40:57 +00:00
P(time) \
P(timeEnd) \
P(timeLog) \
LibJS+LibUnicode: Implement the Intl.DateTimeFormat constructor
2021-11-28 17:55:47 -05:00
P(timeStyle) \
LibJS: Implement Temporal.now.timeZone()
2021-07-06 23:54:53 +01:00
P(timeZone) \
LibJS: Implement the required AOs for ZonedDateTime stringifiers
2021-11-10 00:14:16 +00:00
P(timeZoneName) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 23:49:19 +02:00
P(toDateString) \
LibJS: Implement Number.prototype.toExponential
2022-01-03 19:48:44 -05:00
P(toExponential) \
LibJS: Add the Number.prototype.toFixed method
2021-06-19 17:02:42 +03:00
P(toFixed) \
LibJS: Add Date.prototype.toGMTString()
2021-03-14 16:40:41 +01:00
P(toGMTString) \
LibJS: Implement Temporal.ZonedDateTime.prototype.toInstant()
2021-08-05 21:48:23 +01:00
P(toInstant) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 23:49:19 +02:00
P(toISOString) \
P(toJSON) \
P(toLocaleDateString) \
LibJS: Implement non-ECMA-402 String.prototype.toLocale{Lower,Upper}Case In implementations without ECMA-402, these methods are to behave like their non-locale equivalents.
2021-07-27 16:35:25 -04:00
P(toLocaleLowerCase) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 23:49:19 +02:00
P(toLocaleString) \
P(toLocaleTimeString) \
LibJS: Implement non-ECMA-402 String.prototype.toLocale{Lower,Upper}Case In implementations without ECMA-402, these methods are to behave like their non-locale equivalents.
2021-07-27 16:35:25 -04:00
P(toLocaleUpperCase) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 23:49:19 +02:00
P(toLowerCase) \
LibJS: Implement Temporal.PlainDateTime.prototype.toPlainDate()
2021-07-23 00:39:18 +01:00
P(toPlainDate) \
LibJS: Implement Temporal.PlainTime.prototype.toPlainDateTime
2021-07-30 00:28:04 +03:00
P(toPlainDateTime) \
LibJS: Implement Temporal.PlainDate.prototype.toPlainMonthDay()
2021-08-16 18:13:47 +01:00
P(toPlainMonthDay) \
LibJS: Implement Temporal.PlainDateTime.prototype.toPlainTime
2021-07-31 01:44:31 +03:00
P(toPlainTime) \
LibJS: Implement Temporal.PlainDate.prototype.toPlainYearMonth()
2021-08-16 00:42:01 +01:00
P(toPlainYearMonth) \
LibJS: Implement Number.prototype.toPrecision As noted in the prototype comments, this implementation becomes less accurate as the precision approaches the limit of 100. For example: (3).toPrecision(100) Should result in "3." followed by 99 "0"s. However, due to the loss of accuracy in the floating point computations, we currently result in "2.9999999...".
2022-01-02 23:06:51 -05:00
P(toPrecision) \
LibJS: Implement Array.prototype.toReversed()
2022-06-13 07:57:38 +01:00
P(toReversed) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 23:49:19 +02:00
P(toString) \
LibJS: Implement Temporal.Duration.prototype.total()
2021-11-13 17:38:00 +00:00
P(total) \
LibJS: Implement Date.prototype.toTemporalInstant()
2021-07-08 00:31:49 +01:00
P(toTemporalInstant) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 23:49:19 +02:00
P(toTimeString) \
P(toUpperCase) \
LibJS Date: Added toUTCString() toGMTString() is deprecated but is kept for compatibility's sake, but because HTTP Dates are always expressed in GMT, it should be safe to call toUTCString() in toGMTString().
2021-03-16 14:36:32 +01:00
P(toUTCString) \
LibJS: Implement Temporal.Instant.prototype.toZonedDateTime()
2021-09-09 00:27:19 +01:00
P(toZonedDateTime) \
LibJS: Implement Temporal.Instant.prototype.toZonedDateTimeISO()
2021-09-09 00:35:24 +01:00
P(toZonedDateTimeISO) \
LibJS: Add some more items to CommonPropertyNames that I missed
2020-10-14 00:03:58 +02:00
P(trace) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 23:49:19 +02:00
P(trim) \
P(trimEnd) \
LibJS: Add the String.prototype.trim{Left, Right} aliases These are the same as trim{Start, End} respectively.
2021-06-02 00:59:15 +03:00
P(trimLeft) \
P(trimRight) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 23:49:19 +02:00
P(trimStart) \
P(trunc) \
LibJS: Implement the Intl.DisplayNames constructor There is notably FIXME notations in this commit regarding Unicode locale extensions. We are not parsing extensions (or private use extensions) at all yet.
2021-08-24 22:58:45 -04:00
P(type) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 23:49:19 +02:00
P(undefined) \
LibJS: Add the global escape() & unescape() methods
2021-06-05 19:21:15 +03:00
P(unescape) \
LibJS: Hook up Regex<ECMA262> to RegExpObject and implement `test()' This makes RegExpObject compile and store a Regex<ECMA262>, adds all flag-related properties, and implements `RegExpPrototype.test()` (complete with 'lastIndex' support) :^) It should be noted that this only implements `test()' using the builtin `exec()'.
2020-11-19 01:50:00 +03:30
P(unicode) \
LibJS: Implement the Intl.NumberFormat constructor
2021-09-10 11:04:54 -04:00
P(unit) \
P(unitDisplay) \
LibJS: Implement Temporal.Instant.prototype.until
2021-09-06 21:28:06 +03:00
P(until) \
LibJS: Add all of the FinalizationRegistry.prototype methods More specifically: cleanupSome, register & unregister. FinalizationRegistery.prototype.cleanupSome is actually still a stage 2 proposal, but since test262 test cases already exist for it, i decided to go for it :)
2021-06-15 22:21:24 +03:00
P(unregister) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 23:49:19 +02:00
P(unshift) \
LibJS: Implement the Intl.Collator constructor
2022-01-29 11:31:39 -05:00
P(usage) \
LibJS: Implement the Intl.NumberFormat constructor
2021-09-10 11:04:54 -04:00
P(useGrouping) \
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 23:49:19 +02:00
P(value) \
P(valueOf) \
LibJS: Add some more items to CommonPropertyNames that I missed
2020-10-14 00:03:58 +02:00
P(values) \
P(warn) \
LibJS: Implement Temporal.Calendar.prototype.weekOfYear
2021-07-23 18:19:45 +03:00
P(weekOfYear) \
LibJS+LibUnicode: Implement the Intl.DateTimeFormat constructor
2021-11-28 17:55:47 -05:00
P(weekday) \
LibJS: Implement Temporal.Duration.prototype.weeks
2021-07-15 23:43:55 +01:00
P(weeks) \
LibJS: Implement Temporal.Duration.prototype.with()
2021-07-16 19:30:52 +01:00
P(with) \
LibJS: Implement Temporal.PlainDate.prototype.withCalendar
2021-07-23 15:01:40 +03:00
P(withCalendar) \
LibJS: Implement Temporal.PlainDateTime.prototype.withPlainDate
2021-07-31 01:39:36 +03:00
P(withPlainDate) \
LibJS: Implement Temporal.PlainDateTime.prototype.withPlainTime()
2021-08-27 19:05:16 +03:00
P(withPlainTime) \
LibJS: Implement Temporal.ZonedDateTime.prototype.withTimeZone
2021-11-05 01:35:23 +00:00
P(withTimeZone) \
LibJS: Implement Temporal.Duration.prototype.years
2021-07-15 23:34:53 +01:00
P(writable) \
LibJS: Add Temporal.Calendar.prototype.dateFromFields & required AOs This is required for implementing the DateFromFields PlainDate AO.
2021-07-21 22:17:40 +03:00
P(year) \
LibJS: Implement Temporal.Calendar.prototype.yearMonthFromFields()
2021-08-16 00:35:05 +01:00
P(yearMonthFromFields) \
LibJS: Implement Temporal.Now.zonedDateTime()
2021-08-01 18:31:56 +01:00
P(years) \
LibJS: Implement Temporal.Now.zonedDateTimeISO()
2021-08-01 18:36:15 +01:00
P(zonedDateTime) \
P(zonedDateTimeISO)
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 23:49:19 +02:00
struct CommonPropertyNames {
LibJS: Rename PropertyName to PropertyKey Let's use the same name as the spec. :^)
2021-10-24 16:01:24 +02:00
PropertyKey and_ { "and", PropertyKey::StringMayBeNumber::No };
PropertyKey catch_ { "catch", PropertyKey::StringMayBeNumber::No };
PropertyKey delete_ { "delete", PropertyKey::StringMayBeNumber::No };
PropertyKey for_ { "for", PropertyKey::StringMayBeNumber::No };
PropertyKey or_ { "or", PropertyKey::StringMayBeNumber::No };
PropertyKey register_ { "register", PropertyKey::StringMayBeNumber::No };
PropertyKey return_ { "return", PropertyKey::StringMayBeNumber::No };
PropertyKey throw_ { "throw", PropertyKey::StringMayBeNumber::No };
PropertyKey xor_ { "xor", PropertyKey::StringMayBeNumber::No };
#define __ENUMERATE(x) PropertyKey x { #x, PropertyKey::StringMayBeNumber::No };
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 23:49:19 +02:00
ENUMERATE_STANDARD_PROPERTY_NAMES(__ENUMERATE)
#undef __ENUMERATE
LibJS: Rename PropertyName to PropertyKey Let's use the same name as the spec. :^)
2021-10-24 16:01:24 +02:00
#define __JS_ENUMERATE(x, a, b, c, t) PropertyKey x { #x, PropertyKey::StringMayBeNumber::No };
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 23:49:19 +02:00
JS_ENUMERATE_BUILTIN_TYPES
#undef __JS_ENUMERATE
LibJS: Rename PropertyName to PropertyKey Let's use the same name as the spec. :^)
2021-10-24 16:01:24 +02:00
#define __JS_ENUMERATE(x, a, b, c) PropertyKey x { #x, PropertyKey::StringMayBeNumber::No };
LibJS: Add preparation for Intl constructors and prototypes Add a JS_ENUMERATE_INTL_OBJECTS macro and use it to generate: - Forward declarations - CommonPropertyNames class name members - Constructor and prototype GlobalObject members, getters, visitors, and initialize_constructor() calls
2021-08-08 18:35:29 +01:00
JS_ENUMERATE_INTL_OBJECTS
#undef __JS_ENUMERATE
LibJS: Rename PropertyName to PropertyKey Let's use the same name as the spec. :^)
2021-10-24 16:01:24 +02:00
#define __JS_ENUMERATE(x, a, b, c) PropertyKey x { #x, PropertyKey::StringMayBeNumber::No };
LibJS: Add preparation for Temporal constructors and prototypes Add a JS_ENUMERATE_TEMPORAL_OBJECTS macro and use it to generate: - Forward declarations - CommonPropertyNames class name members - Constructor and prototype GlobalObject members, getters, visitors, and initialize_constructor() calls
2021-07-06 20:39:55 +01:00
JS_ENUMERATE_TEMPORAL_OBJECTS
#undef __JS_ENUMERATE
LibJS: Rename PropertyName to PropertyKey Let's use the same name as the spec. :^)
2021-10-24 16:01:24 +02:00
#define __JS_ENUMERATE(x, a) PropertyKey x { #x, PropertyKey::StringMayBeNumber::No };
LibJS: Cache commonly used FlyStrings in the VM Roughly 7% of test-js runtime was spent creating FlyStrings from string literals. This patch frontloads that work and caches all the commonly used names in LibJS on a CommonPropertyNames struct that hangs off VM.
2020-10-13 23:49:19 +02:00
JS_ENUMERATE_WELL_KNOWN_SYMBOLS
#undef __JS_ENUMERATE
};
}
Reference in a new issue Copy permalink