// Copyright 2022 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#ifndef V8_OBJECTS_JS_STRUCT_H_
#define V8_OBJECTS_JS_STRUCT_H_

#include "src/objects/js-objects.h"
#include "src/objects/smi.h"

// Has to be the last include (doesn't have include guards):
#include "src/objects/object-macros.h"

namespace v8 {
namespace internal {

V8_OBJECT class AlwaysSharedSpaceJSObject : public JSObject {
  V8_IT_ABSTRACT;

 public:
  // Prepare a Map to be used as the instance map for shared JS objects.
  static void PrepareMapNoEnumerableProperties(Tagged<Map> map);
  static void PrepareMapNoEnumerableProperties(
      Isolate* isolate, Tagged<Map> map, Tagged<DescriptorArray> descriptors);
  static void PrepareMapWithEnumerableProperties(
      Isolate* isolate, DirectHandle<Map> map,
      DirectHandle<DescriptorArray> descriptors, int enum_length);

  V8_WARN_UNUSED_RESULT static Maybe<bool> DefineOwnProperty(
      Isolate* isolate, DirectHandle<AlwaysSharedSpaceJSObject> shared_obj,
      DirectHandle<Object> key, PropertyDescriptor* desc,
      Maybe<ShouldThrow> should_throw);

  // This is a generic `HasInstance` that checks the constructor's initial map
  // against the object's map. It is on `AlwaysSharedSpaceJSObject` because this
  // kind of instanceof resolution resolution is used only for shared objects.
  static Maybe<bool> HasInstance(Isolate* isolate,
                                 DirectHandle<JSFunction> constructor,
                                 DirectHandle<Object> object);

  // Defined out-of-line below the class so `sizeof` on the still-incomplete
  // type can appear in an initializer.
  static const int kHeaderSize;
} V8_OBJECT_END;

inline constexpr int AlwaysSharedSpaceJSObject::kHeaderSize =
    sizeof(AlwaysSharedSpaceJSObject);
static_assert(sizeof(AlwaysSharedSpaceJSObject) == sizeof(JSObject));

V8_OBJECT class JSSharedStruct : public AlwaysSharedSpaceJSObject {
 public:
  static DirectHandle<Map> CreateInstanceMap(
      Isolate* isolate,
      const base::Vector<const DirectHandle<Name>> field_names,
      const std::set<uint32_t>& element_names,
      MaybeDirectHandle<String> maybe_registry_key,
      bool has_interesting_properties);

  static MaybeHandle<String> GetRegistryKey(Isolate* isolate,
                                            Tagged<Map> instance_map);

  static bool IsRegistryKeyDescriptor(Isolate* isolate,
                                      Tagged<Map> instance_map,
                                      InternalIndex i);

  static MaybeDirectHandle<NumberDictionary> GetElementsTemplate(
      Isolate* isolate, Tagged<Map> instance_map);

  static bool IsElementsTemplateDescriptor(Isolate* isolate,
                                           Tagged<Map> instance_map,
                                           InternalIndex i);

  DECL_PRINTER(JSSharedStruct)
  EXPORT_DECL_VERIFIER(JSSharedStruct)

  // Defined out-of-line below the class so `sizeof` on the still-incomplete
  // type can appear in an initializer.
  static const int kHeaderSize;
} V8_OBJECT_END;

inline constexpr int JSSharedStruct::kHeaderSize = sizeof(JSSharedStruct);

class SharedStructTypeRegistry final {
 public:
  static constexpr Tagged<Smi> deleted_element() { return Smi::FromInt(1); }

  SharedStructTypeRegistry();
  ~SharedStructTypeRegistry();

  MaybeDirectHandle<Map> Register(
      Isolate* isolate, Handle<String> key,
      const base::Vector<const DirectHandle<Name>> field_names,
      const std::set<uint32_t>& element_names, bool has_interesting_properties);

  void IterateElements(Isolate* isolate, RootVisitor* visitor);
  void NotifyElementsRemoved(int count);

 private:
  class Data;

  MaybeDirectHandle<Map> RegisterNoThrow(
      Isolate* isolate, Handle<String> key,
      const base::Vector<const DirectHandle<Name>> field_names,
      const std::set<uint32_t>& element_names, bool has_interesting_properties);

  MaybeDirectHandle<Map> CheckIfEntryMatches(
      Isolate* isolate, InternalIndex entry, DirectHandle<String> key,
      const base::Vector<const DirectHandle<Name>> field_names,
      const std::set<uint32_t>& element_names);

  void EnsureCapacity(PtrComprCageBase cage_base, int additional_elements);

  std::unique_ptr<Data> data_;

  // Protects all access to the registry.
  base::Mutex data_mutex_;
};

}  // namespace internal
}  // namespace v8

#include "src/objects/object-macros-undef.h"

#endif  // V8_OBJECTS_JS_STRUCT_H_