[cleanup] Cleanup BodyDescriptorApply() and friends

In particular
* use variadic templates in BodyDescriptorApply(),
* ensure all the relevant classes have BodyDescriptor definition,
* ensure "objects-body-descriptors[-inl].h" headers are included only
  where necessary.

Bug: v8:12425
Change-Id: I7a95ed94bf62952e3d22d419d4a65ad2fe959d57
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/3312273Reviewed-by: Leszek Swirski <leszeks@chromium.org>
Reviewed-by: Michael Lippautz <mlippautz@chromium.org>
Reviewed-by: Toon Verwaest <verwaest@chromium.org>
Commit-Queue: Igor Sheludko <ishell@chromium.org>
Cr-Commit-Position: refs/heads/main@{#78242}

src/heap/invalidated-slots-inl.h

@@ -9,9 +9,7 @@
 
 #include "src/heap/invalidated-slots.h"
 #include "src/heap/spaces.h"
-#include "src/objects/objects-body-descriptors-inl.h"
-#include "src/objects/objects-body-descriptors.h"
-#include "src/objects/objects.h"
+#include "src/objects/objects-inl.h"
 #include "src/utils/allocation.h"
 
 namespace v8 {

src/objects/all-objects-inl.h

@@ -57,7 +57,6 @@
 #include "src/objects/microtask-inl.h"
 #include "src/objects/module-inl.h"
 #include "src/objects/name-inl.h"
-#include "src/objects/objects-body-descriptors-inl.h"
 #include "src/objects/objects-inl.h"
 #include "src/objects/oddball-inl.h"
 #include "src/objects/ordered-hash-table-inl.h"
@@ -87,6 +86,7 @@
 #include "src/objects/templates-inl.h"
 #include "src/objects/torque-defined-classes-inl.h"
 #include "src/objects/transitions-inl.h"
+#include "src/objects/turbofan-types-inl.h"
 
 #ifdef V8_INTL_SUPPORT
 #include "src/objects/js-break-iterator-inl.h"

src/objects/allocation-site.h

@@ -181,6 +181,8 @@ class AllocationMemento
 
   DECL_PRINTER(AllocationMemento)
 
+  using BodyDescriptor = StructBodyDescriptor;
+
   TQ_OBJECT_CONSTRUCTORS(AllocationMemento)
 };
 

src/objects/api-callbacks.h

@@ -14,6 +14,8 @@
 namespace v8 {
 namespace internal {
 
+class StructBodyDescriptor;
+
 #include "torque-generated/src/objects/api-callbacks-tq.inc"
 
 // An accessor must have a getter, but can have no setter.
@@ -66,6 +68,8 @@ class AccessorInfo : public TorqueGeneratedAccessorInfo<AccessorInfo, Struct> {
 
   DECL_PRINTER(AccessorInfo)
 
+  using BodyDescriptor = StructBodyDescriptor;
+
  private:
   inline bool HasExpectedReceiverType();
 
@@ -80,6 +84,8 @@ class AccessCheckInfo
  public:
   static AccessCheckInfo Get(Isolate* isolate, Handle<JSObject> receiver);
 
+  using BodyDescriptor = StructBodyDescriptor;
+
   TQ_OBJECT_CONSTRUCTORS(AccessCheckInfo)
 };
 
@@ -94,6 +100,8 @@ class InterceptorInfo
 
   DEFINE_TORQUE_GENERATED_INTERCEPTOR_INFO_FLAGS()
 
+  using BodyDescriptor = StructBodyDescriptor;
+
   TQ_OBJECT_CONSTRUCTORS(InterceptorInfo)
 };
 
@@ -113,6 +121,8 @@ class CallHandlerInfo
 
   Address redirected_callback() const;
 
+  using BodyDescriptor = StructBodyDescriptor;
+
   TQ_OBJECT_CONSTRUCTORS(CallHandlerInfo)
 };
 

src/objects/arguments.h

@@ -15,6 +15,8 @@
 namespace v8 {
 namespace internal {
 
+class StructBodyDescriptor;
+
 #include "torque-generated/src/objects/arguments-tq.inc"
 
 // Superclass for all objects with instance type {JS_ARGUMENTS_OBJECT_TYPE}
@@ -66,6 +68,8 @@ class AliasedArgumentsEntry
     : public TorqueGeneratedAliasedArgumentsEntry<AliasedArgumentsEntry,
                                                   Struct> {
  public:
+  using BodyDescriptor = StructBodyDescriptor;
+
   TQ_OBJECT_CONSTRUCTORS(AliasedArgumentsEntry)
 };
 

src/objects/debug-objects.h

@@ -21,6 +21,7 @@ namespace internal {
 
 class BreakPoint;
 class BytecodeArray;
+class StructBodyDescriptor;
 
 #include "torque-generated/src/objects/debug-objects-tq.inc"
 
@@ -132,6 +133,8 @@ class DebugInfo : public TorqueGeneratedDebugInfo<DebugInfo, Struct> {
 
   static const int kEstimatedNofBreakPointsInFunction = 4;
 
+  using BodyDescriptor = StructBodyDescriptor;
+
  private:
   // Get the break point info object for a source position.
   Object GetBreakPointInfo(Isolate* isolate, int source_position);
@@ -163,6 +166,8 @@ class BreakPointInfo
 
   int GetStatementPosition(Handle<DebugInfo> debug_info);
 
+  using BodyDescriptor = StructBodyDescriptor;
+
   TQ_OBJECT_CONSTRUCTORS(BreakPointInfo)
 };
 
@@ -193,6 +198,8 @@ class CoverageInfo
 // Holds breakpoint related information. This object is used by inspector.
 class BreakPoint : public TorqueGeneratedBreakPoint<BreakPoint, Struct> {
  public:
+  using BodyDescriptor = StructBodyDescriptor;
+
   TQ_OBJECT_CONSTRUCTORS(BreakPoint)
 };
 

src/objects/descriptor-array.h

@@ -24,6 +24,7 @@ template <typename T>
 class Handle;
 
 class Isolate;
+class StructBodyDescriptor;
 
 #include "torque-generated/src/objects/descriptor-array-tq.inc"
 
@@ -32,6 +33,8 @@ class EnumCache : public TorqueGeneratedEnumCache<EnumCache, Struct> {
  public:
   DECL_VERIFIER(EnumCache)
 
+  using BodyDescriptor = StructBodyDescriptor;
+
   TQ_OBJECT_CONSTRUCTORS(EnumCache)
 };
 

src/objects/free-space.h

@@ -37,6 +37,8 @@ class FreeSpace : public TorqueGeneratedFreeSpace<FreeSpace, HeapObject> {
   // Dispatched behavior.
   DECL_PRINTER(FreeSpace)
 
+  class BodyDescriptor;
+
  private:
   inline bool IsValid();
 

src/objects/heap-number.h

@@ -59,6 +59,8 @@ class HeapNumber
   DECL_PRINTER(HeapNumber)
   V8_EXPORT_PRIVATE void HeapNumberShortPrint(std::ostream& os);
 
+  class BodyDescriptor;
+
   TQ_OBJECT_CONSTRUCTORS(HeapNumber)
 };
 

src/objects/js-generator.h

@@ -16,6 +16,7 @@ namespace internal {
 
 // Forward declarations.
 class JSPromise;
+class StructBodyDescriptor;
 
 #include "torque-generated/src/objects/js-generator-tq.inc"
 
@@ -71,6 +72,8 @@ class AsyncGeneratorRequest
   DECL_PRINTER(AsyncGeneratorRequest)
   DECL_VERIFIER(AsyncGeneratorRequest)
 
+  using BodyDescriptor = StructBodyDescriptor;
+
   TQ_OBJECT_CONSTRUCTORS(AsyncGeneratorRequest)
 };
 

src/objects/literal-objects.h

@@ -16,6 +16,7 @@ namespace v8 {
 namespace internal {
 
 class ClassLiteral;
+class StructBodyDescriptor;
 
 #include "torque-generated/src/objects/literal-objects-tq.inc"
 
@@ -71,6 +72,8 @@ class ArrayBoilerplateDescription
   DECL_PRINTER(ArrayBoilerplateDescription)
   void BriefPrintDetails(std::ostream& os);
 
+  using BodyDescriptor = StructBodyDescriptor;
+
  private:
   TQ_OBJECT_CONSTRUCTORS(ArrayBoilerplateDescription)
 };
@@ -82,6 +85,8 @@ class RegExpBoilerplateDescription
   // Dispatched behavior.
   void BriefPrintDetails(std::ostream& os);
 
+  using BodyDescriptor = StructBodyDescriptor;
+
  private:
   TQ_OBJECT_CONSTRUCTORS(RegExpBoilerplateDescription)
 };

src/objects/microtask.h

@@ -14,6 +14,8 @@
 namespace v8 {
 namespace internal {
 
+class StructBodyDescriptor;
+
 #include "torque-generated/src/objects/microtask-tq.inc"
 
 // Abstract base class for all microtasks that can be scheduled on the
@@ -30,6 +32,8 @@ class Microtask : public TorqueGeneratedMicrotask<Microtask, Struct> {
 class CallbackTask
     : public TorqueGeneratedCallbackTask<CallbackTask, Microtask> {
  public:
+  using BodyDescriptor = StructBodyDescriptor;
+
   TQ_OBJECT_CONSTRUCTORS(CallbackTask)
 };
 
@@ -43,6 +47,8 @@ class CallableTask
   DECL_VERIFIER(CallableTask)
   void BriefPrintDetails(std::ostream& os);
 
+  using BodyDescriptor = StructBodyDescriptor;
+
   TQ_OBJECT_CONSTRUCTORS(CallableTask)
 };
 

src/objects/module.h

@@ -181,6 +181,9 @@ class ScriptOrModule
     : public TorqueGeneratedScriptOrModule<ScriptOrModule, Struct> {
  public:
   DECL_PRINTER(ScriptOrModule)
+
+  using BodyDescriptor = StructBodyDescriptor;
+
   TQ_OBJECT_CONSTRUCTORS(ScriptOrModule)
 };
 

src/objects/objects-body-descriptors-inl.h

@@ -8,20 +8,28 @@
 #include <algorithm>
 
 #include "src/codegen/reloc-info.h"
+#include "src/ic/handler-configuration.h"
 #include "src/objects/arguments-inl.h"
+#include "src/objects/bigint.h"
 #include "src/objects/cell.h"
 #include "src/objects/data-handler.h"
+#include "src/objects/fixed-array.h"
 #include "src/objects/foreign-inl.h"
+#include "src/objects/free-space-inl.h"
 #include "src/objects/hash-table.h"
+#include "src/objects/heap-number.h"
 #include "src/objects/js-collection.h"
 #include "src/objects/js-weak-refs.h"
+#include "src/objects/literal-objects.h"
 #include "src/objects/megadom-handler-inl.h"
 #include "src/objects/objects-body-descriptors.h"
-#include "src/objects/oddball.h"
 #include "src/objects/ordered-hash-table-inl.h"
+#include "src/objects/property-descriptor-object.h"
 #include "src/objects/source-text-module.h"
+#include "src/objects/stack-frame-info.h"
 #include "src/objects/swiss-name-dictionary-inl.h"
 #include "src/objects/synthetic-module.h"
+#include "src/objects/template-objects.h"
 #include "src/objects/torque-defined-classes-inl.h"
 #include "src/objects/transitions.h"
 #include "src/objects/turbofan-types-inl.h"
@@ -156,6 +164,34 @@ void BodyDescriptorBase::IterateCustomWeakPointer(HeapObject obj, int offset,
   v->VisitCustomWeakPointer(obj, obj.RawField(offset));
 }
 
+class HeapNumber::BodyDescriptor final : public BodyDescriptorBase {
+ public:
+  static bool IsValidSlot(Map map, HeapObject obj, int offset) { return false; }
+
+  template <typename ObjectVisitor>
+  static inline void IterateBody(Map map, HeapObject obj, int object_size,
+                                 ObjectVisitor* v) {}
+
+  static inline int SizeOf(Map map, HeapObject object) {
+    return HeapNumber::kSize;
+  }
+};
+
+// This is a descriptor for one/two pointer fillers.
+class FreeSpaceFillerBodyDescriptor final : public DataOnlyBodyDescriptor {
+ public:
+  static inline int SizeOf(Map map, HeapObject raw_object) {
+    return map.instance_size();
+  }
+};
+
+class FreeSpace::BodyDescriptor final : public DataOnlyBodyDescriptor {
+ public:
+  static inline int SizeOf(Map map, HeapObject raw_object) {
+    return FreeSpace::unchecked_cast(raw_object).Size();
+  }
+};
+
 class JSObject::BodyDescriptor final : public BodyDescriptorBase {
  public:
   static const int kStartOffset = JSReceiver::kPropertiesOrHashOffset;
@@ -955,38 +991,41 @@ class EmbedderDataArray::BodyDescriptor final : public BodyDescriptorBase {
   }
 };
 
-template <typename Op, typename ReturnType, typename T1, typename T2,
-          typename T3, typename T4>
-ReturnType BodyDescriptorApply(InstanceType type, T1 p1, T2 p2, T3 p3, T4 p4) {
+template <typename Op, typename... Args>
+auto BodyDescriptorApply(InstanceType type, Args&&... args) {
+#define CALL_APPLY(ClassName) \
+  Op::template apply<ClassName::BodyDescriptor>(std::forward<Args>(args)...)
+
   if (type < FIRST_NONSTRING_TYPE) {
     switch (type & kStringRepresentationMask) {
       case kSeqStringTag:
-        return ReturnType();
+        if ((type & kStringEncodingMask) == kOneByteStringTag) {
+          return CALL_APPLY(SeqOneByteString);
+        } else {
+          return CALL_APPLY(SeqTwoByteString);
+        }
       case kConsStringTag:
-        return Op::template apply<ConsString::BodyDescriptor>(p1, p2, p3, p4);
+        return CALL_APPLY(ConsString);
       case kThinStringTag:
-        return Op::template apply<ThinString::BodyDescriptor>(p1, p2, p3, p4);
+        return CALL_APPLY(ThinString);
       case kSlicedStringTag:
-        return Op::template apply<SlicedString::BodyDescriptor>(p1, p2, p3, p4);
+        return CALL_APPLY(SlicedString);
       case kExternalStringTag:
         if ((type & kStringEncodingMask) == kOneByteStringTag) {
-          return Op::template apply<ExternalOneByteString::BodyDescriptor>(
-              p1, p2, p3, p4);
+          return CALL_APPLY(ExternalOneByteString);
         } else {
-          return Op::template apply<ExternalTwoByteString::BodyDescriptor>(
-              p1, p2, p3, p4);
+          return CALL_APPLY(ExternalTwoByteString);
         }
     }
     UNREACHABLE();
   }
   if (InstanceTypeChecker::IsJSApiObject(type)) {
-    return Op::template apply<JSObject::BodyDescriptor>(p1, p2, p3, p4);
+    return CALL_APPLY(JSObject);
   }
 
   switch (type) {
     case EMBEDDER_DATA_ARRAY_TYPE:
-      return Op::template apply<EmbedderDataArray::BodyDescriptor>(p1, p2, p3,
-                                                                   p4);
+      return CALL_APPLY(EmbedderDataArray);
     case OBJECT_BOILERPLATE_DESCRIPTION_TYPE:
     case CLOSURE_FEEDBACK_CELL_ARRAY_TYPE:
     case HASH_TABLE_TYPE:
@@ -998,10 +1037,9 @@ ReturnType BodyDescriptorApply(InstanceType type, T1 p1, T2 p2, T3 p3, T4 p4) {
     case NUMBER_DICTIONARY_TYPE:
     case SIMPLE_NUMBER_DICTIONARY_TYPE:
     case SCRIPT_CONTEXT_TABLE_TYPE:
-      return Op::template apply<FixedArray::BodyDescriptor>(p1, p2, p3, p4);
+      return CALL_APPLY(FixedArray);
     case EPHEMERON_HASH_TABLE_TYPE:
-      return Op::template apply<EphemeronHashTable::BodyDescriptor>(p1, p2, p3,
-                                                                    p4);
+      return CALL_APPLY(EphemeronHashTable);
     case AWAIT_CONTEXT_TYPE:
     case BLOCK_CONTEXT_TYPE:
     case CATCH_CONTEXT_TYPE:
@@ -1011,45 +1049,38 @@ ReturnType BodyDescriptorApply(InstanceType type, T1 p1, T2 p2, T3 p3, T4 p4) {
     case MODULE_CONTEXT_TYPE:
     case SCRIPT_CONTEXT_TYPE:
     case WITH_CONTEXT_TYPE:
-      return Op::template apply<Context::BodyDescriptor>(p1, p2, p3, p4);
+      return CALL_APPLY(Context);
     case NATIVE_CONTEXT_TYPE:
-      return Op::template apply<NativeContext::BodyDescriptor>(p1, p2, p3, p4);
+      return CALL_APPLY(NativeContext);
     case FIXED_DOUBLE_ARRAY_TYPE:
-      return ReturnType();
+      return CALL_APPLY(FixedDoubleArray);
     case FEEDBACK_METADATA_TYPE:
-      return Op::template apply<FeedbackMetadata::BodyDescriptor>(p1, p2, p3,
-                                                                  p4);
+      return CALL_APPLY(FeedbackMetadata);
     case PROPERTY_ARRAY_TYPE:
-      return Op::template apply<PropertyArray::BodyDescriptor>(p1, p2, p3, p4);
+      return CALL_APPLY(PropertyArray);
     case TRANSITION_ARRAY_TYPE:
-      return Op::template apply<TransitionArray::BodyDescriptor>(p1, p2, p3,
-                                                                 p4);
+      return CALL_APPLY(TransitionArray);
     case FEEDBACK_CELL_TYPE:
-      return Op::template apply<FeedbackCell::BodyDescriptor>(p1, p2, p3, p4);
+      return CALL_APPLY(FeedbackCell);
     case COVERAGE_INFO_TYPE:
-      return Op::template apply<CoverageInfo::BodyDescriptor>(p1, p2, p3, p4);
+      return CALL_APPLY(CoverageInfo);
 #if V8_ENABLE_WEBASSEMBLY
     case WASM_API_FUNCTION_REF_TYPE:
-      return Op::template apply<WasmApiFunctionRef::BodyDescriptor>(p1, p2, p3,
-                                                                    p4);
+      return CALL_APPLY(WasmApiFunctionRef);
     case WASM_ARRAY_TYPE:
-      return Op::template apply<WasmArray::BodyDescriptor>(p1, p2, p3, p4);
+      return CALL_APPLY(WasmArray);
     case WASM_CAPI_FUNCTION_DATA_TYPE:
-      return Op::template apply<WasmCapiFunctionData::BodyDescriptor>(p1, p2,
-                                                                      p3, p4);
+      return CALL_APPLY(WasmCapiFunctionData);
     case WASM_EXPORTED_FUNCTION_DATA_TYPE:
-      return Op::template apply<WasmExportedFunctionData::BodyDescriptor>(
-          p1, p2, p3, p4);
+      return CALL_APPLY(WasmExportedFunctionData);
     case WASM_INTERNAL_FUNCTION_TYPE:
-      return Op::template apply<WasmInternalFunction::BodyDescriptor>(p1, p2,
-                                                                      p3, p4);
+      return CALL_APPLY(WasmInternalFunction);
     case WASM_JS_FUNCTION_DATA_TYPE:
-      return Op::template apply<WasmJSFunctionData::BodyDescriptor>(p1, p2, p3,
-                                                                    p4);
+      return CALL_APPLY(WasmJSFunctionData);
     case WASM_STRUCT_TYPE:
-      return Op::template apply<WasmStruct::BodyDescriptor>(p1, p2, p3, p4);
+      return CALL_APPLY(WasmStruct);
     case WASM_TYPE_INFO_TYPE:
-      return Op::template apply<WasmTypeInfo::BodyDescriptor>(p1, p2, p3, p4);
+      return CALL_APPLY(WasmTypeInfo);
 #endif  // V8_ENABLE_WEBASSEMBLY
     case JS_API_OBJECT_TYPE:
     case JS_ARGUMENTS_OBJECT_TYPE:
@@ -1134,111 +1165,97 @@ ReturnType BodyDescriptorApply(InstanceType type, T1 p1, T2 p2, T3 p3, T4 p4) {
     case WASM_TAG_OBJECT_TYPE:
     case WASM_VALUE_OBJECT_TYPE:
 #endif  // V8_ENABLE_WEBASSEMBLY
-      return Op::template apply<JSObject::BodyDescriptor>(p1, p2, p3, p4);
+      return CALL_APPLY(JSObject);
 #if V8_ENABLE_WEBASSEMBLY
     case WASM_INSTANCE_OBJECT_TYPE:
-      return Op::template apply<WasmInstanceObject::BodyDescriptor>(p1, p2, p3,
-                                                                    p4);
+      return CALL_APPLY(WasmInstanceObject);
 #endif  // V8_ENABLE_WEBASSEMBLY
     case JS_WEAK_MAP_TYPE:
     case JS_WEAK_SET_TYPE:
-      return Op::template apply<JSWeakCollection::BodyDescriptor>(p1, p2, p3,
-                                                                  p4);
+      return CALL_APPLY(JSWeakCollection);
     case JS_ARRAY_BUFFER_TYPE:
-      return Op::template apply<JSArrayBuffer::BodyDescriptor>(p1, p2, p3, p4);
+      return CALL_APPLY(JSArrayBuffer);
     case JS_DATA_VIEW_TYPE:
-      return Op::template apply<JSDataView::BodyDescriptor>(p1, p2, p3, p4);
+      return CALL_APPLY(JSDataView);
     case JS_TYPED_ARRAY_TYPE:
-      return Op::template apply<JSTypedArray::BodyDescriptor>(p1, p2, p3, p4);
+      return CALL_APPLY(JSTypedArray);
     case WEAK_CELL_TYPE:
-      return Op::template apply<WeakCell::BodyDescriptor>(p1, p2, p3, p4);
+      return CALL_APPLY(WeakCell);
     case JS_WEAK_REF_TYPE:
-      return Op::template apply<JSWeakRef::BodyDescriptor>(p1, p2, p3, p4);
+      return CALL_APPLY(JSWeakRef);
     case JS_PROXY_TYPE:
-      return Op::template apply<JSProxy::BodyDescriptor>(p1, p2, p3, p4);
+      return CALL_APPLY(JSProxy);
     case FOREIGN_TYPE:
-      return Op::template apply<Foreign::BodyDescriptor>(p1, p2, p3, p4);
+      return CALL_APPLY(Foreign);
     case MAP_TYPE:
-      return Op::template apply<Map::BodyDescriptor>(p1, p2, p3, p4);
+      return CALL_APPLY(Map);
     case CODE_TYPE:
-      return Op::template apply<Code::BodyDescriptor>(p1, p2, p3, p4);
+      return CALL_APPLY(Code);
     case CELL_TYPE:
-      return Op::template apply<Cell::BodyDescriptor>(p1, p2, p3, p4);
+      return CALL_APPLY(Cell);
     case PROPERTY_CELL_TYPE:
-      return Op::template apply<PropertyCell::BodyDescriptor>(p1, p2, p3, p4);
+      return CALL_APPLY(PropertyCell);
     case SYMBOL_TYPE:
-      return Op::template apply<Symbol::BodyDescriptor>(p1, p2, p3, p4);
+      return CALL_APPLY(Symbol);
     case BYTECODE_ARRAY_TYPE:
-      return Op::template apply<BytecodeArray::BodyDescriptor>(p1, p2, p3, p4);
+      return CALL_APPLY(BytecodeArray);
     case SMALL_ORDERED_HASH_SET_TYPE:
-      return Op::template apply<
-          SmallOrderedHashTable<SmallOrderedHashSet>::BodyDescriptor>(p1, p2,
-                                                                      p3, p4);
+      return CALL_APPLY(SmallOrderedHashTable<SmallOrderedHashSet>);
     case SMALL_ORDERED_HASH_MAP_TYPE:
-      return Op::template apply<
-          SmallOrderedHashTable<SmallOrderedHashMap>::BodyDescriptor>(p1, p2,
-                                                                      p3, p4);
+      return CALL_APPLY(SmallOrderedHashTable<SmallOrderedHashMap>);
     case SMALL_ORDERED_NAME_DICTIONARY_TYPE:
-      return Op::template apply<
-          SmallOrderedHashTable<SmallOrderedNameDictionary>::BodyDescriptor>(
-          p1, p2, p3, p4);
-
+      return CALL_APPLY(SmallOrderedHashTable<SmallOrderedNameDictionary>);
     case SWISS_NAME_DICTIONARY_TYPE:
-      return Op::template apply<SwissNameDictionary::BodyDescriptor>(p1, p2, p3,
-                                                                     p4);
-
+      return CALL_APPLY(SwissNameDictionary);
     case CODE_DATA_CONTAINER_TYPE:
-      return Op::template apply<CodeDataContainer::BodyDescriptor>(p1, p2, p3,
-                                                                   p4);
+      return CALL_APPLY(CodeDataContainer);
     case PREPARSE_DATA_TYPE:
-      return Op::template apply<PreparseData::BodyDescriptor>(p1, p2, p3, p4);
+      return CALL_APPLY(PreparseData);
     case HEAP_NUMBER_TYPE:
-    case FILLER_TYPE:
+      return CALL_APPLY(HeapNumber);
     case BYTE_ARRAY_TYPE:
-    case FREE_SPACE_TYPE:
+      return CALL_APPLY(BigInt);
     case BIGINT_TYPE:
-      return ReturnType();
+      return CALL_APPLY(BigInt);
     case ALLOCATION_SITE_TYPE:
-      return Op::template apply<AllocationSite::BodyDescriptor>(p1, p2, p3, p4);
+      return CALL_APPLY(AllocationSite);
 
-#define MAKE_STRUCT_CASE(TYPE, Name, name) case TYPE:
+#define MAKE_STRUCT_CASE(TYPE, Name, name) \
+  case TYPE:                               \
+    return CALL_APPLY(Name);
       STRUCT_LIST(MAKE_STRUCT_CASE)
 #undef MAKE_STRUCT_CASE
-      if (type == PROTOTYPE_INFO_TYPE) {
-        return Op::template apply<PrototypeInfo::BodyDescriptor>(p1, p2, p3,
-                                                                 p4);
-      }
-#if V8_ENABLE_WEBASSEMBLY
-      if (type == WASM_INDIRECT_FUNCTION_TABLE_TYPE) {
-        return Op::template apply<WasmIndirectFunctionTable::BodyDescriptor>(
-            p1, p2, p3, p4);
-      }
-#endif  // V8_ENABLE_WEBASSEMBLY
-      return Op::template apply<StructBodyDescriptor>(p1, p2, p3, p4);
     case CALL_HANDLER_INFO_TYPE:
-      return Op::template apply<StructBodyDescriptor>(p1, p2, p3, p4);
+      return CALL_APPLY(CallHandlerInfo);
     case LOAD_HANDLER_TYPE:
+      return CALL_APPLY(LoadHandler);
     case STORE_HANDLER_TYPE:
-      return Op::template apply<DataHandler::BodyDescriptor>(p1, p2, p3, p4);
+      return CALL_APPLY(StoreHandler);
     case SOURCE_TEXT_MODULE_TYPE:
-      return Op::template apply<SourceTextModule::BodyDescriptor>(p1, p2, p3,
-                                                                  p4);
+      return CALL_APPLY(SourceTextModule);
     case SYNTHETIC_MODULE_TYPE:
-      return Op::template apply<SyntheticModule::BodyDescriptor>(p1, p2, p3,
-                                                                 p4);
+      return CALL_APPLY(SyntheticModule);
 // TODO(turbofan): Avoid duplicated cases when the body descriptors are
 // identical.
 #define MAKE_TORQUE_BODY_DESCRIPTOR_APPLY(TYPE, TypeName) \
   case TYPE:                                              \
-    return Op::template apply<TypeName::BodyDescriptor>(p1, p2, p3, p4);
+    return CALL_APPLY(TypeName);
       TORQUE_INSTANCE_TYPE_TO_BODY_DESCRIPTOR_LIST(
           MAKE_TORQUE_BODY_DESCRIPTOR_APPLY)
 #undef MAKE_TORQUE_BODY_DESCRIPTOR_APPLY
 
+    case FILLER_TYPE:
+      return Op::template apply<FreeSpaceFillerBodyDescriptor>(
+          std::forward<Args>(args)...);
+
+    case FREE_SPACE_TYPE:
+      return CALL_APPLY(FreeSpace);
+
     default:
       PrintF("Unknown type: %d\n", type);
       UNREACHABLE();
   }
+#undef CALL_APPLY
 }
 
 template <typename ObjectVisitor>
@@ -1263,8 +1280,8 @@ struct CallIterateBody {
 
 template <typename ObjectVisitor>
 void HeapObject::IterateBodyFast(Map map, int object_size, ObjectVisitor* v) {
-  BodyDescriptorApply<CallIterateBody, void>(map.instance_type(), map, *this,
-                                             object_size, v);
+  BodyDescriptorApply<CallIterateBody>(map.instance_type(), map, *this,
+                                       object_size, v);
 }
 
 class EphemeronHashTable::BodyDescriptor final : public BodyDescriptorBase {

src/objects/objects-body-descriptors.h

@@ -152,7 +152,11 @@ class FlexibleBodyDescriptor : public SuffixRangeBodyDescriptor<start_offset> {
   static inline int SizeOf(Map map, HeapObject object);
 };
 
-using StructBodyDescriptor = FlexibleBodyDescriptor<HeapObject::kHeaderSize>;
+// A forward-declacable descriptor body alias for most of the Struct successors.
+class StructBodyDescriptor
+    : public FlexibleBodyDescriptor<HeapObject::kHeaderSize> {
+ public:
+};
 
 // This class describes a body of an object in which all pointer fields are
 // located in the [start_offset, object_size) interval.

src/objects/objects.cc

@@ -2172,15 +2172,15 @@ void HeapObject::IterateBody(Map map, int object_size, ObjectVisitor* v) {
 
 struct CallIsValidSlot {
   template <typename BodyDescriptor>
-  static bool apply(Map map, HeapObject obj, int offset, int) {
+  static bool apply(Map map, HeapObject obj, int offset) {
     return BodyDescriptor::IsValidSlot(map, obj, offset);
   }
 };
 
 bool HeapObject::IsValidSlot(Map map, int offset) {
   DCHECK_NE(0, offset);
-  return BodyDescriptorApply<CallIsValidSlot, bool>(map.instance_type(), map,
-                                                    *this, offset, 0);
+  return BodyDescriptorApply<CallIsValidSlot>(map.instance_type(), map, *this,
+                                              offset);
 }
 
 int HeapObject::SizeFromMap(Map map) const {

src/objects/promise.h

@@ -14,6 +14,7 @@ namespace v8 {
 namespace internal {
 
 class JSPromise;
+class StructBodyDescriptor;
 
 #include "torque-generated/src/objects/promise-tq.inc"
 
@@ -31,6 +32,9 @@ class PromiseReactionJobTask
                                                    Microtask> {
  public:
   static const int kSizeOfAllPromiseReactionJobTasks = kHeaderSize;
+
+  using BodyDescriptor = StructBodyDescriptor;
+
   TQ_OBJECT_CONSTRUCTORS(PromiseReactionJobTask)
 };
 
@@ -41,6 +45,8 @@ class PromiseFulfillReactionJobTask
  public:
   STATIC_ASSERT(kSize == kSizeOfAllPromiseReactionJobTasks);
 
+  using BodyDescriptor = StructBodyDescriptor;
+
   TQ_OBJECT_CONSTRUCTORS(PromiseFulfillReactionJobTask)
 };
 
@@ -51,6 +57,8 @@ class PromiseRejectReactionJobTask
  public:
   STATIC_ASSERT(kSize == kSizeOfAllPromiseReactionJobTasks);
 
+  using BodyDescriptor = StructBodyDescriptor;
+
   TQ_OBJECT_CONSTRUCTORS(PromiseRejectReactionJobTask)
 };
 
@@ -59,6 +67,8 @@ class PromiseResolveThenableJobTask
     : public TorqueGeneratedPromiseResolveThenableJobTask<
           PromiseResolveThenableJobTask, Microtask> {
  public:
+  using BodyDescriptor = StructBodyDescriptor;
+
   TQ_OBJECT_CONSTRUCTORS(PromiseResolveThenableJobTask)
 };
 
@@ -66,6 +76,8 @@ class PromiseResolveThenableJobTask
 class PromiseCapability
     : public TorqueGeneratedPromiseCapability<PromiseCapability, Struct> {
  public:
+  using BodyDescriptor = StructBodyDescriptor;
+
   TQ_OBJECT_CONSTRUCTORS(PromiseCapability)
 };
 
@@ -91,6 +103,8 @@ class PromiseReaction
  public:
   enum Type { kFulfill, kReject };
 
+  using BodyDescriptor = StructBodyDescriptor;
+
   TQ_OBJECT_CONSTRUCTORS(PromiseReaction)
 };
 

src/objects/property-descriptor-object.h

@@ -35,6 +35,8 @@ class PropertyDescriptorObject
                               HasWritableBit::kMask | HasValueBit::kMask |
                               HasGetBit::kMask | HasSetBit::kMask;
 
+  using BodyDescriptor = StructBodyDescriptor;
+
   TQ_OBJECT_CONSTRUCTORS(PropertyDescriptorObject)
 };
 

src/objects/script.h

@@ -22,6 +22,7 @@ namespace v8 {
 namespace internal {
 
 class FunctionLiteral;
+class StructBodyDescriptor;
 
 namespace wasm {
 class NativeModule;
@@ -230,6 +231,8 @@ class Script : public TorqueGeneratedScript<Script, Struct> {
   DECL_PRINTER(Script)
   DECL_VERIFIER(Script)
 
+  using BodyDescriptor = StructBodyDescriptor;
+
  private:
   // Bit positions in the flags field.
   DEFINE_TORQUE_GENERATED_SCRIPT_FLAGS()

src/objects/shared-function-info.h

@@ -148,6 +148,8 @@ class UncompiledDataWithPreparseData
 class InterpreterData
     : public TorqueGeneratedInterpreterData<InterpreterData, Struct> {
  public:
+  using BodyDescriptor = StructBodyDescriptor;
+
  private:
   TQ_OBJECT_CONSTRUCTORS(InterpreterData)
 };

src/objects/source-text-module.h

@@ -17,6 +17,7 @@ namespace v8 {
 namespace internal {
 
 class UnorderedModuleSet;
+class StructBodyDescriptor;
 
 #include "torque-generated/src/objects/source-text-module-tq.inc"
 
@@ -276,6 +277,8 @@ class ModuleRequest
   // a single assertion.
   static const size_t kAssertionEntrySize = 3;
 
+  using BodyDescriptor = StructBodyDescriptor;
+
   TQ_OBJECT_CONSTRUCTORS(ModuleRequest)
 };
 
@@ -292,6 +295,8 @@ class SourceTextModuleInfoEntry
       Handle<PrimitiveHeapObject> import_name, int module_request,
       int cell_index, int beg_pos, int end_pos);
 
+  using BodyDescriptor = StructBodyDescriptor;
+
   TQ_OBJECT_CONSTRUCTORS(SourceTextModuleInfoEntry)
 };
 

src/objects/stack-frame-info.h

@@ -16,6 +16,7 @@ namespace internal {
 
 class MessageLocation;
 class WasmInstanceObject;
+class StructBodyDescriptor;
 
 #include "torque-generated/src/objects/stack-frame-info-tq.inc"
 
@@ -86,6 +87,8 @@ class StackFrameInfo
   static bool ComputeLocation(Handle<StackFrameInfo> info,
                               MessageLocation* location);
 
+  using BodyDescriptor = StructBodyDescriptor;
+
  private:
   // Bit position in the flag, from least significant bit position.
   DEFINE_TORQUE_GENERATED_STACK_FRAME_INFO_FLAGS()

src/objects/struct.h

@@ -14,6 +14,8 @@
 namespace v8 {
 namespace internal {
 
+class StructBodyDescriptor;
+
 #include "torque-generated/src/objects/struct-tq.inc"
 
 // An abstract superclass, a marker class really, for simple structure classes.
@@ -31,6 +33,8 @@ class Tuple2 : public TorqueGeneratedTuple2<Tuple2, Struct> {
  public:
   void BriefPrintDetails(std::ostream& os);
 
+  using BodyDescriptor = StructBodyDescriptor;
+
   TQ_OBJECT_CONSTRUCTORS(Tuple2)
 };
 
@@ -69,6 +73,8 @@ class AccessorPair : public TorqueGeneratedAccessorPair<AccessorPair, Struct> {
 
   inline bool Equals(Object getter_value, Object setter_value);
 
+  using BodyDescriptor = StructBodyDescriptor;
+
   TQ_OBJECT_CONSTRUCTORS(AccessorPair)
 };
 
@@ -78,6 +84,8 @@ class ClassPositions
   // Dispatched behavior.
   void BriefPrintDetails(std::ostream& os);
 
+  using BodyDescriptor = StructBodyDescriptor;
+
   TQ_OBJECT_CONSTRUCTORS(ClassPositions)
 };
 

src/objects/template-objects.h

@@ -15,6 +15,8 @@
 namespace v8 {
 namespace internal {
 
+class StructBodyDescriptor;
+
 #include "torque-generated/src/objects/template-objects-tq.inc"
 
 // CachedTemplateObject is a tuple used to cache a TemplateObject that has been
@@ -27,6 +29,8 @@ class CachedTemplateObject final
                                           Handle<JSArray> template_object,
                                           Handle<HeapObject> next);
 
+  using BodyDescriptor = StructBodyDescriptor;
+
   TQ_OBJECT_CONSTRUCTORS(CachedTemplateObject)
 };
 
@@ -42,6 +46,8 @@ class TemplateObjectDescription final
       Handle<TemplateObjectDescription> description,
       Handle<SharedFunctionInfo> shared_info, int slot_id);
 
+  using BodyDescriptor = StructBodyDescriptor;
+
   TQ_OBJECT_CONSTRUCTORS(TemplateObjectDescription)
 };
 

src/objects/templates.h

@@ -14,6 +14,7 @@
 namespace v8 {
 
 class CFunctionInfo;
+class StructBodyDescriptor;
 
 namespace internal {
 
@@ -40,6 +41,8 @@ class TemplateInfo : public TorqueGeneratedTemplateInfo<TemplateInfo, Struct> {
   inline bool should_cache() const;
   inline bool is_cached() const;
 
+  using BodyDescriptor = StructBodyDescriptor;
+
   TQ_OBJECT_CONSTRUCTORS(TemplateInfo)
 };
 
@@ -49,6 +52,9 @@ class FunctionTemplateRareData
                                                      Struct> {
  public:
   DECL_VERIFIER(FunctionTemplateRareData)
+
+  using BodyDescriptor = StructBodyDescriptor;
+
   TQ_OBJECT_CONSTRUCTORS(FunctionTemplateRareData)
 };
 
@@ -176,6 +182,8 @@ class FunctionTemplateInfo
   // Bit position in the flag, from least significant bit position.
   DEFINE_TORQUE_GENERATED_FUNCTION_TEMPLATE_INFO_FLAGS()
 
+  using BodyDescriptor = StructBodyDescriptor;
+
  private:
   static constexpr int kNoJSApiObjectType = 0;
   static inline FunctionTemplateRareData EnsureFunctionTemplateRareData(
@@ -202,6 +210,8 @@ class ObjectTemplateInfo
   // chain till a function template that has an instance template is found.
   inline ObjectTemplateInfo GetParent(Isolate* isolate);
 
+  using BodyDescriptor = StructBodyDescriptor;
+
  private:
   DEFINE_TORQUE_GENERATED_OBJECT_TEMPLATE_INFO_FLAGS()
 

src/profiler/heap-snapshot-generator.cc

@@ -29,7 +29,6 @@
 #include "src/objects/js-regexp-inl.h"
 #include "src/objects/js-weak-refs-inl.h"
 #include "src/objects/literal-objects-inl.h"
-#include "src/objects/objects-body-descriptors.h"
 #include "src/objects/objects-inl.h"
 #include "src/objects/prototype.h"
 #include "src/objects/slots-inl.h"

src/wasm/wasm-objects.h

@@ -42,6 +42,7 @@ class WireBytesRef;
 class BreakPoint;
 class JSArrayBuffer;
 class SeqOneByteString;
+class StructBodyDescriptor;
 class WasmCapiFunction;
 class WasmExceptionTag;
 class WasmExportedFunction;
@@ -858,6 +859,8 @@ class WasmExceptionTag
   V8_EXPORT_PRIVATE static Handle<WasmExceptionTag> New(Isolate* isolate,
                                                         int index);
 
+  using BodyDescriptor = StructBodyDescriptor;
+
   TQ_OBJECT_CONSTRUCTORS(WasmExceptionTag)
 };
 
@@ -871,6 +874,8 @@ class AsmWasmData : public TorqueGeneratedAsmWasmData<AsmWasmData, Struct> {
 
   DECL_PRINTER(AsmWasmData)
 
+  using BodyDescriptor = StructBodyDescriptor;
+
   TQ_OBJECT_CONSTRUCTORS(AsmWasmData)
 };
 
@@ -994,12 +999,15 @@ class WasmContinuationObject
                                             WasmContinuationObject parent);
 
   DECL_PRINTER(WasmContinuationObject)
-  TQ_OBJECT_CONSTRUCTORS(WasmContinuationObject)
+
+  using BodyDescriptor = StructBodyDescriptor;
 
  private:
   static Handle<WasmContinuationObject> New(
       Isolate* isolate, std::unique_ptr<wasm::StackMemory> stack,
       HeapObject parent);
+
+  TQ_OBJECT_CONSTRUCTORS(WasmContinuationObject)
 };
 
 // The suspender object provides an API to suspend and resume wasm code using