Object.h 12 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269
  1. /*
  2. * Copyright (c) 2020, Andreas Kling <kling@serenityos.org>
  3. * Copyright (c) 2020-2023, Linus Groh <linusg@serenityos.org>
  4. *
  5. * SPDX-License-Identifier: BSD-2-Clause
  6. */
  7. #pragma once
  8. #include <AK/Badge.h>
  9. #include <AK/HashMap.h>
  10. #include <AK/StringView.h>
  11. #include <LibJS/Forward.h>
  12. #include <LibJS/Heap/Cell.h>
  13. #include <LibJS/Heap/CellAllocator.h>
  14. #include <LibJS/Heap/MarkedVector.h>
  15. #include <LibJS/Runtime/Completion.h>
  16. #include <LibJS/Runtime/IndexedProperties.h>
  17. #include <LibJS/Runtime/PrimitiveString.h>
  18. #include <LibJS/Runtime/PrivateEnvironment.h>
  19. #include <LibJS/Runtime/PropertyDescriptor.h>
  20. #include <LibJS/Runtime/PropertyKey.h>
  21. #include <LibJS/Runtime/Shape.h>
  22. #include <LibJS/Runtime/Value.h>
  23. #include <LibJS/SafeFunction.h>
  24. namespace JS {
  25. #define JS_OBJECT(class_, base_class) JS_CELL(class_, base_class)
  26. struct PrivateElement {
  27. enum class Kind {
  28. Field,
  29. Method,
  30. Accessor
  31. };
  32. PrivateName key;
  33. Kind kind { Kind::Field };
  34. Handle<Value> value;
  35. };
  36. // Non-standard: This is information optionally returned by object property access functions.
  37. // It can be used to implement inline caches for property lookup.
  38. struct CacheablePropertyMetadata {
  39. enum class Type {
  40. NotCacheable,
  41. OwnProperty,
  42. };
  43. Type type { Type::NotCacheable };
  44. Optional<u32> property_offset;
  45. u64 unique_shape_serial_number { 0 };
  46. };
  47. class Object : public Cell {
  48. JS_CELL(Object, Cell);
  49. JS_DECLARE_ALLOCATOR(Object);
  50. public:
  51. static NonnullGCPtr<Object> create(Realm&, Object* prototype);
  52. virtual void initialize(Realm&) override;
  53. virtual ~Object();
  54. enum class PropertyKind {
  55. Key,
  56. Value,
  57. KeyAndValue,
  58. };
  59. enum class IntegrityLevel {
  60. Sealed,
  61. Frozen,
  62. };
  63. enum class ShouldThrowExceptions {
  64. No,
  65. Yes,
  66. };
  67. enum class MayInterfereWithIndexedPropertyAccess {
  68. No,
  69. Yes,
  70. };
  71. // Please DO NOT make up your own non-standard methods unless you
  72. // have a very good reason to do so. If any object abstract
  73. // operation from the spec is missing, add it instead.
  74. // Functionality for implementation details like shapes and
  75. // property storage are obviously exempt from this rule :^)
  76. //
  77. // Methods named [[Foo]]() in the spec are named internal_foo()
  78. // here, as they are "The [[Foo]] internal method of a ... object".
  79. // They must be virtual and may be overridden. All other methods
  80. // follow the regular PascalCase name converted to camel_case
  81. // naming convention and must not be virtual.
  82. // 7.1 Type Conversion, https://tc39.es/ecma262/#sec-type-conversion
  83. ThrowCompletionOr<Value> ordinary_to_primitive(Value::PreferredType preferred_type) const;
  84. // 7.2 Testing and Comparison Operations, https://tc39.es/ecma262/#sec-testing-and-comparison-operations
  85. ThrowCompletionOr<bool> is_extensible() const;
  86. // 7.3 Operations on Objects, https://tc39.es/ecma262/#sec-operations-on-objects
  87. ThrowCompletionOr<Value> get(PropertyKey const&) const;
  88. ThrowCompletionOr<void> set(PropertyKey const&, Value, ShouldThrowExceptions);
  89. ThrowCompletionOr<bool> create_data_property(PropertyKey const&, Value);
  90. void create_method_property(PropertyKey const&, Value);
  91. ThrowCompletionOr<bool> create_data_property_or_throw(PropertyKey const&, Value);
  92. void create_non_enumerable_data_property_or_throw(PropertyKey const&, Value);
  93. ThrowCompletionOr<void> define_property_or_throw(PropertyKey const&, PropertyDescriptor const&);
  94. ThrowCompletionOr<void> delete_property_or_throw(PropertyKey const&);
  95. ThrowCompletionOr<bool> has_property(PropertyKey const&) const;
  96. ThrowCompletionOr<bool> has_own_property(PropertyKey const&) const;
  97. ThrowCompletionOr<bool> set_integrity_level(IntegrityLevel);
  98. ThrowCompletionOr<bool> test_integrity_level(IntegrityLevel) const;
  99. ThrowCompletionOr<MarkedVector<Value>> enumerable_own_property_names(PropertyKind kind) const;
  100. ThrowCompletionOr<void> copy_data_properties(VM&, Value source, HashTable<PropertyKey> const& seen_names);
  101. PrivateElement* private_element_find(PrivateName const& name);
  102. ThrowCompletionOr<void> private_field_add(PrivateName const& name, Value value);
  103. ThrowCompletionOr<void> private_method_or_accessor_add(PrivateElement element);
  104. ThrowCompletionOr<Value> private_get(PrivateName const& name);
  105. ThrowCompletionOr<void> private_set(PrivateName const& name, Value value);
  106. ThrowCompletionOr<void> define_field(ClassFieldDefinition const&);
  107. ThrowCompletionOr<void> initialize_instance_elements(ECMAScriptFunctionObject& constructor);
  108. // 10.1 Ordinary Object Internal Methods and Internal Slots, https://tc39.es/ecma262/#sec-ordinary-object-internal-methods-and-internal-slots
  109. virtual ThrowCompletionOr<Object*> internal_get_prototype_of() const;
  110. virtual ThrowCompletionOr<bool> internal_set_prototype_of(Object* prototype);
  111. virtual ThrowCompletionOr<bool> internal_is_extensible() const;
  112. virtual ThrowCompletionOr<bool> internal_prevent_extensions();
  113. virtual ThrowCompletionOr<Optional<PropertyDescriptor>> internal_get_own_property(PropertyKey const&) const;
  114. virtual ThrowCompletionOr<bool> internal_define_own_property(PropertyKey const&, PropertyDescriptor const&);
  115. virtual ThrowCompletionOr<bool> internal_has_property(PropertyKey const&) const;
  116. virtual ThrowCompletionOr<Value> internal_get(PropertyKey const&, Value receiver, CacheablePropertyMetadata* = nullptr) const;
  117. virtual ThrowCompletionOr<bool> internal_set(PropertyKey const&, Value value, Value receiver, CacheablePropertyMetadata* = nullptr);
  118. virtual ThrowCompletionOr<bool> internal_delete(PropertyKey const&);
  119. virtual ThrowCompletionOr<MarkedVector<Value>> internal_own_property_keys() const;
  120. // NOTE: Any subclass of Object that overrides property access slots ([[Get]], [[Set]] etc)
  121. // to customize access to indexed properties (properties where the name is a positive integer)
  122. // must return true for this, to opt out of optimizations that rely on assumptions that
  123. // might not hold when property access behaves differently.
  124. bool may_interfere_with_indexed_property_access() const { return m_may_interfere_with_indexed_property_access; }
  125. ThrowCompletionOr<bool> ordinary_set_with_own_descriptor(PropertyKey const&, Value, Value, Optional<PropertyDescriptor>, CacheablePropertyMetadata* = nullptr);
  126. // 10.4.7 Immutable Prototype Exotic Objects, https://tc39.es/ecma262/#sec-immutable-prototype-exotic-objects
  127. ThrowCompletionOr<bool> set_immutable_prototype(Object* prototype);
  128. // 20.1 Object Objects, https://tc39.es/ecma262/#sec-object-objects
  129. ThrowCompletionOr<Object*> define_properties(Value properties);
  130. // 14.7.5 The for-in, for-of, and for-await-of Statements
  131. Optional<Completion> enumerate_object_properties(Function<Optional<Completion>(Value)>) const;
  132. // Implementation-specific storage abstractions
  133. Optional<ValueAndAttributes> storage_get(PropertyKey const&) const;
  134. bool storage_has(PropertyKey const&) const;
  135. void storage_set(PropertyKey const&, ValueAndAttributes const&);
  136. void storage_delete(PropertyKey const&);
  137. // Non-standard methods
  138. Value get_without_side_effects(PropertyKey const&) const;
  139. void define_direct_property(PropertyKey const& property_key, Value value, PropertyAttributes attributes) { storage_set(property_key, { value, attributes }); }
  140. void define_direct_accessor(PropertyKey const&, FunctionObject* getter, FunctionObject* setter, PropertyAttributes attributes);
  141. using IntrinsicAccessor = Value (*)(Realm&);
  142. void define_intrinsic_accessor(PropertyKey const&, PropertyAttributes attributes, IntrinsicAccessor accessor);
  143. void define_native_function(Realm&, PropertyKey const&, Function<ThrowCompletionOr<Value>(VM&)>, i32 length, PropertyAttributes attributes, Optional<Bytecode::Builtin> builtin = {});
  144. void define_native_accessor(Realm&, PropertyKey const&, Function<ThrowCompletionOr<Value>(VM&)> getter, Function<ThrowCompletionOr<Value>(VM&)> setter, PropertyAttributes attributes);
  145. virtual bool is_dom_node() const { return false; }
  146. virtual bool is_function() const { return false; }
  147. virtual bool is_string_object() const { return false; }
  148. virtual bool is_global_object() const { return false; }
  149. virtual bool is_proxy_object() const { return false; }
  150. virtual bool is_native_function() const { return false; }
  151. virtual bool is_ecmascript_function_object() const { return false; }
  152. virtual bool is_iterator_record() const { return false; }
  153. // B.3.7 The [[IsHTMLDDA]] Internal Slot, https://tc39.es/ecma262/#sec-IsHTMLDDA-internal-slot
  154. virtual bool is_htmldda() const { return false; }
  155. bool has_parameter_map() const { return m_has_parameter_map; }
  156. void set_has_parameter_map() { m_has_parameter_map = true; }
  157. virtual void visit_edges(Cell::Visitor&) override;
  158. Value get_direct(size_t index) const { return m_storage[index]; }
  159. void put_direct(size_t index, Value value) { m_storage[index] = value; }
  160. static FlatPtr storage_offset() { return OFFSET_OF(Object, m_storage); }
  161. IndexedProperties const& indexed_properties() const { return m_indexed_properties; }
  162. IndexedProperties& indexed_properties() { return m_indexed_properties; }
  163. void set_indexed_property_elements(Vector<Value>&& values) { m_indexed_properties = IndexedProperties(move(values)); }
  164. Shape& shape() { return *m_shape; }
  165. Shape const& shape() const { return *m_shape; }
  166. static FlatPtr shape_offset() { return OFFSET_OF(Object, m_shape); }
  167. void ensure_shape_is_unique();
  168. template<typename T>
  169. bool fast_is() const = delete;
  170. void set_prototype(Object*);
  171. static FlatPtr may_interfere_with_indexed_property_access_offset() { return OFFSET_OF(Object, m_may_interfere_with_indexed_property_access); }
  172. static FlatPtr indexed_properties_offset() { return OFFSET_OF(Object, m_indexed_properties); }
  173. static FlatPtr has_magical_length_property_offset() { return OFFSET_OF(Object, m_has_magical_length_property); }
  174. [[nodiscard]] bool is_typed_array() const { return m_is_typed_array; }
  175. void set_is_typed_array() { m_is_typed_array = true; }
  176. protected:
  177. enum class GlobalObjectTag { Tag };
  178. enum class ConstructWithoutPrototypeTag { Tag };
  179. enum class ConstructWithPrototypeTag { Tag };
  180. Object(GlobalObjectTag, Realm&, MayInterfereWithIndexedPropertyAccess = MayInterfereWithIndexedPropertyAccess::No);
  181. Object(ConstructWithoutPrototypeTag, Realm&, MayInterfereWithIndexedPropertyAccess = MayInterfereWithIndexedPropertyAccess::No);
  182. Object(Realm&, Object* prototype, MayInterfereWithIndexedPropertyAccess = MayInterfereWithIndexedPropertyAccess::No);
  183. Object(ConstructWithPrototypeTag, Object& prototype, MayInterfereWithIndexedPropertyAccess = MayInterfereWithIndexedPropertyAccess::No);
  184. explicit Object(Shape&, MayInterfereWithIndexedPropertyAccess = MayInterfereWithIndexedPropertyAccess::No);
  185. // [[Extensible]]
  186. bool m_is_extensible { true };
  187. // [[ParameterMap]]
  188. bool m_has_parameter_map { false };
  189. bool m_has_magical_length_property { false };
  190. bool m_is_typed_array { false };
  191. private:
  192. void set_shape(Shape& shape) { m_shape = &shape; }
  193. Object* prototype() { return shape().prototype(); }
  194. Object const* prototype() const { return shape().prototype(); }
  195. bool m_may_interfere_with_indexed_property_access { false };
  196. // True if this object has lazily allocated intrinsic properties.
  197. bool m_has_intrinsic_accessors { false };
  198. GCPtr<Shape> m_shape;
  199. Vector<Value> m_storage;
  200. IndexedProperties m_indexed_properties;
  201. OwnPtr<Vector<PrivateElement>> m_private_elements; // [[PrivateElements]]
  202. };
  203. }