mirrors/ladybird
0
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2025-07-31 05:09:12 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 9

LibGC: Rename MarkedVector => RootVector

Browse source 
Let's try to make it a bit more clear that this is a Vector of GC roots.
This commit is contained in:
Andreas Kling 2024-12-26 14:32:52 +01:00 • committed by Andreas Kling
commit 3bfb0534be
Notes: github-actions[bot] 2024-12-26 18:11:36 +00:00
117 changed files with 281 additions and 281 deletions
Download patch file Download diff file Expand all files Collapse all files

2
Libraries/LibJS/AST.cpp
View file

@ -14,7 +14,7 @@
#include <AK/TemporaryChange.h>
#include <LibCrypto/BigInt/SignedBigInteger.h>
#include <LibGC/ConservativeVector.h>
#include <LibGC/MarkedVector.h>
#include <LibGC/RootVector.h>
#include <LibJS/AST.h>
#include <LibJS/Runtime/AbstractOperations.h>
#include <LibJS/Runtime/Accessor.h>

2
Libraries/LibJS/Bytecode/Generator.h
View file

@ -373,7 +373,7 @@ private:
NonnullOwnPtr<StringTable> m_string_table;
NonnullOwnPtr<IdentifierTable> m_identifier_table;
NonnullOwnPtr<RegexTable> m_regex_table;
GC::MarkedVector<Value> m_constants;
GC::RootVector<Value> m_constants;
mutable Optional<ScopedOperand> m_true_constant;
mutable Optional<ScopedOperand> m_false_constant;

6
Libraries/LibJS/Bytecode/Interpreter.cpp
View file

@ -1458,13 +1458,13 @@ inline Value new_regexp(VM& vm, ParsedRegex const& parsed_regex, ByteString cons
}
// 13.3.8.1 https://tc39.es/ecma262/#sec-runtime-semantics-argumentlistevaluation
inline GC::MarkedVector<Value> argument_list_evaluation(VM& vm, Value arguments)
inline GC::RootVector<Value> argument_list_evaluation(VM& vm, Value arguments)
{
// Note: Any spreading and actual evaluation is handled in preceding opcodes
// Note: The spec uses the concept of a list, while we create a temporary array
// in the preceding opcodes, so we have to convert in a manner that is not
// visible to the user
GC::MarkedVector<Value> argument_values { vm.heap() };
GC::RootVector<Value> argument_values { vm.heap() };
auto& argument_array = arguments.as_array();
auto array_length = argument_array.indexed_properties().array_like_size();
@ -1541,7 +1541,7 @@ inline ThrowCompletionOr<GC::Ref<Object>> super_call_with_argument_array(VM& vm,
auto* func = get_super_constructor(vm);
// 4. Let argList be ? ArgumentListEvaluation of Arguments.
GC::MarkedVector<Value> arg_list { vm.heap() };
GC::RootVector<Value> arg_list { vm.heap() };
if (is_synthetic) {
VERIFY(argument_array.is_object() && is<Array>(argument_array.as_object()));
auto const& array_value = static_cast<Array const&>(argument_array.as_object());

42
Libraries/LibJS/Console.cpp
View file

@ -51,7 +51,7 @@ ThrowCompletionOr<Value> Console::assert_()
auto message = PrimitiveString::create(vm, "Assertion failed"_string);
// NOTE: Assemble `data` from the function arguments.
GC::MarkedVector<Value> data { vm.heap() };
GC::RootVector<Value> data { vm.heap() };
if (vm.argument_count() > 1) {
data.ensure_capacity(vm.argument_count() - 1);
for (size_t i = 1; i < vm.argument_count(); ++i) {
@ -143,7 +143,7 @@ ThrowCompletionOr<Value> Console::log()
}
// To [create table row] given tabularDataItem, rowIndex, list finalColumns, and optional list properties, perform the following steps:
static ThrowCompletionOr<GC::Ref<Object>> create_table_row(Realm& realm, Value row_index, Value tabular_data_item, GC::MarkedVector<Value>& final_columns, HashMap<PropertyKey, bool>& visited_columns, HashMap<PropertyKey, bool>& properties)
static ThrowCompletionOr<GC::Ref<Object>> create_table_row(Realm& realm, Value row_index, Value tabular_data_item, GC::RootVector<Value>& final_columns, HashMap<PropertyKey, bool>& visited_columns, HashMap<PropertyKey, bool>& properties)
{
auto& vm = realm.vm();
@ -264,10 +264,10 @@ ThrowCompletionOr<Value> Console::table()
}
// 1. Let `finalRows` be the new list, initially empty
GC::MarkedVector<Value> final_rows(vm.heap());
GC::RootVector<Value> final_rows(vm.heap());
// 2. Let `finalColumns` be the new list, initially empty
GC::MarkedVector<Value> final_columns(vm.heap());
GC::RootVector<Value> final_columns(vm.heap());
HashMap<PropertyKey, bool> visited_columns;
@ -327,7 +327,7 @@ ThrowCompletionOr<Value> Console::table()
TRY(final_data->set(vm.names.columns, table_cols, Object::ShouldThrowExceptions::No));
// 5.4. Perform `Printer("table", finalData)`
GC::MarkedVector<Value> args(vm.heap());
GC::RootVector<Value> args(vm.heap());
args.append(Value(final_data));
return m_client->printer(LogLevel::Table, args);
}
@ -389,7 +389,7 @@ ThrowCompletionOr<Value> Console::dir()
// 2. Perform Printer("dir", « object », options).
if (m_client) {
GC::MarkedVector<Value> printer_arguments { vm.heap() };
GC::RootVector<Value> printer_arguments { vm.heap() };
TRY_OR_THROW_OOM(vm, printer_arguments.try_append(object));
return m_client->printer(LogLevel::Dir, move(printer_arguments));
@ -429,7 +429,7 @@ ThrowCompletionOr<Value> Console::count()
auto concat = TRY_OR_THROW_OOM(vm, String::formatted("{}: {}", label, map.get(label).value()));
// 5. Perform Logger("count", « concat »).
GC::MarkedVector<Value> concat_as_vector { vm.heap() };
GC::RootVector<Value> concat_as_vector { vm.heap() };
concat_as_vector.append(PrimitiveString::create(vm, move(concat)));
if (m_client)
TRY(m_client->logger(LogLevel::Count, concat_as_vector));
@ -457,7 +457,7 @@ ThrowCompletionOr<Value> Console::count_reset()
// that the given label does not have an associated count.
auto message = TRY_OR_THROW_OOM(vm, String::formatted("\"{}\" doesn't have a count", label));
// 2. Perform Logger("countReset", « message »);
GC::MarkedVector<Value> message_as_vector { vm.heap() };
GC::RootVector<Value> message_as_vector { vm.heap() };
message_as_vector.append(PrimitiveString::create(vm, move(message)));
if (m_client)
TRY(m_client->logger(LogLevel::CountReset, message_as_vector));
@ -560,7 +560,7 @@ ThrowCompletionOr<Value> Console::time()
// a warning to the console indicating that a timer with label `label` has already been started.
if (m_timer_table.contains(label)) {
if (m_client) {
GC::MarkedVector<Value> timer_already_exists_warning_message_as_vector { vm.heap() };
GC::RootVector<Value> timer_already_exists_warning_message_as_vector { vm.heap() };
auto message = TRY_OR_THROW_OOM(vm, String::formatted("Timer '{}' already exists.", label));
timer_already_exists_warning_message_as_vector.append(PrimitiveString::create(vm, move(message)));
@ -591,7 +591,7 @@ ThrowCompletionOr<Value> Console::time_log()
// NOTE: Warn if the timer doesn't exist. Not part of the spec yet, but discussed here: https://github.com/whatwg/console/issues/134
if (maybe_start_time == m_timer_table.end()) {
if (m_client) {
GC::MarkedVector<Value> timer_does_not_exist_warning_message_as_vector { vm.heap() };
GC::RootVector<Value> timer_does_not_exist_warning_message_as_vector { vm.heap() };
auto message = TRY_OR_THROW_OOM(vm, String::formatted("Timer '{}' does not exist.", label));
timer_does_not_exist_warning_message_as_vector.append(PrimitiveString::create(vm, move(message)));
@ -609,7 +609,7 @@ ThrowCompletionOr<Value> Console::time_log()
auto concat = TRY_OR_THROW_OOM(vm, String::formatted("{}: {}", label, duration));
// 5. Prepend concat to data.
GC::MarkedVector<Value> data { vm.heap() };
GC::RootVector<Value> data { vm.heap() };
data.ensure_capacity(vm.argument_count());
data.append(PrimitiveString::create(vm, move(concat)));
for (size_t i = 1; i < vm.argument_count(); ++i)
@ -637,7 +637,7 @@ ThrowCompletionOr<Value> Console::time_end()
// NOTE: Warn if the timer doesn't exist. Not part of the spec yet, but discussed here: https://github.com/whatwg/console/issues/134
if (maybe_start_time == m_timer_table.end()) {
if (m_client) {
GC::MarkedVector<Value> timer_does_not_exist_warning_message_as_vector { vm.heap() };
GC::RootVector<Value> timer_does_not_exist_warning_message_as_vector { vm.heap() };
auto message = TRY_OR_THROW_OOM(vm, String::formatted("Timer '{}' does not exist.", label));
timer_does_not_exist_warning_message_as_vector.append(PrimitiveString::create(vm, move(message)));
@ -659,18 +659,18 @@ ThrowCompletionOr<Value> Console::time_end()
// 6. Perform Printer("timeEnd", « concat »).
if (m_client) {
GC::MarkedVector<Value> concat_as_vector { vm.heap() };
GC::RootVector<Value> concat_as_vector { vm.heap() };
concat_as_vector.append(PrimitiveString::create(vm, move(concat)));
TRY(m_client->printer(LogLevel::TimeEnd, move(concat_as_vector)));
}
return js_undefined();
}
GC::MarkedVector<Value> Console::vm_arguments()
GC::RootVector<Value> Console::vm_arguments()
{
auto& vm = realm().vm();
GC::MarkedVector<Value> arguments { vm.heap() };
GC::RootVector<Value> arguments { vm.heap() };
arguments.ensure_capacity(vm.argument_count());
for (size_t i = 0; i < vm.argument_count(); ++i) {
arguments.append(vm.argument(i));
@ -708,7 +708,7 @@ void Console::report_exception(JS::Error const& exception, bool in_promise) cons
m_client->report_exception(exception, in_promise);
}
ThrowCompletionOr<String> Console::value_vector_to_string(GC::MarkedVector<Value> const& values)
ThrowCompletionOr<String> Console::value_vector_to_string(GC::RootVector<Value> const& values)
{
auto& vm = realm().vm();
StringBuilder builder;
@ -737,7 +737,7 @@ void ConsoleClient::visit_edges(Visitor& visitor)
}
// 2.1. Logger(logLevel, args), https://console.spec.whatwg.org/#logger
ThrowCompletionOr<Value> ConsoleClient::logger(Console::LogLevel log_level, GC::MarkedVector<Value> const& args)
ThrowCompletionOr<Value> ConsoleClient::logger(Console::LogLevel log_level, GC::RootVector<Value> const& args)
{
auto& vm = m_console->realm().vm();
@ -753,7 +753,7 @@ ThrowCompletionOr<Value> ConsoleClient::logger(Console::LogLevel log_level, GC::
// 4. If rest is empty, perform Printer(logLevel, « first ») and return.
if (rest_size == 0) {
GC::MarkedVector<Value> first_as_vector { vm.heap() };
GC::RootVector<Value> first_as_vector { vm.heap() };
first_as_vector.append(first);
return printer(log_level, move(first_as_vector));
}
@ -769,7 +769,7 @@ ThrowCompletionOr<Value> ConsoleClient::logger(Console::LogLevel log_level, GC::
}
// 2.2. Formatter(args), https://console.spec.whatwg.org/#formatter
ThrowCompletionOr<GC::MarkedVector<Value>> ConsoleClient::formatter(GC::MarkedVector<Value> const& args)
ThrowCompletionOr<GC::RootVector<Value>> ConsoleClient::formatter(GC::RootVector<Value> const& args)
{
auto& realm = m_console->realm();
auto& vm = realm.vm();
@ -871,7 +871,7 @@ ThrowCompletionOr<GC::MarkedVector<Value>> ConsoleClient::formatter(GC::MarkedVe
}
// 7. Let result be a list containing target together with the elements of args starting from the third onward.
GC::MarkedVector<Value> result { vm.heap() };
GC::RootVector<Value> result { vm.heap() };
result.ensure_capacity(args.size() - 1);
result.empend(PrimitiveString::create(vm, move(target)));
for (size_t i = 2; i < args.size(); ++i)
@ -881,7 +881,7 @@ ThrowCompletionOr<GC::MarkedVector<Value>> ConsoleClient::formatter(GC::MarkedVe
return formatter(result);
}
ThrowCompletionOr<String> ConsoleClient::generically_format_values(GC::MarkedVector<Value> const& values)
ThrowCompletionOr<String> ConsoleClient::generically_format_values(GC::RootVector<Value> const& values)
{
AllocatingMemoryStream stream;
auto& vm = m_console->realm().vm();

12
Libraries/LibJS/Console.h
View file

@ -63,7 +63,7 @@ public:
Realm& realm() const { return m_realm; }
GC::MarkedVector<Value> vm_arguments();
GC::RootVector<Value> vm_arguments();
HashMap<String, unsigned>& counters() { return m_counters; }
HashMap<String, unsigned> const& counters() const { return m_counters; }
@ -95,7 +95,7 @@ private:
virtual void visit_edges(Visitor&) override;
ThrowCompletionOr<String> value_vector_to_string(GC::MarkedVector<Value> const&);
ThrowCompletionOr<String> value_vector_to_string(GC::RootVector<Value> const&);
GC::Ref<Realm> m_realm;
GC::Ptr<ConsoleClient> m_client;
@ -110,10 +110,10 @@ class ConsoleClient : public Cell {
GC_DECLARE_ALLOCATOR(ConsoleClient);
public:
using PrinterArguments = Variant<Console::Group, Console::Trace, GC::MarkedVector<Value>>;
using PrinterArguments = Variant<Console::Group, Console::Trace, GC::RootVector<Value>>;
ThrowCompletionOr<Value> logger(Console::LogLevel log_level, GC::MarkedVector<Value> const& args);
ThrowCompletionOr<GC::MarkedVector<Value>> formatter(GC::MarkedVector<Value> const& args);
ThrowCompletionOr<Value> logger(Console::LogLevel log_level, GC::RootVector<Value> const& args);
ThrowCompletionOr<GC::RootVector<Value>> formatter(GC::RootVector<Value> const& args);
virtual ThrowCompletionOr<Value> printer(Console::LogLevel log_level, PrinterArguments) = 0;
virtual void add_css_style_to_current_message(StringView) { }
@ -122,7 +122,7 @@ public:
virtual void clear() = 0;
virtual void end_group() = 0;
ThrowCompletionOr<String> generically_format_values(GC::MarkedVector<Value> const&);
ThrowCompletionOr<String> generically_format_values(GC::RootVector<Value> const&);
protected:
explicit ConsoleClient(Console&);

4
Libraries/LibJS/Runtime/AbstractOperations.cpp
View file

@ -97,7 +97,7 @@ ThrowCompletionOr<size_t> length_of_array_like(VM& vm, Object const& object)
}
// 7.3.20 CreateListFromArrayLike ( obj [ , elementTypes ] ), https://tc39.es/ecma262/#sec-createlistfromarraylike
ThrowCompletionOr<GC::MarkedVector<Value>> create_list_from_array_like(VM& vm, Value value, Function<ThrowCompletionOr<void>(Value)> check_value)
ThrowCompletionOr<GC::RootVector<Value>> create_list_from_array_like(VM& vm, Value value, Function<ThrowCompletionOr<void>(Value)> check_value)
{
// 1. If elementTypes is not present, set elementTypes to « Undefined, Null, Boolean, String, Symbol, Number, BigInt, Object ».
@ -111,7 +111,7 @@ ThrowCompletionOr<GC::MarkedVector<Value>> create_list_from_array_like(VM& vm, V
auto length = TRY(length_of_array_like(vm, array_like));
// 4. Let list be a new empty List.
auto list = GC::MarkedVector<Value> { vm.heap() };
auto list = GC::RootVector<Value> { vm.heap() };
list.ensure_capacity(length);
// 5. Let index be 0.

6
Libraries/LibJS/Runtime/AbstractOperations.h
View file

@ -9,7 +9,7 @@
#include <AK/Concepts.h>
#include <AK/Forward.h>
#include <LibCrypto/Forward.h>
#include <LibGC/MarkedVector.h>
#include <LibGC/RootVector.h>
#include <LibJS/Forward.h>
#include <LibJS/Runtime/CanonicalIndex.h>
#include <LibJS/Runtime/FunctionObject.h>
@ -34,7 +34,7 @@ ThrowCompletionOr<Value> call_impl(VM&, Value function, Value this_value, Readon
ThrowCompletionOr<Value> call_impl(VM&, FunctionObject& function, Value this_value, ReadonlySpan<Value> arguments = {});
ThrowCompletionOr<GC::Ref<Object>> construct_impl(VM&, FunctionObject&, ReadonlySpan<Value> arguments = {}, FunctionObject* new_target = nullptr);
ThrowCompletionOr<size_t> length_of_array_like(VM&, Object const&);
ThrowCompletionOr<GC::MarkedVector<Value>> create_list_from_array_like(VM&, Value, Function<ThrowCompletionOr<void>(Value)> = {});
ThrowCompletionOr<GC::RootVector<Value>> create_list_from_array_like(VM&, Value, Function<ThrowCompletionOr<void>(Value)> = {});
ThrowCompletionOr<FunctionObject*> species_constructor(VM&, Object const&, FunctionObject& default_constructor);
ThrowCompletionOr<Realm*> get_function_realm(VM&, FunctionObject const&);
ThrowCompletionOr<void> initialize_bound_name(VM&, DeprecatedFlyString const&, Value, Environment*);
@ -199,7 +199,7 @@ void add_value_to_keyed_group(VM& vm, GroupsType& groups, KeyType key, Value val
}
// 2. Let group be the Record { [[Key]]: key, [[Elements]]: « value » }.
GC::MarkedVector<Value> new_elements { vm.heap() };
GC::RootVector<Value> new_elements { vm.heap() };
new_elements.append(value);
// 3. Append group as the last element of groups.

6
Libraries/LibJS/Runtime/Array.cpp
View file

@ -161,10 +161,10 @@ ThrowCompletionOr<bool> Array::set_length(PropertyDescriptor const& property_des
}
// 23.1.3.30.1 SortIndexedProperties ( obj, len, SortCompare, holes ), https://tc39.es/ecma262/#sec-sortindexedproperties
ThrowCompletionOr<GC::MarkedVector<Value>> sort_indexed_properties(VM& vm, Object const& object, size_t length, Function<ThrowCompletionOr<double>(Value, Value)> const& sort_compare, Holes holes)
ThrowCompletionOr<GC::RootVector<Value>> sort_indexed_properties(VM& vm, Object const& object, size_t length, Function<ThrowCompletionOr<double>(Value, Value)> const& sort_compare, Holes holes)
{
// 1. Let items be a new empty List.
auto items = GC::MarkedVector<Value> { vm.heap() };
auto items = GC::RootVector<Value> { vm.heap() };
// 2. Let k be 0.
// 3. Repeat, while k < len,
@ -330,7 +330,7 @@ ThrowCompletionOr<bool> Array::internal_delete(PropertyKey const& property_key)
}
// NON-STANDARD: Used to inject the ephemeral length property's key
ThrowCompletionOr<GC::MarkedVector<Value>> Array::internal_own_property_keys() const
ThrowCompletionOr<GC::RootVector<Value>> Array::internal_own_property_keys() const
{
auto& vm = this->vm();
auto keys = TRY(Object::internal_own_property_keys());

6
Libraries/LibJS/Runtime/Array.h
View file

@ -37,7 +37,7 @@ public:
template<typename T>
static GC::Ref<Array> create_from(Realm& realm, ReadonlySpan<T> elements, Function<Value(T const&)> map_fn)
{
auto values = GC::MarkedVector<Value> { realm.heap() };
auto values = GC::RootVector<Value> { realm.heap() };
values.ensure_capacity(elements.size());
for (auto const& element : elements)
values.append(map_fn(element));
@ -50,7 +50,7 @@ public:
virtual ThrowCompletionOr<Optional<PropertyDescriptor>> internal_get_own_property(PropertyKey const&) const override final;
virtual ThrowCompletionOr<bool> internal_define_own_property(PropertyKey const&, PropertyDescriptor const&, Optional<PropertyDescriptor>* precomputed_get_own_property = nullptr) override final;
virtual ThrowCompletionOr<bool> internal_delete(PropertyKey const&) override;
virtual ThrowCompletionOr<GC::MarkedVector<Value>> internal_own_property_keys() const override final;
virtual ThrowCompletionOr<GC::RootVector<Value>> internal_own_property_keys() const override final;
[[nodiscard]] bool length_is_writable() const { return m_length_writable; }
@ -68,7 +68,7 @@ enum class Holes {
ReadThroughHoles,
};
ThrowCompletionOr<GC::MarkedVector<Value>> sort_indexed_properties(VM&, Object const&, size_t length, Function<ThrowCompletionOr<double>(Value, Value)> const& sort_compare, Holes holes);
ThrowCompletionOr<GC::RootVector<Value>> sort_indexed_properties(VM&, Object const&, size_t length, Function<ThrowCompletionOr<double>(Value, Value)> const& sort_compare, Holes holes);
ThrowCompletionOr<double> compare_array_elements(VM&, Value x, Value y, FunctionObject* comparefn);
}

6
Libraries/LibJS/Runtime/ArrayPrototype.cpp
View file

@ -1339,15 +1339,15 @@ JS_DEFINE_NATIVE_FUNCTION(ArrayPrototype::some)
return Value(false);
}
ThrowCompletionOr<void> array_merge_sort(VM& vm, Function<ThrowCompletionOr<double>(Value, Value)> const& compare_func, GC::MarkedVector<Value>& arr_to_sort)
ThrowCompletionOr<void> array_merge_sort(VM& vm, Function<ThrowCompletionOr<double>(Value, Value)> const& compare_func, GC::RootVector<Value>& arr_to_sort)
{
// FIXME: it would probably be better to switch to insertion sort for small arrays for
// better performance
if (arr_to_sort.size() <= 1)
return {};
GC::MarkedVector<Value> left(vm.heap());
GC::MarkedVector<Value> right(vm.heap());
GC::RootVector<Value> left(vm.heap());
GC::RootVector<Value> right(vm.heap());
left.ensure_capacity(arr_to_sort.size() / 2);
right.ensure_capacity(arr_to_sort.size() / 2 + (arr_to_sort.size() & 1));

2
Libraries/LibJS/Runtime/ArrayPrototype.h
View file

@ -64,6 +64,6 @@ private:
JS_DECLARE_NATIVE_FUNCTION(with);
};
ThrowCompletionOr<void> array_merge_sort(VM&, Function<ThrowCompletionOr<double>(Value, Value)> const& compare_func, GC::MarkedVector<Value>& arr_to_sort);
ThrowCompletionOr<void> array_merge_sort(VM&, Function<ThrowCompletionOr<double>(Value, Value)> const& compare_func, GC::RootVector<Value>& arr_to_sort);
}

2
Libraries/LibJS/Runtime/BoundFunction.cpp
View file

@ -83,7 +83,7 @@ ThrowCompletionOr<GC::Ref<Object>> BoundFunction::internal_construct(ReadonlySpa
auto& bound_args = m_bound_arguments;
// 4. Let args be the list-concatenation of boundArgs and argumentsList.
auto args = GC::MarkedVector<Value> { heap() };
auto args = GC::RootVector<Value> { heap() };
args.extend(bound_args);
args.append(arguments_list.data(), arguments_list.size());

2
Libraries/LibJS/Runtime/FinalizationRegistry.cpp
View file

@ -79,7 +79,7 @@ ThrowCompletionOr<void> FinalizationRegistry::cleanup(GC::Ptr<JobCallback> callb
continue;
// b. Remove cell from finalizationRegistry.[[Cells]].
GC::MarkedVector<Value> arguments(vm.heap());
GC::RootVector<Value> arguments(vm.heap());
arguments.append(it->held_value);
it.remove(m_records);

2
Libraries/LibJS/Runtime/FunctionPrototype.cpp
View file

@ -7,7 +7,7 @@
#include <AK/Function.h>
#include <AK/StringBuilder.h>
#include <AK/TypeCasts.h>
#include <LibGC/MarkedVector.h>
#include <LibGC/RootVector.h>
#include <LibJS/Runtime/AbstractOperations.h>
#include <LibJS/Runtime/BoundFunction.h>
#include <LibJS/Runtime/ECMAScriptFunctionObject.h>

4
Libraries/LibJS/Runtime/GlobalObject.h
View file

@ -52,12 +52,12 @@ template<typename... Args>
[[nodiscard]] ALWAYS_INLINE ThrowCompletionOr<Value> Value::invoke(VM& vm, PropertyKey const& property_key, Args... args)
{
if constexpr (sizeof...(Args) > 0) {
GC::MarkedVector<Value> arglist { vm.heap() };
GC::RootVector<Value> arglist { vm.heap() };
(..., arglist.append(move(args)));
return invoke_internal(vm, property_key, move(arglist));
}
return invoke_internal(vm, property_key, Optional<GC::MarkedVector<Value>> {});
return invoke_internal(vm, property_key, Optional<GC::RootVector<Value>> {});
}
}

2
Libraries/LibJS/Runtime/Intl/Intl.cpp
View file

@ -72,7 +72,7 @@ JS_DEFINE_NATIVE_FUNCTION(Intl::get_canonical_locales)
// 1. Let ll be ? CanonicalizeLocaleList(locales).
auto locale_list = TRY(canonicalize_locale_list(vm, locales));
GC::MarkedVector<Value> marked_locale_list { vm.heap() };
GC::RootVector<Value> marked_locale_list { vm.heap() };
marked_locale_list.ensure_capacity(locale_list.size());
for (auto& locale : locale_list)

2
Libraries/LibJS/Runtime/Intl/PluralRulesPrototype.cpp
View file

@ -4,7 +4,7 @@
* SPDX-License-Identifier: BSD-2-Clause
*/
#include <LibGC/MarkedVector.h>
#include <LibGC/RootVector.h>
#include <LibJS/Runtime/Array.h>
#include <LibJS/Runtime/GlobalObject.h>
#include <LibJS/Runtime/Intl/PluralRulesPrototype.h>

4
Libraries/LibJS/Runtime/Iterator.cpp
View file

@ -345,10 +345,10 @@ GC::Ref<Object> create_iterator_result_object(VM& vm, Value value, bool done)
}
// 7.4.16 IteratorToList ( iteratorRecord ), https://tc39.es/ecma262/#sec-iteratortolist
ThrowCompletionOr<GC::MarkedVector<Value>> iterator_to_list(VM& vm, IteratorRecord& iterator_record)
ThrowCompletionOr<GC::RootVector<Value>> iterator_to_list(VM& vm, IteratorRecord& iterator_record)
{
// 1. Let values be a new empty List.
GC::MarkedVector<Value> values(vm.heap());
GC::RootVector<Value> values(vm.heap());
// 2. Repeat,
while (true) {

2
Libraries/LibJS/Runtime/Iterator.h
View file

@ -82,7 +82,7 @@ ThrowCompletionOr<Optional<Value>> iterator_step_value(VM&, IteratorRecord&);
Completion iterator_close(VM&, IteratorRecord const&, Completion);
Completion async_iterator_close(VM&, IteratorRecord const&, Completion);
GC::Ref<Object> create_iterator_result_object(VM&, Value, bool done);
ThrowCompletionOr<GC::MarkedVector<Value>> iterator_to_list(VM&, IteratorRecord&);
ThrowCompletionOr<GC::RootVector<Value>> iterator_to_list(VM&, IteratorRecord&);
ThrowCompletionOr<void> setter_that_ignores_prototype_properties(VM&, Value this_, Object const& home, PropertyKey const& property, Value value);
using IteratorValueCallback = Function<Optional<Completion>(Value)>;

2
Libraries/LibJS/Runtime/IteratorPrototype.cpp
View file

@ -717,7 +717,7 @@ JS_DEFINE_NATIVE_FUNCTION(IteratorPrototype::to_array)
auto iterated = TRY(get_iterator_direct(vm, object));
// 4. Let items be a new empty List.
GC::MarkedVector<Value> items(realm.heap());
GC::RootVector<Value> items(realm.heap());
// 5. Repeat,
while (true) {

2
Libraries/LibJS/Runtime/MapConstructor.cpp
View file

@ -94,7 +94,7 @@ JS_DEFINE_NATIVE_FUNCTION(MapConstructor::group_by)
};
// 1. Let groups be ? GroupBy(items, callbackfn, zero).
auto groups = TRY((JS::group_by<OrderedHashMap<GC::Root<Value>, GC::MarkedVector<Value>, KeyedGroupTraits>, void>(vm, items, callback_function)));
auto groups = TRY((JS::group_by<OrderedHashMap<GC::Root<Value>, GC::RootVector<Value>, KeyedGroupTraits>, void>(vm, items, callback_function)));
// 2. Let map be ! Construct(%Map%).
auto map = Map::create(realm);

4
Libraries/LibJS/Runtime/ModuleNamespaceObject.cpp
View file

@ -210,11 +210,11 @@ ThrowCompletionOr<bool> ModuleNamespaceObject::internal_delete(PropertyKey const
}
// 10.4.6.11 [[OwnPropertyKeys]] ( ), https://tc39.es/ecma262/#sec-module-namespace-exotic-objects-ownpropertykeys
ThrowCompletionOr<GC::MarkedVector<Value>> ModuleNamespaceObject::internal_own_property_keys() const
ThrowCompletionOr<GC::RootVector<Value>> ModuleNamespaceObject::internal_own_property_keys() const
{
// 1. Let exports be O.[[Exports]].
// NOTE: We only add the exports after we know the size of symbolKeys
GC::MarkedVector<Value> exports { vm().heap() };
GC::RootVector<Value> exports { vm().heap() };
// 2. Let symbolKeys be OrdinaryOwnPropertyKeys(O).
auto symbol_keys = MUST(Object::internal_own_property_keys());

2
Libraries/LibJS/Runtime/ModuleNamespaceObject.h
View file

@ -29,7 +29,7 @@ public:
virtual ThrowCompletionOr<Value> internal_get(PropertyKey const&, Value receiver, CacheablePropertyMetadata* = nullptr, PropertyLookupPhase = PropertyLookupPhase::OwnProperty) const override;
virtual ThrowCompletionOr<bool> internal_set(PropertyKey const&, Value value, Value receiver, CacheablePropertyMetadata*) override;
virtual ThrowCompletionOr<bool> internal_delete(PropertyKey const&) override;
virtual ThrowCompletionOr<GC::MarkedVector<Value>> internal_own_property_keys() const override;
virtual ThrowCompletionOr<GC::RootVector<Value>> internal_own_property_keys() const override;
virtual void initialize(Realm&) override;
private:

8
Libraries/LibJS/Runtime/Object.cpp
View file

@ -371,7 +371,7 @@ ThrowCompletionOr<bool> Object::test_integrity_level(IntegrityLevel level) const
}
// 7.3.24 EnumerableOwnPropertyNames ( O, kind ), https://tc39.es/ecma262/#sec-enumerableownpropertynames
ThrowCompletionOr<GC::MarkedVector<Value>> Object::enumerable_own_property_names(PropertyKind kind) const
ThrowCompletionOr<GC::RootVector<Value>> Object::enumerable_own_property_names(PropertyKind kind) const
{
// NOTE: This has been flattened for readability, so some `else` branches in the
// spec text have been replaced with `continue`s in the loop below.
@ -383,7 +383,7 @@ ThrowCompletionOr<GC::MarkedVector<Value>> Object::enumerable_own_property_names
auto own_keys = TRY(internal_own_property_keys());
// 2. Let properties be a new empty List.
auto properties = GC::MarkedVector<Value> { heap() };
auto properties = GC::RootVector<Value> { heap() };
// 3. For each element key of ownKeys, do
for (auto& key : own_keys) {
@ -1070,12 +1070,12 @@ ThrowCompletionOr<bool> Object::internal_delete(PropertyKey const& property_key)
}
// 10.1.11 [[OwnPropertyKeys]] ( ), https://tc39.es/ecma262/#sec-ordinary-object-internal-methods-and-internal-slots-ownpropertykeys
ThrowCompletionOr<GC::MarkedVector<Value>> Object::internal_own_property_keys() const
ThrowCompletionOr<GC::RootVector<Value>> Object::internal_own_property_keys() const
{
auto& vm = this->vm();
// 1. Let keys be a new empty List.
GC::MarkedVector<Value> keys { heap() };
GC::RootVector<Value> keys { heap() };
// 2. For each own property key P of O such that P is an array index, in ascending numeric index order, do
for (auto& entry : m_indexed_properties) {

6
Libraries/LibJS/Runtime/Object.h
View file

@ -10,7 +10,7 @@
#include <AK/Badge.h>
#include <AK/StringView.h>
#include <LibGC/CellAllocator.h>
#include <LibGC/MarkedVector.h>
#include <LibGC/RootVector.h>
#include <LibJS/Forward.h>
#include <LibJS/Heap/Cell.h>
#include <LibJS/Runtime/Completion.h>
@ -118,7 +118,7 @@ public:
ThrowCompletionOr<bool> has_own_property(PropertyKey const&) const;
ThrowCompletionOr<bool> set_integrity_level(IntegrityLevel);
ThrowCompletionOr<bool> test_integrity_level(IntegrityLevel) const;
ThrowCompletionOr<GC::MarkedVector<Value>> enumerable_own_property_names(PropertyKind kind) const;
ThrowCompletionOr<GC::RootVector<Value>> enumerable_own_property_names(PropertyKind kind) const;
ThrowCompletionOr<void> copy_data_properties(VM&, Value source, HashTable<PropertyKey> const& excluded_keys, HashTable<JS::Value> const& excluded_values = {});
ThrowCompletionOr<GC::Ref<Object>> snapshot_own_properties(VM&, GC::Ptr<Object> prototype, HashTable<PropertyKey> const& excluded_keys = {}, HashTable<Value> const& excluded_values = {});
@ -146,7 +146,7 @@ public:
virtual ThrowCompletionOr<Value> internal_get(PropertyKey const&, Value receiver, CacheablePropertyMetadata* = nullptr, PropertyLookupPhase = PropertyLookupPhase::OwnProperty) const;
virtual ThrowCompletionOr<bool> internal_set(PropertyKey const&, Value value, Value receiver, CacheablePropertyMetadata* = nullptr);
virtual ThrowCompletionOr<bool> internal_delete(PropertyKey const&);
virtual ThrowCompletionOr<GC::MarkedVector<Value>> internal_own_property_keys() const;
virtual ThrowCompletionOr<GC::RootVector<Value>> internal_own_property_keys() const;
// NOTE: Any subclass of Object that overrides property access slots ([[Get]], [[Set]] etc)
// to customize access to indexed properties (properties where the name is a positive integer)

6
Libraries/LibJS/Runtime/ObjectConstructor.cpp
View file

@ -93,7 +93,7 @@ enum class GetOwnPropertyKeysType {
};
// 20.1.2.11.1 GetOwnPropertyKeys ( O, type ), https://tc39.es/ecma262/#sec-getownpropertykeys
static ThrowCompletionOr<GC::MarkedVector<Value>> get_own_property_keys(VM& vm, Value value, GetOwnPropertyKeysType type)
static ThrowCompletionOr<GC::RootVector<Value>> get_own_property_keys(VM& vm, Value value, GetOwnPropertyKeysType type)
{
// 1. Let obj be ? ToObject(O).
auto object = TRY(value.to_object(vm));
@ -102,7 +102,7 @@ static ThrowCompletionOr<GC::MarkedVector<Value>> get_own_property_keys(VM& vm,
auto keys = TRY(object->internal_own_property_keys());
// 3. Let nameList be a new empty List.
auto name_list = GC::MarkedVector<Value> { vm.heap() };
auto name_list = GC::RootVector<Value> { vm.heap() };
// 4. For each element nextKey of keys, do
for (auto& next_key : keys) {
@ -382,7 +382,7 @@ JS_DEFINE_NATIVE_FUNCTION(ObjectConstructor::group_by)
auto callback_function = vm.argument(1);
// 1. Let groups be ? GroupBy(items, callbackfn, property).
auto groups = TRY((JS::group_by<OrderedHashMap<PropertyKey, GC::MarkedVector<Value>>, PropertyKey>(vm, items, callback_function)));
auto groups = TRY((JS::group_by<OrderedHashMap<PropertyKey, GC::RootVector<Value>>, PropertyKey>(vm, items, callback_function)));
// 2. Let obj be OrdinaryObjectCreate(null).
auto object = Object::create(realm, nullptr);

8
Libraries/LibJS/Runtime/ProxyObject.cpp
View file

@ -681,7 +681,7 @@ ThrowCompletionOr<bool> ProxyObject::internal_delete(PropertyKey const& property
}
// 10.5.11 [[OwnPropertyKeys]] ( ), https://tc39.es/ecma262/#sec-proxy-object-internal-methods-and-internal-slots-ownpropertykeys
ThrowCompletionOr<GC::MarkedVector<Value>> ProxyObject::internal_own_property_keys() const
ThrowCompletionOr<GC::RootVector<Value>> ProxyObject::internal_own_property_keys() const
{
LIMIT_PROXY_RECURSION_DEPTH();
@ -732,10 +732,10 @@ ThrowCompletionOr<GC::MarkedVector<Value>> ProxyObject::internal_own_property_ke
// 13. Assert: targetKeys contains no duplicate entries.
// 14. Let targetConfigurableKeys be a new empty List.
auto target_configurable_keys = GC::MarkedVector<Value> { heap() };
auto target_configurable_keys = GC::RootVector<Value> { heap() };
// 15. Let targetNonconfigurableKeys be a new empty List.
auto target_nonconfigurable_keys = GC::MarkedVector<Value> { heap() };
auto target_nonconfigurable_keys = GC::RootVector<Value> { heap() };
// 16. For each element key of targetKeys, do
for (auto& key : target_keys) {
@ -763,7 +763,7 @@ ThrowCompletionOr<GC::MarkedVector<Value>> ProxyObject::internal_own_property_ke
}
// 18. Let uncheckedResultKeys be a List whose elements are the elements of trapResult.
auto unchecked_result_keys = GC::MarkedVector<Value> { heap() };
auto unchecked_result_keys = GC::RootVector<Value> { heap() };
unchecked_result_keys.extend(trap_result);
// 19. For each element key of targetNonconfigurableKeys, do

2
Libraries/LibJS/Runtime/ProxyObject.h
View file

@ -42,7 +42,7 @@ public:
virtual ThrowCompletionOr<Value> internal_get(PropertyKey const&, Value receiver, CacheablePropertyMetadata*, PropertyLookupPhase) const override;
virtual ThrowCompletionOr<bool> internal_set(PropertyKey const&, Value value, Value receiver, CacheablePropertyMetadata*) override;
virtual ThrowCompletionOr<bool> internal_delete(PropertyKey const&) override;
virtual ThrowCompletionOr<GC::MarkedVector<Value>> internal_own_property_keys() const override;
virtual ThrowCompletionOr<GC::RootVector<Value>> internal_own_property_keys() const override;
virtual ThrowCompletionOr<Value> internal_call(Value this_argument, ReadonlySpan<Value> arguments_list) override;
virtual ThrowCompletionOr<GC::Ref<Object>> internal_construct(ReadonlySpan<Value> arguments_list, FunctionObject& new_target) override;

6
Libraries/LibJS/Runtime/RegExpPrototype.cpp
View file

@ -669,7 +669,7 @@ JS_DEFINE_NATIVE_FUNCTION(RegExpPrototype::symbol_replace)
}
// 10. Let results be a new empty List.
GC::MarkedVector<Object*> results(vm.heap());
GC::RootVector<Object*> results(vm.heap());
// 11. Let done be false.
// 12. Repeat, while done is false,
@ -735,7 +735,7 @@ JS_DEFINE_NATIVE_FUNCTION(RegExpPrototype::symbol_replace)
position = clamp(position, static_cast<double>(0), static_cast<double>(string.length_in_code_units()));
// g. Let captures be a new empty List.
GC::MarkedVector<Value> captures(vm.heap());
GC::RootVector<Value> captures(vm.heap());
// h. Let n be 1.
// i. Repeat, while n ≤ nCaptures,
@ -764,7 +764,7 @@ JS_DEFINE_NATIVE_FUNCTION(RegExpPrototype::symbol_replace)
// k. If functionalReplace is true, then
if (replace_value.is_function()) {
// i. Let replacerArgs be the list-concatenation of « matched », captures, and « 𝔽(position), S ».
GC::MarkedVector<Value> replacer_args(vm.heap());
GC::RootVector<Value> replacer_args(vm.heap());
replacer_args.append(PrimitiveString::create(vm, move(matched)));
replacer_args.extend(move(captures));
replacer_args.append(Value(position));

4
Libraries/LibJS/Runtime/StringObject.cpp
View file

@ -128,12 +128,12 @@ ThrowCompletionOr<bool> StringObject::internal_define_own_property(PropertyKey c
}
// 10.4.3.3 [[OwnPropertyKeys]] ( ), https://tc39.es/ecma262/#sec-string-exotic-objects-ownpropertykeys
ThrowCompletionOr<GC::MarkedVector<Value>> StringObject::internal_own_property_keys() const
ThrowCompletionOr<GC::RootVector<Value>> StringObject::internal_own_property_keys() const
{
auto& vm = this->vm();
// 1. Let keys be a new empty List.
auto keys = GC::MarkedVector<Value> { heap() };
auto keys = GC::RootVector<Value> { heap() };
// 2. Let str be O.[[StringData]].
auto str = m_string->utf16_string_view();

2
Libraries/LibJS/Runtime/StringObject.h
View file

@ -29,7 +29,7 @@ protected:
private:
virtual ThrowCompletionOr<Optional<PropertyDescriptor>> internal_get_own_property(PropertyKey const&) const override;
virtual ThrowCompletionOr<bool> internal_define_own_property(PropertyKey const&, PropertyDescriptor const&, Optional<PropertyDescriptor>* precomputed_get_own_property = nullptr) override;
virtual ThrowCompletionOr<GC::MarkedVector<Value>> internal_own_property_keys() const override;
virtual ThrowCompletionOr<GC::RootVector<Value>> internal_own_property_keys() const override;
virtual bool is_string_object() const final { return true; }
virtual void visit_edges(Visitor&) override;

6
Libraries/LibJS/Runtime/TypedArray.cpp
View file

@ -288,7 +288,7 @@ static ThrowCompletionOr<void> initialize_typed_array_from_array_like(VM& vm, Ty
// 23.2.5.1.4 InitializeTypedArrayFromList, https://tc39.es/ecma262/#sec-initializetypedarrayfromlist
template<typename T>
static ThrowCompletionOr<void> initialize_typed_array_from_list(VM& vm, TypedArray<T>& typed_array, GC::MarkedVector<Value> const& list)
static ThrowCompletionOr<void> initialize_typed_array_from_list(VM& vm, TypedArray<T>& typed_array, GC::RootVector<Value> const& list)
{
// 1. Let len be the number of elements in values.
auto length = list.size();
@ -315,7 +315,7 @@ static ThrowCompletionOr<void> initialize_typed_array_from_list(VM& vm, TypedArr
}
// 23.2.4.2 TypedArrayCreate ( constructor, argumentList ), https://tc39.es/ecma262/#typedarray-create
ThrowCompletionOr<TypedArrayBase*> typed_array_create(VM& vm, FunctionObject& constructor, GC::MarkedVector<Value> arguments)
ThrowCompletionOr<TypedArrayBase*> typed_array_create(VM& vm, FunctionObject& constructor, GC::RootVector<Value> arguments)
{
Optional<double> first_argument;
if (arguments.size() == 1 && arguments[0].is_number())
@ -346,7 +346,7 @@ ThrowCompletionOr<TypedArrayBase*> typed_array_create(VM& vm, FunctionObject& co
}
// 23.2.4.3 TypedArrayCreateSameType ( exemplar, argumentList ), https://tc39.es/ecma262/#sec-typedarray-create-same-type
ThrowCompletionOr<TypedArrayBase*> typed_array_create_same_type(VM& vm, TypedArrayBase const& exemplar, GC::MarkedVector<Value> arguments)
ThrowCompletionOr<TypedArrayBase*> typed_array_create_same_type(VM& vm, TypedArrayBase const& exemplar, GC::RootVector<Value> arguments)
{
auto& realm = *vm.current_realm();

8
Libraries/LibJS/Runtime/TypedArray.h
View file

@ -413,7 +413,7 @@ public:
}
// 10.4.5.8 [[OwnPropertyKeys]] ( ), https://tc39.es/ecma262/#sec-integer-indexed-exotic-objects-ownpropertykeys
virtual ThrowCompletionOr<GC::MarkedVector<Value>> internal_own_property_keys() const override
virtual ThrowCompletionOr<GC::RootVector<Value>> internal_own_property_keys() const override
{
auto& vm = this->vm();
@ -421,7 +421,7 @@ public:
auto typed_array_record = make_typed_array_with_buffer_witness_record(*this, ArrayBuffer::Order::SeqCst);
// 2. Let keys be a new empty List.
auto keys = GC::MarkedVector<Value> { heap() };
auto keys = GC::RootVector<Value> { heap() };
// 3. If IsTypedArrayOutOfBounds(taRecord) is false, then
if (!is_typed_array_out_of_bounds(typed_array_record)) {
@ -511,8 +511,8 @@ protected:
};
ThrowCompletionOr<TypedArrayBase*> typed_array_from(VM&, Value);
ThrowCompletionOr<TypedArrayBase*> typed_array_create(VM&, FunctionObject& constructor, GC::MarkedVector<Value> arguments);
ThrowCompletionOr<TypedArrayBase*> typed_array_create_same_type(VM&, TypedArrayBase const& exemplar, GC::MarkedVector<Value> arguments);
ThrowCompletionOr<TypedArrayBase*> typed_array_create(VM&, FunctionObject& constructor, GC::RootVector<Value> arguments);
ThrowCompletionOr<TypedArrayBase*> typed_array_create_same_type(VM&, TypedArrayBase const& exemplar, GC::RootVector<Value> arguments);
ThrowCompletionOr<TypedArrayWithBufferWitness> validate_typed_array(VM&, Object const&, ArrayBuffer::Order);
ThrowCompletionOr<double> compare_typed_array_elements(VM&, Value x, Value y, FunctionObject* comparefn);

6
Libraries/LibJS/Runtime/TypedArrayConstructor.cpp
View file

@ -92,7 +92,7 @@ JS_DEFINE_NATIVE_FUNCTION(TypedArrayConstructor::from)
auto length = values.size();
// c. Let targetObj be ? TypedArrayCreate(C, « 𝔽(len) »).
GC::MarkedVector<Value> arguments(vm.heap());
GC::RootVector<Value> arguments(vm.heap());
arguments.empend(length);
auto* target_object = TRY(typed_array_create(vm, constructor.as_function(), move(arguments)));
@ -139,7 +139,7 @@ JS_DEFINE_NATIVE_FUNCTION(TypedArrayConstructor::from)
auto length = TRY(length_of_array_like(vm, array_like));
// 10. Let targetObj be ? TypedArrayCreate(C, « 𝔽(len) »).
GC::MarkedVector<Value> arguments(vm.heap());
GC::RootVector<Value> arguments(vm.heap());
arguments.empend(length);
auto* target_object = TRY(typed_array_create(vm, constructor.as_function(), move(arguments)));
@ -188,7 +188,7 @@ JS_DEFINE_NATIVE_FUNCTION(TypedArrayConstructor::of)
return vm.throw_completion<TypeError>(ErrorType::NotAConstructor, constructor.to_string_without_side_effects());
// 4. Let newObj be ? TypedArrayCreate(C, « 𝔽(len) »).
GC::MarkedVector<Value> arguments(vm.heap());
GC::RootVector<Value> arguments(vm.heap());
arguments.append(Value(length));
auto* new_object = TRY(typed_array_create(vm, constructor.as_function(), move(arguments)));

18
Libraries/LibJS/Runtime/TypedArrayPrototype.cpp
View file

@ -92,7 +92,7 @@ static ThrowCompletionOr<GC::Ref<FunctionObject>> callback_from_args(VM& vm, Str
}
// 23.2.4.1 TypedArraySpeciesCreate ( exemplar, argumentList ), https://tc39.es/ecma262/#typedarray-species-create
static ThrowCompletionOr<TypedArrayBase*> typed_array_species_create(VM& vm, TypedArrayBase const& exemplar, GC::MarkedVector<Value> arguments)
static ThrowCompletionOr<TypedArrayBase*> typed_array_species_create(VM& vm, TypedArrayBase const& exemplar, GC::RootVector<Value> arguments)
{
auto& realm = *vm.current_realm();
@ -634,7 +634,7 @@ JS_DEFINE_NATIVE_FUNCTION(TypedArrayPrototype::filter)
auto callback_function = TRY(callback_from_args(vm, "filter"sv));
// 5. Let kept be a new empty List.
GC::MarkedVector<Value> kept { vm.heap() };
GC::RootVector<Value> kept { vm.heap() };
// 6. Let captured be 0.
size_t captured = 0;
@ -664,7 +664,7 @@ JS_DEFINE_NATIVE_FUNCTION(TypedArrayPrototype::filter)
}
// 9. Let A be ? TypedArraySpeciesCreate(O, « 𝔽(captured) »).
GC::MarkedVector<Value> arguments(vm.heap());
GC::RootVector<Value> arguments(vm.heap());
arguments.empend(captured);
auto* filter_array = TRY(typed_array_species_create(vm, *typed_array, move(arguments)));
@ -1186,7 +1186,7 @@ JS_DEFINE_NATIVE_FUNCTION(TypedArrayPrototype::map)
auto callback_function = TRY(callback_from_args(vm, "map"sv));
// 5. Let A be ? TypedArraySpeciesCreate(O, « 𝔽(len) »).
GC::MarkedVector<Value> arguments(vm.heap());
GC::RootVector<Value> arguments(vm.heap());
arguments.empend(length);
auto* array = TRY(typed_array_species_create(vm, *typed_array, move(arguments)));
@ -1660,7 +1660,7 @@ JS_DEFINE_NATIVE_FUNCTION(TypedArrayPrototype::slice)
auto count = max(final - k, 0);
// 13. Let A be ? TypedArraySpeciesCreate(O, « 𝔽(count) »).
GC::MarkedVector<Value> arguments(vm.heap());
GC::RootVector<Value> arguments(vm.heap());
arguments.empend(count);
auto* array = TRY(typed_array_species_create(vm, *typed_array, move(arguments)));
@ -1905,7 +1905,7 @@ JS_DEFINE_NATIVE_FUNCTION(TypedArrayPrototype::subarray)
return typed_array;
}
GC::MarkedVector<Value> arguments(vm.heap());
GC::RootVector<Value> arguments(vm.heap());
// 15. If O.[[ArrayLength]] is auto and end is undefined, then
if (typed_array->array_length().is_auto() && end.is_undefined()) {
@ -2013,7 +2013,7 @@ JS_DEFINE_NATIVE_FUNCTION(TypedArrayPrototype::to_reversed)
auto length = typed_array_length(typed_array_record);
// 4. Let A be ? TypedArrayCreateSameType(O, « 𝔽(length) »).
GC::MarkedVector<Value> arguments(vm.heap());
GC::RootVector<Value> arguments(vm.heap());
arguments.empend(length);
auto* array = TRY(typed_array_create_same_type(vm, *typed_array, move(arguments)));
@ -2058,7 +2058,7 @@ JS_DEFINE_NATIVE_FUNCTION(TypedArrayPrototype::to_sorted)
auto length = typed_array_length(typed_array_record);
// 5. Let A be ? TypedArrayCreateSameType(O, « 𝔽(len) »).
GC::MarkedVector<Value> arguments(vm.heap());
GC::RootVector<Value> arguments(vm.heap());
arguments.empend(length);
auto* array = TRY(typed_array_create_same_type(vm, *typed_array, move(arguments)));
@ -2138,7 +2138,7 @@ JS_DEFINE_NATIVE_FUNCTION(TypedArrayPrototype::with)
return vm.throw_completion<RangeError>(ErrorType::TypedArrayInvalidIntegerIndex, actual_index);
// 10. Let A be ? TypedArrayCreateSameType(O, « 𝔽(len) »).
GC::MarkedVector<Value> arguments(vm.heap());
GC::RootVector<Value> arguments(vm.heap());
arguments.empend(length);
auto* array = TRY(typed_array_create_same_type(vm, *typed_array, move(arguments)));

2
Libraries/LibJS/Runtime/VM.h
View file

@ -18,7 +18,7 @@
#include <LibCrypto/Forward.h>
#include <LibGC/Function.h>
#include <LibGC/Heap.h>
#include <LibGC/MarkedVector.h>
#include <LibGC/RootVector.h>
#include <LibJS/CyclicModule.h>
#include <LibJS/ModuleLoading.h>
#include <LibJS/Runtime/CommonPropertyNames.h>

2
Libraries/LibJS/Runtime/Value.cpp
View file

@ -2493,7 +2493,7 @@ ThrowCompletionOr<TriState> is_less_than(VM& vm, Value lhs, Value rhs, bool left
}
// 7.3.21 Invoke ( V, P [ , argumentsList ] ), https://tc39.es/ecma262/#sec-invoke
ThrowCompletionOr<Value> Value::invoke_internal(VM& vm, PropertyKey const& property_key, Optional<GC::MarkedVector<Value>> arguments)
ThrowCompletionOr<Value> Value::invoke_internal(VM& vm, PropertyKey const& property_key, Optional<GC::RootVector<Value>> arguments)
{
// 1. If argumentsList is not present, set argumentsList to a new empty List.

2
Libraries/LibJS/Runtime/Value.h
View file

@ -449,7 +449,7 @@ private:
}
}
[[nodiscard]] ThrowCompletionOr<Value> invoke_internal(VM&, PropertyKey const&, Optional<GC::MarkedVector<Value>> arguments);
[[nodiscard]] ThrowCompletionOr<Value> invoke_internal(VM&, PropertyKey const&, Optional<GC::RootVector<Value>> arguments);
ThrowCompletionOr<i32> to_i32_slow_case(VM&) const;

2
Libraries/LibJS/Runtime/WrappedFunction.cpp
View file

@ -99,7 +99,7 @@ ThrowCompletionOr<Value> ordinary_wrapped_function_call(WrappedFunction const& f
auto* target_realm = TRY(get_function_realm(vm, target));
// 6. Let wrappedArgs be a new empty List.
auto wrapped_args = GC::MarkedVector<Value> { vm.heap() };
auto wrapped_args = GC::RootVector<Value> { vm.heap() };
wrapped_args.ensure_capacity(arguments_list.size());
// 7. For each element arg of argumentsList, do