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

46 lines
1.7 KiB
C
Raw Normal View History

LibJS: Add the CreateMappedArgumentsObject abstract operation This patch adds a new ArgumentsObject class to represent what the spec calls "Arguments Exotic Objects" These are constructed by the new CreateMappedArgumentsObject when the `arguments` identifier is resolved in a callee context. The implementation is incomplete and doesn't yet support mapping of the parameter variables to the indexed properties of `arguments`.
2021-06-28 13:26:01 +02:00
/*
LibJS: Make mapped arguments objects way less allocation-happy By following the spec to the letter, our mapped arguments objects ended up with many extra GC allocations: - 1 extra Object for the internal [[ParameterMap]]. - 2 extra NativeFunctions for each mapped parameter accessor. - 1 extra Accessor to hold the aforementioned NativeFunctions. This patch removes all those allocations and lets ArgumentsObject model the desired behavior in custom C++ instead of using script primitives. 1.06x speedup on Speedometer's TodoMVC-jQuery.
2025-05-11 12:32:24 +02:00
* Copyright (c) 2021-2025, Andreas Kling <andreas@ladybird.org>
LibJS: Add the CreateMappedArgumentsObject abstract operation This patch adds a new ArgumentsObject class to represent what the spec calls "Arguments Exotic Objects" These are constructed by the new CreateMappedArgumentsObject when the `arguments` identifier is resolved in a callee context. The implementation is incomplete and doesn't yet support mapping of the parameter variables to the indexed properties of `arguments`.
2021-06-28 13:26:01 +02:00
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#pragma once
LibJS: Convert internal_get_own_property() to ThrowCompletionOr
2021-09-29 17:53:57 +01:00
#include <LibJS/Runtime/Completion.h>
LibJS: Finish implementing mapped arguments exotic objects :^) Now that the Object rewrite is in place, we have enough tools to implement the mapped `arguments` propreties according to spec. The basic mechanism is that the `arguments` object installs a hidden parameter mapping object that property accesses get filtered through. This is how accessing numeric properties on `arguments` are proxied to the named identifier in the function scope. When `arguments` is instantiated, getters and setters are created for all the numeric properties on the object that correspond to function arguments. These getters and setters can be deleted from the object. This is all pretty intricate, so refer to the spec for details. Note that the `arguments` object itself is still lazily instantiated on first access within a function. This is non-conforming, and we'll have to revisit this once we get around to improving function calls.
2021-06-28 21:19:25 +02:00
#include <LibJS/Runtime/Environment.h>
LibJS: Add the CreateMappedArgumentsObject abstract operation This patch adds a new ArgumentsObject class to represent what the spec calls "Arguments Exotic Objects" These are constructed by the new CreateMappedArgumentsObject when the `arguments` identifier is resolved in a callee context. The implementation is incomplete and doesn't yet support mapping of the parameter variables to the indexed properties of `arguments`.
2021-06-28 13:26:01 +02:00
#include <LibJS/Runtime/Object.h>
namespace JS {
LibJS: Enable EXPLICIT_SYMBOL_EXPORT
2025-06-28 21:39:13 -07:00
class JS_API ArgumentsObject final : public Object {
LibJS: Add the CreateMappedArgumentsObject abstract operation This patch adds a new ArgumentsObject class to represent what the spec calls "Arguments Exotic Objects" These are constructed by the new CreateMappedArgumentsObject when the `arguments` identifier is resolved in a callee context. The implementation is incomplete and doesn't yet support mapping of the parameter variables to the indexed properties of `arguments`.
2021-06-28 13:26:01 +02:00
JS_OBJECT(ArgumentsObject, Object);
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-15 04:01:23 +13:00
GC_DECLARE_ALLOCATOR(ArgumentsObject);
LibJS: Add the CreateMappedArgumentsObject abstract operation This patch adds a new ArgumentsObject class to represent what the spec calls "Arguments Exotic Objects" These are constructed by the new CreateMappedArgumentsObject when the `arguments` identifier is resolved in a callee context. The implementation is incomplete and doesn't yet support mapping of the parameter variables to the indexed properties of `arguments`.
2021-06-28 13:26:01 +02:00
public:
LibJS: Make Cell::initialize() return void Stop worrying about tiny OOMs. Work towards #20405
2023-08-07 08:41:28 +02:00
virtual void initialize(Realm&) override;
Libraries: Use default constructors/destructors in LibJS https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#cother-other-default-operation-rules "The compiler is more likely to get the default semantics right and you cannot implement these functions better than the compiler."
2022-03-14 10:25:06 -06:00
virtual ~ArgumentsObject() override = default;
LibJS: Finish implementing mapped arguments exotic objects :^) Now that the Object rewrite is in place, we have enough tools to implement the mapped `arguments` propreties according to spec. The basic mechanism is that the `arguments` object installs a hidden parameter mapping object that property accesses get filtered through. This is how accessing numeric properties on `arguments` are proxied to the named identifier in the function scope. When `arguments` is instantiated, getters and setters are created for all the numeric properties on the object that correspond to function arguments. These getters and setters can be deleted from the object. This is all pretty intricate, so refer to the spec for details. Note that the `arguments` object itself is still lazily instantiated on first access within a function. This is non-conforming, and we'll have to revisit this once we get around to improving function calls.
2021-06-28 21:19:25 +02:00
LibJS: Rename PropertyName to PropertyKey Let's use the same name as the spec. :^)
2021-10-24 16:01:24 +02:00
virtual ThrowCompletionOr<Optional<PropertyDescriptor>> internal_get_own_property(PropertyKey const&) const override;
LibJS+LibWeb: Prevent double invocation of `[[GetOwnProperty]]` The `[[GetOwnProperty]]` internal method invocation in `OrdinarySetWithOwnDescriptor` was being invocated again with the same parameters in the `[[DefineOwnProperty]]` internal method that is also later called in `OrdinarySetWithOwnDescriptor`. The `PlatformObject.[[DefineOwnProperty]]` has similair logic. This change adds an optional parameter to the `[[DefineOwnProperty]]` internal method so the results of the previous `[[GetOwnProperty]]` internal method invocation can be re-used.
2024-11-01 21:03:18 +01:00
virtual ThrowCompletionOr<bool> internal_define_own_property(PropertyKey const&, PropertyDescriptor const&, Optional<PropertyDescriptor>* precomputed_get_own_property = nullptr) override;
LibJS: Add PropertyLookupPhase enum to distinguish Object [[Get]] calls We can now tell the difference between an own property access and a subsequent (automatic) prototype chain access. This will be used to implement caching of prototype chain accesses.
2024-05-02 11:13:08 +02:00
virtual ThrowCompletionOr<Value> internal_get(PropertyKey const&, Value receiver, CacheablePropertyMetadata*, PropertyLookupPhase) const override;
LibJS: Cache PutById to setters in the prototype chain This is *extremely* common on the web, but barely shows up at all in JavaScript benchmarks. A typical example is setting Element.innerHTML on a HTMLDivElement. HTMLDivElement doesn't have innerHTML, so it has to travel up the prototype chain until it finds it. Before this change, we didn't cache this at all, so we had to travel the prototype chain every time a setter like this was used. We now use the same mechanism we already had for GetBydId and cache PutById setter accesses in the prototype chain as well. 1.74x speedup on MicroBench/setter-in-prototype-chain.js
2025-05-04 16:00:13 +02:00
virtual ThrowCompletionOr<bool> internal_set(PropertyKey const&, Value value, Value receiver, CacheablePropertyMetadata*, PropertyLookupPhase) override;
LibJS: Rename PropertyName to PropertyKey Let's use the same name as the spec. :^)
2021-10-24 16:01:24 +02:00
virtual ThrowCompletionOr<bool> internal_delete(PropertyKey const&) override;
LibJS: Finish implementing mapped arguments exotic objects :^) Now that the Object rewrite is in place, we have enough tools to implement the mapped `arguments` propreties according to spec. The basic mechanism is that the `arguments` object installs a hidden parameter mapping object that property accesses get filtered through. This is how accessing numeric properties on `arguments` are proxied to the named identifier in the function scope. When `arguments` is instantiated, getters and setters are created for all the numeric properties on the object that correspond to function arguments. These getters and setters can be deleted from the object. This is all pretty intricate, so refer to the spec for details. Note that the `arguments` object itself is still lazily instantiated on first access within a function. This is non-conforming, and we'll have to revisit this once we get around to improving function calls.
2021-06-28 21:19:25 +02:00
LibJS: Make mapped arguments objects way less allocation-happy By following the spec to the letter, our mapped arguments objects ended up with many extra GC allocations: - 1 extra Object for the internal [[ParameterMap]]. - 2 extra NativeFunctions for each mapped parameter accessor. - 1 extra Accessor to hold the aforementioned NativeFunctions. This patch removes all those allocations and lets ArgumentsObject model the desired behavior in custom C++ instead of using script primitives. 1.06x speedup on Speedometer's TodoMVC-jQuery.
2025-05-11 12:32:24 +02:00
void set_mapped_names(Vector<FlyString> mapped_names) { m_mapped_names = move(mapped_names); }
LibJS: Finish implementing mapped arguments exotic objects :^) Now that the Object rewrite is in place, we have enough tools to implement the mapped `arguments` propreties according to spec. The basic mechanism is that the `arguments` object installs a hidden parameter mapping object that property accesses get filtered through. This is how accessing numeric properties on `arguments` are proxied to the named identifier in the function scope. When `arguments` is instantiated, getters and setters are created for all the numeric properties on the object that correspond to function arguments. These getters and setters can be deleted from the object. This is all pretty intricate, so refer to the spec for details. Note that the `arguments` object itself is still lazily instantiated on first access within a function. This is non-conforming, and we'll have to revisit this once we get around to improving function calls.
2021-06-28 21:19:25 +02:00
private:
LibJS: Hide all the constructors! Now that the GC allocator is able to invoke Cell subclass constructors directly via friendship, we no longer need to keep them public. :^)
2022-08-28 23:51:28 +02:00
ArgumentsObject(Realm&, Environment&);
LibJS: Make mapped arguments objects way less allocation-happy By following the spec to the letter, our mapped arguments objects ended up with many extra GC allocations: - 1 extra Object for the internal [[ParameterMap]]. - 2 extra NativeFunctions for each mapped parameter accessor. - 1 extra Accessor to hold the aforementioned NativeFunctions. This patch removes all those allocations and lets ArgumentsObject model the desired behavior in custom C++ instead of using script primitives. 1.06x speedup on Speedometer's TodoMVC-jQuery.
2025-05-11 12:32:24 +02:00
[[nodiscard]] bool parameter_map_has(PropertyKey const&) const;
[[nodiscard]] Value get_from_parameter_map(PropertyKey const&) const;
void set_in_parameter_map(PropertyKey const&, Value);
void delete_from_parameter_map(PropertyKey const&);
LibJS: Finish implementing mapped arguments exotic objects :^) Now that the Object rewrite is in place, we have enough tools to implement the mapped `arguments` propreties according to spec. The basic mechanism is that the `arguments` object installs a hidden parameter mapping object that property accesses get filtered through. This is how accessing numeric properties on `arguments` are proxied to the named identifier in the function scope. When `arguments` is instantiated, getters and setters are created for all the numeric properties on the object that correspond to function arguments. These getters and setters can be deleted from the object. This is all pretty intricate, so refer to the spec for details. Note that the `arguments` object itself is still lazily instantiated on first access within a function. This is non-conforming, and we'll have to revisit this once we get around to improving function calls.
2021-06-28 21:19:25 +02:00
virtual void visit_edges(Cell::Visitor&) override;
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-15 04:01:23 +13:00
GC::Ref<Environment> m_environment;
LibJS: Make mapped arguments objects way less allocation-happy By following the spec to the letter, our mapped arguments objects ended up with many extra GC allocations: - 1 extra Object for the internal [[ParameterMap]]. - 2 extra NativeFunctions for each mapped parameter accessor. - 1 extra Accessor to hold the aforementioned NativeFunctions. This patch removes all those allocations and lets ArgumentsObject model the desired behavior in custom C++ instead of using script primitives. 1.06x speedup on Speedometer's TodoMVC-jQuery.
2025-05-11 12:32:24 +02:00
Vector<FlyString> m_mapped_names;
LibJS: Add the CreateMappedArgumentsObject abstract operation This patch adds a new ArgumentsObject class to represent what the spec calls "Arguments Exotic Objects" These are constructed by the new CreateMappedArgumentsObject when the `arguments` identifier is resolved in a callee context. The implementation is incomplete and doesn't yet support mapping of the parameter variables to the indexed properties of `arguments`.
2021-06-28 13:26:01 +02:00
};
}
Reference in a new issue Copy permalink