@triniwiz/nativescript-masonkit 1.0.0-alpha.9 → 1.0.0-beta.0

package/src-native/pods/Headers/include/cppgc/heap.h

@@ -1,206 +0,0 @@
-// Copyright 2020 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 INCLUDE_CPPGC_HEAP_H_
-#define INCLUDE_CPPGC_HEAP_H_
-
-#include <cstddef>
-#include <cstdint>
-#include <memory>
-#include <vector>
-
-#include "cppgc/common.h"
-#include "cppgc/custom-space.h"
-#include "cppgc/platform.h"
-#include "v8config.h"  // NOLINT(build/include_directory)
-
-/**
- * cppgc - A C++ garbage collection library.
- */
-namespace cppgc {
-
-class AllocationHandle;
-
-/**
- * Implementation details of cppgc. Those details are considered internal and
- * may change at any point in time without notice. Users should never rely on
- * the contents of this namespace.
- */
-namespace internal {
-class Heap;
-}  // namespace internal
-
-/**
- * Used for additional heap APIs.
- */
-class HeapHandle;
-
-class V8_EXPORT Heap {
- public:
-  /**
-   * Specifies the stack state the embedder is in.
-   */
-  using StackState = EmbedderStackState;
-
-  /**
-   * Specifies whether conservative stack scanning is supported.
-   */
-  enum class StackSupport : uint8_t {
-    /**
-     * Conservative stack scan is supported.
-     */
-    kSupportsConservativeStackScan,
-    /**
-     * Conservative stack scan is not supported. Embedders may use this option
-     * when using custom infrastructure that is unsupported by the library.
-     */
-    kNoConservativeStackScan,
-  };
-
-  /**
-   * Specifies supported marking types
-   */
-  enum class MarkingType : uint8_t {
-    /**
-     * Atomic stop-the-world marking. This option does not require any write
-     * barriers but is the most intrusive in terms of jank.
-     */
-    kAtomic,
-    /**
-     * Incremental marking interleaves marking with the rest of the application
-     * workload on the same thread.
-     */
-    kIncremental,
-    /**
-     * Incremental and concurrent marking.
-     */
-    kIncrementalAndConcurrent
-  };
-
-  /**
-   * Specifies supported sweeping types
-   */
-  enum class SweepingType : uint8_t {
-    /**
-     * Atomic stop-the-world sweeping. All of sweeping is performed at once.
-     */
-    kAtomic,
-    /**
-     * Incremental sweeping interleaves sweeping with the rest of the
-     * application workload on the same thread.
-     */
-    kIncremental,
-    /**
-     * Incremental and concurrent sweeping. Sweeping is split and interleaved
-     * with the rest of the application.
-     */
-    kIncrementalAndConcurrent
-  };
-
-  /**
-   * Constraints for a Heap setup.
-   */
-  struct ResourceConstraints {
-    /**
-     * Allows the heap to grow to some initial size in bytes before triggering
-     * garbage collections. This is useful when it is known that applications
-     * need a certain minimum heap to run to avoid repeatedly invoking the
-     * garbage collector when growing the heap.
-     */
-    size_t initial_heap_size_bytes = 0;
-  };
-
-  /**
-   * Options specifying Heap properties (e.g. custom spaces) when initializing a
-   * heap through `Heap::Create()`.
-   */
-  struct HeapOptions {
-    /**
-     * Creates reasonable defaults for instantiating a Heap.
-     *
-     * \returns the HeapOptions that can be passed to `Heap::Create()`.
-     */
-    static HeapOptions Default() { return {}; }
-
-    /**
-     * Custom spaces added to heap are required to have indices forming a
-     * numbered sequence starting at 0, i.e., their `kSpaceIndex` must
-     * correspond to the index they reside in the vector.
-     */
-    std::vector<std::unique_ptr<CustomSpaceBase>> custom_spaces;
-
-    /**
-     * Specifies whether conservative stack scan is supported. When conservative
-     * stack scan is not supported, the collector may try to invoke
-     * garbage collections using non-nestable task, which are guaranteed to have
-     * no interesting stack, through the provided Platform. If such tasks are
-     * not supported by the Platform, the embedder must take care of invoking
-     * the GC through `ForceGarbageCollectionSlow()`.
-     */
-    StackSupport stack_support = StackSupport::kSupportsConservativeStackScan;
-
-    /**
-     * Specifies which types of marking are supported by the heap.
-     */
-    MarkingType marking_support = MarkingType::kIncrementalAndConcurrent;
-
-    /**
-     * Specifies which types of sweeping are supported by the heap.
-     */
-    SweepingType sweeping_support = SweepingType::kIncrementalAndConcurrent;
-
-    /**
-     * Resource constraints specifying various properties that the internal
-     * GC scheduler follows.
-     */
-    ResourceConstraints resource_constraints;
-  };
-
-  /**
-   * Creates a new heap that can be used for object allocation.
-   *
-   * \param platform implemented and provided by the embedder.
-   * \param options HeapOptions specifying various properties for the Heap.
-   * \returns a new Heap instance.
-   */
-  static std::unique_ptr<Heap> Create(
-      std::shared_ptr<Platform> platform,
-      HeapOptions options = HeapOptions::Default());
-
-  virtual ~Heap() = default;
-
-  /**
-   * Forces garbage collection.
-   *
-   * \param source String specifying the source (or caller) triggering a
-   *   forced garbage collection.
-   * \param reason String specifying the reason for the forced garbage
-   *   collection.
-   * \param stack_state The embedder stack state, see StackState.
-   */
-  void ForceGarbageCollectionSlow(
-      const char* source, const char* reason,
-      StackState stack_state = StackState::kMayContainHeapPointers);
-
-  /**
-   * \returns the opaque handle for allocating objects using
-   * `MakeGarbageCollected()`.
-   */
-  AllocationHandle& GetAllocationHandle();
-
-  /**
-   * \returns the opaque heap handle which may be used to refer to this heap in
-   *   other APIs. Valid as long as the underlying `Heap` is alive.
-   */
-  HeapHandle& GetHeapHandle();
-
- private:
-  Heap() = default;
-
-  friend class internal::Heap;
-};
-
-}  // namespace cppgc
-
-#endif  // INCLUDE_CPPGC_HEAP_H_

package/src-native/pods/Headers/include/cppgc/internal/api-constants.h

@@ -1,55 +0,0 @@
-// Copyright 2020 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 INCLUDE_CPPGC_INTERNAL_API_CONSTANTS_H_
-#define INCLUDE_CPPGC_INTERNAL_API_CONSTANTS_H_
-
-#include <cstddef>
-#include <cstdint>
-
-#include "v8config.h"  // NOLINT(build/include_directory)
-
-namespace cppgc {
-namespace internal {
-
-// Embedders should not rely on this code!
-
-// Internal constants to avoid exposing internal types on the API surface.
-namespace api_constants {
-
-constexpr size_t kKB = 1024;
-constexpr size_t kMB = kKB * 1024;
-constexpr size_t kGB = kMB * 1024;
-
-// Offset of the uint16_t bitfield from the payload contaning the
-// in-construction bit. This is subtracted from the payload pointer to get
-// to the right bitfield.
-static constexpr size_t kFullyConstructedBitFieldOffsetFromPayload =
-    2 * sizeof(uint16_t);
-// Mask for in-construction bit.
-static constexpr uint16_t kFullyConstructedBitMask = uint16_t{1};
-
-static constexpr size_t kPageSize = size_t{1} << 17;
-
-static constexpr size_t kLargeObjectSizeThreshold = kPageSize / 2;
-
-#if defined(CPPGC_CAGED_HEAP)
-constexpr size_t kCagedHeapReservationSize = static_cast<size_t>(4) * kGB;
-constexpr size_t kCagedHeapReservationAlignment = kCagedHeapReservationSize;
-#endif
-
-static constexpr size_t kDefaultAlignment = sizeof(void*);
-
-// Maximum support alignment for a type as in `alignof(T)`.
-static constexpr size_t kMaxSupportedAlignment = 2 * kDefaultAlignment;
-
-// Granularity of heap allocations.
-constexpr size_t kAllocationGranularity = sizeof(void*);
-
-}  // namespace api_constants
-
-}  // namespace internal
-}  // namespace cppgc
-
-#endif  // INCLUDE_CPPGC_INTERNAL_API_CONSTANTS_H_

package/src-native/pods/Headers/include/cppgc/internal/atomic-entry-flag.h

@@ -1,48 +0,0 @@
-// Copyright 2020 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 INCLUDE_CPPGC_INTERNAL_ATOMIC_ENTRY_FLAG_H_
-#define INCLUDE_CPPGC_INTERNAL_ATOMIC_ENTRY_FLAG_H_
-
-#include <atomic>
-
-namespace cppgc {
-namespace internal {
-
-// A flag which provides a fast check whether a scope may be entered on the
-// current thread, without needing to access thread-local storage or mutex.  Can
-// have false positives (i.e., spuriously report that it might be entered), so
-// it is expected that this will be used in tandem with a precise check that the
-// scope is in fact entered on that thread.
-//
-// Example:
-//   g_frobnicating_flag.MightBeEntered() &&
-//   ThreadLocalFrobnicator().IsFrobnicating()
-//
-// Relaxed atomic operations are sufficient, since:
-// - all accesses remain atomic
-// - each thread must observe its own operations in order
-// - no thread ever exits the flag more times than it enters (if used correctly)
-// And so if a thread observes zero, it must be because it has observed an equal
-// number of exits as entries.
-class AtomicEntryFlag final {
- public:
-  void Enter() { entries_.fetch_add(1, std::memory_order_relaxed); }
-  void Exit() { entries_.fetch_sub(1, std::memory_order_relaxed); }
-
-  // Returns false only if the current thread is not between a call to Enter
-  // and a call to Exit. Returns true if this thread or another thread may
-  // currently be in the scope guarded by this flag.
-  bool MightBeEntered() const {
-    return entries_.load(std::memory_order_relaxed) != 0;
-  }
-
- private:
-  std::atomic_int entries_{0};
-};
-
-}  // namespace internal
-}  // namespace cppgc
-
-#endif  // INCLUDE_CPPGC_INTERNAL_ATOMIC_ENTRY_FLAG_H_

package/src-native/pods/Headers/include/cppgc/internal/caged-heap-local-data.h

@@ -1,79 +0,0 @@
-// Copyright 2020 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 INCLUDE_CPPGC_INTERNAL_CAGED_HEAP_LOCAL_DATA_H_
-#define INCLUDE_CPPGC_INTERNAL_CAGED_HEAP_LOCAL_DATA_H_
-
-#include <array>
-#include <cstddef>
-#include <cstdint>
-
-#include "cppgc/internal/api-constants.h"
-#include "cppgc/internal/logging.h"
-#include "cppgc/platform.h"
-#include "v8config.h"  // NOLINT(build/include_directory)
-
-namespace cppgc {
-namespace internal {
-
-class HeapBase;
-
-#if defined(CPPGC_YOUNG_GENERATION)
-
-// AgeTable is the bytemap needed for the fast generation check in the write
-// barrier. AgeTable contains entries that correspond to 512 bytes memory
-// regions (cards). Each entry in the table represents generation of the objects
-// that reside on the corresponding card (young, old or mixed).
-class AgeTable final {
-  static constexpr size_t kRequiredSize = 1 * api_constants::kMB;
-  static constexpr size_t kAllocationGranularity =
-      api_constants::kAllocationGranularity;
-
- public:
-  enum class Age : uint8_t { kOld, kYoung, kMixed };
-
-  static constexpr size_t kCardSizeInBytes =
-      (api_constants::kCagedHeapReservationSize / kAllocationGranularity) /
-      kRequiredSize;
-
-  void SetAge(uintptr_t cage_offset, Age age) {
-    table_[card(cage_offset)] = age;
-  }
-  V8_INLINE Age GetAge(uintptr_t cage_offset) const {
-    return table_[card(cage_offset)];
-  }
-
-  void Reset(PageAllocator* allocator);
-
- private:
-  V8_INLINE size_t card(uintptr_t offset) const {
-    constexpr size_t kGranularityBits =
-        __builtin_ctz(static_cast<uint32_t>(kCardSizeInBytes));
-    const size_t entry = offset >> kGranularityBits;
-    CPPGC_DCHECK(table_.size() > entry);
-    return entry;
-  }
-
-  std::array<Age, kRequiredSize> table_;
-};
-
-static_assert(sizeof(AgeTable) == 1 * api_constants::kMB,
-              "Size of AgeTable is 1MB");
-
-#endif  // CPPGC_YOUNG_GENERATION
-
-struct CagedHeapLocalData final {
-  CagedHeapLocalData(HeapBase&, PageAllocator&);
-
-  bool is_incremental_marking_in_progress = false;
-  HeapBase& heap_base;
-#if defined(CPPGC_YOUNG_GENERATION)
-  AgeTable age_table;
-#endif
-};
-
-}  // namespace internal
-}  // namespace cppgc
-
-#endif  // INCLUDE_CPPGC_INTERNAL_CAGED_HEAP_LOCAL_DATA_H_

package/src-native/pods/Headers/include/cppgc/internal/compiler-specific.h

@@ -1,38 +0,0 @@
-// Copyright 2020 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 INCLUDE_CPPGC_INTERNAL_COMPILER_SPECIFIC_H_
-#define INCLUDE_CPPGC_INTERNAL_COMPILER_SPECIFIC_H_
-
-namespace cppgc {
-
-#if defined(__has_attribute)
-#define CPPGC_HAS_ATTRIBUTE(FEATURE) __has_attribute(FEATURE)
-#else
-#define CPPGC_HAS_ATTRIBUTE(FEATURE) 0
-#endif
-
-#if defined(__has_cpp_attribute)
-#define CPPGC_HAS_CPP_ATTRIBUTE(FEATURE) __has_cpp_attribute(FEATURE)
-#else
-#define CPPGC_HAS_CPP_ATTRIBUTE(FEATURE) 0
-#endif
-
-// [[no_unique_address]] comes in C++20 but supported in clang with -std >=
-// c++11.
-#if CPPGC_HAS_CPP_ATTRIBUTE(no_unique_address)
-#define CPPGC_NO_UNIQUE_ADDRESS [[no_unique_address]]
-#else
-#define CPPGC_NO_UNIQUE_ADDRESS
-#endif
-
-#if CPPGC_HAS_ATTRIBUTE(unused)
-#define CPPGC_UNUSED __attribute__((unused))
-#else
-#define CPPGC_UNUSED
-#endif
-
-}  // namespace cppgc
-
-#endif  // INCLUDE_CPPGC_INTERNAL_COMPILER_SPECIFIC_H_

package/src-native/pods/Headers/include/cppgc/internal/finalizer-trait.h

@@ -1,93 +0,0 @@
-// Copyright 2020 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 INCLUDE_CPPGC_INTERNAL_FINALIZER_TRAIT_H_
-#define INCLUDE_CPPGC_INTERNAL_FINALIZER_TRAIT_H_
-
-#include <type_traits>
-
-#include "cppgc/type-traits.h"
-
-namespace cppgc {
-namespace internal {
-
-using FinalizationCallback = void (*)(void*);
-
-template <typename T, typename = void>
-struct HasFinalizeGarbageCollectedObject : std::false_type {};
-
-template <typename T>
-struct HasFinalizeGarbageCollectedObject<
-    T,
-    std::void_t<decltype(std::declval<T>().FinalizeGarbageCollectedObject())>>
-    : std::true_type {};
-
-// The FinalizerTraitImpl specifies how to finalize objects.
-template <typename T, bool isFinalized>
-struct FinalizerTraitImpl;
-
-template <typename T>
-struct FinalizerTraitImpl<T, true> {
- private:
-  // Dispatch to custom FinalizeGarbageCollectedObject().
-  struct Custom {
-    static void Call(void* obj) {
-      static_cast<T*>(obj)->FinalizeGarbageCollectedObject();
-    }
-  };
-
-  // Dispatch to regular destructor.
-  struct Destructor {
-    static void Call(void* obj) { static_cast<T*>(obj)->~T(); }
-  };
-
-  using FinalizeImpl =
-      std::conditional_t<HasFinalizeGarbageCollectedObject<T>::value, Custom,
-                         Destructor>;
-
- public:
-  static void Finalize(void* obj) {
-    static_assert(sizeof(T), "T must be fully defined");
-    FinalizeImpl::Call(obj);
-  }
-};
-
-template <typename T>
-struct FinalizerTraitImpl<T, false> {
-  static void Finalize(void* obj) {
-    static_assert(sizeof(T), "T must be fully defined");
-  }
-};
-
-// The FinalizerTrait is used to determine if a type requires finalization and
-// what finalization means.
-template <typename T>
-struct FinalizerTrait {
- private:
-  // Object has a finalizer if it has
-  // - a custom FinalizeGarbageCollectedObject method, or
-  // - a destructor.
-  static constexpr bool kNonTrivialFinalizer =
-      internal::HasFinalizeGarbageCollectedObject<T>::value ||
-      !std::is_trivially_destructible<typename std::remove_cv<T>::type>::value;
-
-  static void Finalize(void* obj) {
-    internal::FinalizerTraitImpl<T, kNonTrivialFinalizer>::Finalize(obj);
-  }
-
- public:
-  static constexpr bool HasFinalizer() { return kNonTrivialFinalizer; }
-
-  // The callback used to finalize an object of type T.
-  static constexpr FinalizationCallback kCallback =
-      kNonTrivialFinalizer ? Finalize : nullptr;
-};
-
-template <typename T>
-constexpr FinalizationCallback FinalizerTrait<T>::kCallback;
-
-}  // namespace internal
-}  // namespace cppgc
-
-#endif  // INCLUDE_CPPGC_INTERNAL_FINALIZER_TRAIT_H_

package/src-native/pods/Headers/include/cppgc/internal/gc-info.h

@@ -1,156 +0,0 @@
-// Copyright 2020 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 INCLUDE_CPPGC_INTERNAL_GC_INFO_H_
-#define INCLUDE_CPPGC_INTERNAL_GC_INFO_H_
-
-#include <atomic>
-#include <cstdint>
-#include <type_traits>
-
-#include "cppgc/internal/finalizer-trait.h"
-#include "cppgc/internal/name-trait.h"
-#include "cppgc/trace-trait.h"
-#include "v8config.h"  // NOLINT(build/include_directory)
-
-namespace cppgc {
-namespace internal {
-
-using GCInfoIndex = uint16_t;
-
-struct V8_EXPORT EnsureGCInfoIndexTrait final {
-  // Acquires a new GC info object and returns the index. In addition, also
-  // updates `registered_index` atomically.
-  template <typename T>
-  V8_INLINE static GCInfoIndex EnsureIndex(
-      std::atomic<GCInfoIndex>& registered_index) {
-    return EnsureGCInfoIndexTraitDispatch<T>{}(registered_index);
-  }
-
- private:
-  template <typename T, bool = std::is_polymorphic<T>::value,
-            bool = FinalizerTrait<T>::HasFinalizer(),
-            bool = NameTrait<T>::HasNonHiddenName()>
-  struct EnsureGCInfoIndexTraitDispatch;
-
-  static GCInfoIndex EnsureGCInfoIndexPolymorphic(std::atomic<GCInfoIndex>&,
-                                                  TraceCallback,
-                                                  FinalizationCallback,
-                                                  NameCallback);
-  static GCInfoIndex EnsureGCInfoIndexPolymorphic(std::atomic<GCInfoIndex>&,
-                                                  TraceCallback,
-                                                  FinalizationCallback);
-  static GCInfoIndex EnsureGCInfoIndexPolymorphic(std::atomic<GCInfoIndex>&,
-                                                  TraceCallback, NameCallback);
-  static GCInfoIndex EnsureGCInfoIndexPolymorphic(std::atomic<GCInfoIndex>&,
-                                                  TraceCallback);
-  static GCInfoIndex EnsureGCInfoIndexNonPolymorphic(std::atomic<GCInfoIndex>&,
-                                                     TraceCallback,
-                                                     FinalizationCallback,
-
-                                                     NameCallback);
-  static GCInfoIndex EnsureGCInfoIndexNonPolymorphic(std::atomic<GCInfoIndex>&,
-                                                     TraceCallback,
-                                                     FinalizationCallback);
-  static GCInfoIndex EnsureGCInfoIndexNonPolymorphic(std::atomic<GCInfoIndex>&,
-                                                     TraceCallback,
-                                                     NameCallback);
-  static GCInfoIndex EnsureGCInfoIndexNonPolymorphic(std::atomic<GCInfoIndex>&,
-                                                     TraceCallback);
-};
-
-#define DISPATCH(is_polymorphic, has_finalizer, has_non_hidden_name, function) \
-  template <typename T>                                                        \
-  struct EnsureGCInfoIndexTrait::EnsureGCInfoIndexTraitDispatch<               \
-      T, is_polymorphic, has_finalizer, has_non_hidden_name> {                 \
-    V8_INLINE GCInfoIndex                                                      \
-    operator()(std::atomic<GCInfoIndex>& registered_index) {                   \
-      return function;                                                         \
-    }                                                                          \
-  };
-
-// --------------------------------------------------------------------- //
-// DISPATCH(is_polymorphic, has_finalizer, has_non_hidden_name, function)
-// --------------------------------------------------------------------- //
-DISPATCH(true, true, true,                                               //
-         EnsureGCInfoIndexPolymorphic(registered_index,                  //
-                                      TraceTrait<T>::Trace,              //
-                                      FinalizerTrait<T>::kCallback,      //
-                                      NameTrait<T>::GetName))            //
-DISPATCH(true, true, false,                                              //
-         EnsureGCInfoIndexPolymorphic(registered_index,                  //
-                                      TraceTrait<T>::Trace,              //
-                                      FinalizerTrait<T>::kCallback))     //
-DISPATCH(true, false, true,                                              //
-         EnsureGCInfoIndexPolymorphic(registered_index,                  //
-                                      TraceTrait<T>::Trace,              //
-                                      NameTrait<T>::GetName))            //
-DISPATCH(true, false, false,                                             //
-         EnsureGCInfoIndexPolymorphic(registered_index,                  //
-                                      TraceTrait<T>::Trace))             //
-DISPATCH(false, true, true,                                              //
-         EnsureGCInfoIndexNonPolymorphic(registered_index,               //
-                                         TraceTrait<T>::Trace,           //
-                                         FinalizerTrait<T>::kCallback,   //
-                                         NameTrait<T>::GetName))         //
-DISPATCH(false, true, false,                                             //
-         EnsureGCInfoIndexNonPolymorphic(registered_index,               //
-                                         TraceTrait<T>::Trace,           //
-                                         FinalizerTrait<T>::kCallback))  //
-DISPATCH(false, false, true,                                             //
-         EnsureGCInfoIndexNonPolymorphic(registered_index,               //
-                                         TraceTrait<T>::Trace,           //
-                                         NameTrait<T>::GetName))         //
-DISPATCH(false, false, false,                                            //
-         EnsureGCInfoIndexNonPolymorphic(registered_index,               //
-                                         TraceTrait<T>::Trace))          //
-
-#undef DISPATCH
-
-// Fold types based on finalizer behavior. Note that finalizer characteristics
-// align with trace behavior, i.e., destructors are virtual when trace methods
-// are and vice versa.
-template <typename T, typename ParentMostGarbageCollectedType>
-struct GCInfoFolding {
-  static constexpr bool kHasVirtualDestructorAtBase =
-      std::has_virtual_destructor<ParentMostGarbageCollectedType>::value;
-  static constexpr bool kBothTypesAreTriviallyDestructible =
-      std::is_trivially_destructible<ParentMostGarbageCollectedType>::value &&
-      std::is_trivially_destructible<T>::value;
-  static constexpr bool kHasCustomFinalizerDispatchAtBase =
-      internal::HasFinalizeGarbageCollectedObject<
-          ParentMostGarbageCollectedType>::value;
-#ifdef CPPGC_SUPPORTS_OBJECT_NAMES
-  static constexpr bool kWantsDetailedObjectNames = true;
-#else   // !CPPGC_SUPPORTS_OBJECT_NAMES
-  static constexpr bool kWantsDetailedObjectNames = false;
-#endif  // !CPPGC_SUPPORTS_OBJECT_NAMES
-
-  // Folding would regresses name resolution when deriving names from C++
-  // class names as it would just folds a name to the base class name.
-  using ResultType = std::conditional_t<(kHasVirtualDestructorAtBase ||
-                                         kBothTypesAreTriviallyDestructible ||
-                                         kHasCustomFinalizerDispatchAtBase) &&
-                                            !kWantsDetailedObjectNames,
-                                        ParentMostGarbageCollectedType, T>;
-};
-
-// Trait determines how the garbage collector treats objects wrt. to traversing,
-// finalization, and naming.
-template <typename T>
-struct GCInfoTrait final {
-  V8_INLINE static GCInfoIndex Index() {
-    static_assert(sizeof(T), "T must be fully defined");
-    static std::atomic<GCInfoIndex>
-        registered_index;  // Uses zero initialization.
-    const GCInfoIndex index = registered_index.load(std::memory_order_acquire);
-    return index ? index
-                 : EnsureGCInfoIndexTrait::EnsureIndex<T>(registered_index);
-  }
-};
-
-}  // namespace internal
-}  // namespace cppgc
-
-#endif  // INCLUDE_CPPGC_INTERNAL_GC_INFO_H_