[objects] Rename macros from DECLARE_ to DECL_ for consistency.

src/objects.h

 // Copyright 2015 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_H_
 #define V8_OBJECTS_H_
 
 #include <iosfwd>
 #include <memory>
 
@@ skipping 948 matching lines @@
 class WeakCell;
 class TransitionArray;
 class TemplateList;
 template <typename T>
 class ZoneForwardList;
 
 // A template-ized version of the IsXXX functions.
 template <class C> inline bool Is(Object* obj);
 
 #ifdef OBJECT_PRINT
-#define DECLARE_PRINTER(Name) void Name##Print(std::ostream& os);  // NOLINT
+#define DECL_PRINTER(Name) void Name##Print(std::ostream& os);  // NOLINT
 #else
-#define DECLARE_PRINTER(Name)
+#define DECL_PRINTER(Name)
 #endif
 
 #define OBJECT_TYPE_LIST(V) \
   V(Smi)                    \
   V(LayoutDescriptor)       \
   V(HeapObject)             \
   V(Primitive)              \
   V(Number)
 
 #define HEAP_OBJECT_TYPE_LIST(V)       \
@@ skipping 183 matching lines @@
     }                                               \
   } while (false)
 
 #define MAYBE_RETURN(call, value)         \
   do {                                    \
     if ((call).IsNothing()) return value; \
   } while (false)
 
 #define MAYBE_RETURN_NULL(call) MAYBE_RETURN(call, MaybeHandle<Object>())
 
-#define DECLARE_STRUCT_PREDICATE(NAME, Name, name) \
-  INLINE(bool Is##Name() const);
-  STRUCT_LIST(DECLARE_STRUCT_PREDICATE)
-#undef DECLARE_STRUCT_PREDICATE
+#define DECL_STRUCT_PREDICATE(NAME, Name, name) INLINE(bool Is##Name() const);
+  STRUCT_LIST(DECL_STRUCT_PREDICATE)
+#undef DECL_STRUCT_PREDICATE
 
   // ES6, #sec-isarray.  NOT to be confused with %_IsArray.
   INLINE(MUST_USE_RESULT static Maybe<bool> IsArray(Handle<Object> object));
 
   INLINE(bool IsNameDictionary() const);
   INLINE(bool IsGlobalDictionary() const);
   INLINE(bool IsSeededNumberDictionary() const);
   INLINE(bool IsOrderedHashSet() const);
   INLINE(bool IsOrderedHashMap() const);
   INLINE(bool IsSmallOrderedHashTable() const);
@@ skipping 287 matching lines @@
   // Tries to convert an object to an array index. Returns true and sets the
   // output parameter if it succeeds. Equivalent to ToArrayLength, but does not
   // allow kMaxUInt32.
   inline bool ToArrayIndex(uint32_t* index);
 
   // Returns true if the result of iterating over the object is the same
   // (including observable effects) as simply accessing the properties between 0
   // and length.
   bool IterationHasObservableEffects();
 
-  DECLARE_VERIFIER(Object)
+  DECL_VERIFIER(Object)
 #ifdef VERIFY_HEAP
   // Verify a pointer is a valid object pointer.
   static void VerifyPointer(Object* p);
 #endif
 
   inline void VerifyApiCallResultType();
 
   // Prints this object without details.
   void ShortPrint(FILE* out = stdout);
 
   // Prints this object without details to a message accumulator.
   void ShortPrint(StringStream* accumulator);
 
   void ShortPrint(std::ostream& os);  // NOLINT
 
-  DECLARE_CAST(Object)
+  DECL_CAST(Object)
 
   // Layout description.
   static const int kHeaderSize = 0;  // Object does not take up any space.
 
 #ifdef OBJECT_PRINT
   // For our gdb macros, we should perhaps change these in the future.
   void Print();
 
   // Prints this object with details.
   void Print(std::ostream& os);  // NOLINT
@@ skipping 87 matching lines @@
     return FromInt(static_cast<int>(value));
   }
 
   // Returns whether value can be represented in a Smi.
   static inline bool IsValid(intptr_t value) {
     bool result = Internals::IsValidSmi(value);
     DCHECK_EQ(result, value >= kMinValue && value <= kMaxValue);
     return result;
   }
 
-  DECLARE_CAST(Smi)
+  DECL_CAST(Smi)
 
   // Dispatched behavior.
   V8_EXPORT_PRIVATE void SmiPrint(std::ostream& os) const;  // NOLINT
-  DECLARE_VERIFIER(Smi)
+  DECL_VERIFIER(Smi)
 
   static constexpr Smi* const kZero = nullptr;
   static const int kMinValue =
       (static_cast<unsigned int>(-1)) << (kSmiValueSize - 1);
   static const int kMaxValue = -(kMinValue + 1);
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(Smi);
 };
 
@@ skipping 89 matching lines @@
   HEAP_OBJECT_TYPE_LIST(IS_TYPE_FUNCTION_DECL)
 #undef IS_TYPE_FUNCTION_DECL
 
 #define IS_TYPE_FUNCTION_DECL(Type, Value) \
   INLINE(bool Is##Type(Isolate* isolate) const);
   ODDBALL_LIST(IS_TYPE_FUNCTION_DECL)
 #undef IS_TYPE_FUNCTION_DECL
 
   INLINE(bool IsNullOrUndefined(Isolate* isolate) const);
 
-#define DECLARE_STRUCT_PREDICATE(NAME, Name, name) \
-  INLINE(bool Is##Name() const);
-  STRUCT_LIST(DECLARE_STRUCT_PREDICATE)
-#undef DECLARE_STRUCT_PREDICATE
+#define DECL_STRUCT_PREDICATE(NAME, Name, name) INLINE(bool Is##Name() const);
+  STRUCT_LIST(DECL_STRUCT_PREDICATE)
+#undef DECL_STRUCT_PREDICATE
 
   // Converts an address to a HeapObject pointer.
   static inline HeapObject* FromAddress(Address address) {
     DCHECK_TAG_ALIGNED(address);
     return reinterpret_cast<HeapObject*>(address + kHeapObjectTag);
   }
 
   // Returns the address of this HeapObject.
   inline Address address() {
     return reinterpret_cast<Address>(this) - kHeapObjectTag;
@@ skipping 42 matching lines @@
   // during marking GC.
   static inline Object** RawField(HeapObject* obj, int offset);
 
   // Adds the |code| object related to |name| to the code cache of this map. If
   // this map is a dictionary map that is shared, the map copied and installed
   // onto the object.
   static void UpdateMapCodeCache(Handle<HeapObject> object,
                                  Handle<Name> name,
                                  Handle<Code> code);
 
-  DECLARE_CAST(HeapObject)
+  DECL_CAST(HeapObject)
 
   // Return the write barrier mode for this. Callers of this function
   // must be able to present a reference to an DisallowHeapAllocation
   // object as a sign that they are not going to use this function
   // from code that allocates and thus invalidates the returned write
   // barrier mode.
   inline WriteBarrierMode GetWriteBarrierMode(
       const DisallowHeapAllocation& promise);
 
   // Dispatched behavior.
   void HeapObjectShortPrint(std::ostream& os);  // NOLINT
 #ifdef OBJECT_PRINT
   void PrintHeader(std::ostream& os, const char* id);  // NOLINT
 #endif
-  DECLARE_PRINTER(HeapObject)
-  DECLARE_VERIFIER(HeapObject)
+  DECL_PRINTER(HeapObject)
+  DECL_VERIFIER(HeapObject)
 #ifdef VERIFY_HEAP
   inline void VerifyObjectField(int offset);
   inline void VerifySmiField(int offset);
 
   // Verify a pointer is a valid HeapObject pointer that points to object
   // areas in the heap.
   static void VerifyHeapPointer(Object* p);
 #endif
 
   inline AllocationAlignment RequiredAlignment();
@@ skipping 22 matching lines @@
 // represented in a Smi (small integer)
 class HeapNumber: public HeapObject {
  public:
   // [value]: number value.
   inline double value() const;
   inline void set_value(double value);
 
   inline uint64_t value_as_bits() const;
   inline void set_value_as_bits(uint64_t bits);
 
-  DECLARE_CAST(HeapNumber)
+  DECL_CAST(HeapNumber)
 
   // Dispatched behavior.
   bool HeapNumberBooleanValue();
 
   V8_EXPORT_PRIVATE void HeapNumberPrint(std::ostream& os);  // NOLINT
-  DECLARE_VERIFIER(HeapNumber)
+  DECL_VERIFIER(HeapNumber)
 
   inline int get_exponent();
   inline int get_sign();
 
   // Layout description.
   static const int kValueOffset = HeapObject::kHeaderSize;
   // IEEE doubles are two 32 bit words.  The first is just mantissa, the second
   // is a mixture of sign, exponent and mantissa. The offsets of two 32 bit
   // words within double numbers are endian dependent and they are set
   // accordingly.
@@ skipping 56 matching lines @@
   // slow case.
   DECL_ACCESSORS(properties, FixedArray)  // Get and set fast properties.
   inline void initialize_properties();
   inline bool HasFastProperties();
   // Gets slow properties for non-global objects.
   inline NameDictionary* property_dictionary();
 
   // Deletes an existing named property in a normalized object.
   static void DeleteNormalizedProperty(Handle<JSReceiver> object, int entry);
 
-  DECLARE_CAST(JSReceiver)
+  DECL_CAST(JSReceiver)
 
   // ES6 section 7.1.1 ToPrimitive
   MUST_USE_RESULT static MaybeHandle<Object> ToPrimitive(
       Handle<JSReceiver> receiver,
       ToPrimitiveHint hint = ToPrimitiveHint::kDefault);
 
   // ES6 section 7.1.1.1 OrdinaryToPrimitive
   MUST_USE_RESULT static MaybeHandle<Object> OrdinaryToPrimitive(
       Handle<JSReceiver> receiver, OrdinaryToPrimitiveHint hint);
 
@@ skipping 549 matching lines @@
   bool ReferencesObject(Object* obj);
 
   MUST_USE_RESULT static Maybe<bool> TestIntegrityLevel(Handle<JSObject> object,
                                                         IntegrityLevel lvl);
 
   MUST_USE_RESULT static Maybe<bool> PreventExtensions(
       Handle<JSObject> object, ShouldThrow should_throw);
 
   static bool IsExtensible(Handle<JSObject> object);
 
-  DECLARE_CAST(JSObject)
+  DECL_CAST(JSObject)
 
   // Dispatched behavior.
   void JSObjectShortPrint(StringStream* accumulator);
-  DECLARE_PRINTER(JSObject)
-  DECLARE_VERIFIER(JSObject)
+  DECL_PRINTER(JSObject)
+  DECL_VERIFIER(JSObject)
 #ifdef OBJECT_PRINT
   bool PrintProperties(std::ostream& os);  // NOLINT
   void PrintElements(std::ostream& os);    // NOLINT
 #endif
 #if defined(DEBUG) || defined(OBJECT_PRINT)
   void PrintTransitions(std::ostream& os);  // NOLINT
 #endif
 
   static void PrintElementsTransition(
       FILE* file, Handle<JSObject> object,
@@ skipping 191 matching lines @@
 class FixedArrayBase: public HeapObject {
  public:
   // [length]: length of the array.
   inline int length() const;
   inline void set_length(int value);
 
   // Get and set the length using acquire loads and release stores.
   inline int synchronized_length() const;
   inline void synchronized_set_length(int value);
 
-  DECLARE_CAST(FixedArrayBase)
+  DECL_CAST(FixedArrayBase)
 
   static int GetMaxLengthForNewSpaceAllocation(ElementsKind kind);
 
   bool IsCowArray() const;
 
   // Layout description.
   // Length is smi tagged when it is stored.
   static const int kLengthOffset = HeapObject::kHeaderSize;
   static const int kHeaderSize = kLengthOffset + kPointerSize;
 };
@@ skipping 55 matching lines @@
   static constexpr int SizeFor(int length) {
     return kHeaderSize + length * kPointerSize;
   }
 
   // Code Generation support.
   static constexpr int OffsetOfElementAt(int index) { return SizeFor(index); }
 
   // Garbage collection support.
   inline Object** RawFieldOfElementAt(int index);
 
-  DECLARE_CAST(FixedArray)
+  DECL_CAST(FixedArray)
 
   // Maximal allowed size, in bytes, of a single FixedArray.
   // Prevents overflowing size computations, as well as extreme memory
   // consumption.
   static const int kMaxSize = 128 * MB * kPointerSize;
   // Maximally allowed length of a FixedArray.
   static const int kMaxLength = (kMaxSize - kHeaderSize) / kPointerSize;
   // Maximally allowed length for regular (non large object space) object.
   STATIC_ASSERT(kMaxRegularHeapObjectSize < kMaxSize);
   static const int kMaxRegularLength =
       (kMaxRegularHeapObjectSize - kHeaderSize) / kPointerSize;
 
   // Dispatched behavior.
-  DECLARE_PRINTER(FixedArray)
-  DECLARE_VERIFIER(FixedArray)
+  DECL_PRINTER(FixedArray)
+  DECL_VERIFIER(FixedArray)
 #ifdef DEBUG
   // Checks if two FixedArrays have identical contents.
   bool IsEqualTo(FixedArray* other);
 #endif
 
   typedef FlexibleBodyDescriptor<kHeaderSize> BodyDescriptor;
   // No weak fields.
   typedef BodyDescriptor BodyDescriptorWeak;
 
  protected:
@@ skipping 31 matching lines @@
   }
 
   // Gives access to raw memory which stores the array's data.
   inline double* data_start();
 
   inline void FillWithHoles(int from, int to);
 
   // Code Generation support.
   static int OffsetOfElementAt(int index) { return SizeFor(index); }
 
-  DECLARE_CAST(FixedDoubleArray)
+  DECL_CAST(FixedDoubleArray)
 
   // Maximal allowed size, in bytes, of a single FixedDoubleArray.
   // Prevents overflowing size computations, as well as extreme memory
   // consumption.
   static const int kMaxSize = 512 * MB;
   // Maximally allowed length of a FixedArray.
   static const int kMaxLength = (kMaxSize - kHeaderSize) / kDoubleSize;
 
   // Dispatched behavior.
-  DECLARE_PRINTER(FixedDoubleArray)
-  DECLARE_VERIFIER(FixedDoubleArray)
+  DECL_PRINTER(FixedDoubleArray)
+  DECL_VERIFIER(FixedDoubleArray)
 
   class BodyDescriptor;
   // No weak fields.
   typedef BodyDescriptor BodyDescriptorWeak;
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(FixedDoubleArray);
 };
 
 class WeakFixedArray : public FixedArray {
@@ skipping 34 matching lines @@
    private:
     int index_;
     WeakFixedArray* list_;
 #ifdef DEBUG
     int last_used_index_;
     DisallowHeapAllocation no_gc_;
 #endif  // DEBUG
     DISALLOW_COPY_AND_ASSIGN(Iterator);
   };
 
-  DECLARE_CAST(WeakFixedArray)
+  DECL_CAST(WeakFixedArray)
 
  private:
   static const int kLastUsedIndexIndex = 0;
   static const int kFirstIndex = 1;
 
   static Handle<WeakFixedArray> Allocate(
       Isolate* isolate, int size, Handle<WeakFixedArray> initialize_from);
 
   static void Set(Handle<WeakFixedArray> array, int index,
                   Handle<HeapObject> value);
@@ skipping 44 matching lines @@
   inline void Set(int index, Object* obj,
                   WriteBarrierMode mode = UPDATE_WRITE_BARRIER);
 
   // Set the element at index to undefined. This does not change the Length().
   inline void Clear(int index, Object* undefined);
 
   // Return a copy of the list of size Length() without the first entry. The
   // number returned by Length() is stored in the first entry.
   Handle<FixedArray> Elements() const;
   bool IsFull();
-  DECLARE_CAST(ArrayList)
+  DECL_CAST(ArrayList)
 
  private:
   static Handle<ArrayList> EnsureSpace(Handle<ArrayList> array, int length);
   static const int kLengthIndex = 0;
   static const int kFirstIndex = 1;
   DISALLOW_IMPLICIT_CONSTRUCTORS(ArrayList);
 };
 
 enum SearchMode { ALL_ENTRIES, VALID_ENTRIES };
 
@@ skipping 52 matching lines @@
   // Lookup handler in a table based on return addresses.
   int LookupReturn(int pc_offset);
 
   // Returns the number of entries in the table.
   inline int NumberOfRangeEntries() const;
 
   // Returns the required length of the underlying fixed array.
   static int LengthForRange(int entries) { return entries * kRangeEntrySize; }
   static int LengthForReturn(int entries) { return entries * kReturnEntrySize; }
 
-  DECLARE_CAST(HandlerTable)
+  DECL_CAST(HandlerTable)
 
 #ifdef ENABLE_DISASSEMBLER
   void HandlerTableRangePrint(std::ostream& os);   // NOLINT
   void HandlerTableReturnPrint(std::ostream& os);  // NOLINT
 #endif
 
  private:
   // Layout description for handler table based on ranges.
   static const int kRangeStartIndex = 0;
   static const int kRangeEndIndex = 1;
@@ skipping 46 matching lines @@
   }
 
   // Returns data start address.
   inline Address GetDataStartAddress();
 
   inline int DataSize() const;
 
   // Returns a pointer to the ByteArray object for a given data start address.
   static inline ByteArray* FromDataStartAddress(Address address);
 
-  DECLARE_CAST(ByteArray)
+  DECL_CAST(ByteArray)
 
   // Dispatched behavior.
   inline int ByteArraySize();
-  DECLARE_PRINTER(ByteArray)
-  DECLARE_VERIFIER(ByteArray)
+  DECL_PRINTER(ByteArray)
+  DECL_VERIFIER(ByteArray)
 
   // Layout description.
   static const int kAlignedSize = OBJECT_POINTER_ALIGN(kHeaderSize);
 
   // Maximal memory consumption for a single ByteArray.
   static const int kMaxSize = 512 * MB;
   // Maximal length of a single ByteArray.
   static const int kMaxLength = kMaxSize - kHeaderSize;
 
   class BodyDescriptor;
@@ skipping 18 matching lines @@
   T get(int index) {
     T result;
     copy_out(index, &result);
     return result;
   }
   void set(int index, const T& value) {
     copy_in(index * sizeof(T), reinterpret_cast<const byte*>(&value),
             sizeof(T));
   }
   int length() { return ByteArray::length() / sizeof(T); }
-  DECLARE_CAST(PodArray<T>)
+  DECL_CAST(PodArray<T>)
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(PodArray<T>);
 };
 
 // BytecodeArray represents a sequence of interpreter bytecodes.
 class BytecodeArray : public FixedArrayBase {
  public:
-#define DECLARE_BYTECODE_AGE_ENUM(X) k##X##BytecodeAge,
+#define DECL_BYTECODE_AGE_ENUM(X) k##X##BytecodeAge,
   enum Age {
     kNoAgeBytecodeAge = 0,
-    CODE_AGE_LIST(DECLARE_BYTECODE_AGE_ENUM) kAfterLastBytecodeAge,
+    CODE_AGE_LIST(DECL_BYTECODE_AGE_ENUM) kAfterLastBytecodeAge,
     kFirstBytecodeAge = kNoAgeBytecodeAge,
     kLastBytecodeAge = kAfterLastBytecodeAge - 1,
     kBytecodeAgeCount = kAfterLastBytecodeAge - kFirstBytecodeAge - 1,
     kIsOldBytecodeAge = kSexagenarianBytecodeAge
   };
-#undef DECLARE_BYTECODE_AGE_ENUM
+#undef DECL_BYTECODE_AGE_ENUM
 
   static int SizeFor(int length) {
     return OBJECT_POINTER_ALIGN(kHeaderSize + length);
   }
 
   // Setter and getter
   inline byte get(int index);
   inline void set(int index, byte value);
 
   // Returns data start address.
@@ skipping 27 matching lines @@
 
   // Accessors for handler table containing offsets of exception handlers.
   DECL_ACCESSORS(handler_table, FixedArray)
 
   // Accessors for source position table containing mappings between byte code
   // offset and source position or SourcePositionTableWithFrameCache.
   DECL_ACCESSORS(source_position_table, Object)
 
   inline ByteArray* SourcePositionTable();
 
-  DECLARE_CAST(BytecodeArray)
+  DECL_CAST(BytecodeArray)
 
   // Dispatched behavior.
   inline int BytecodeArraySize();
 
   inline int instruction_size();
 
   // Returns the size of bytecode and its metadata. This includes the size of
   // bytecode, constant pool, source position table, and handler table.
   inline int SizeIncludingMetadata();
 
   int SourcePosition(int offset);
   int SourceStatementPosition(int offset);
 
-  DECLARE_PRINTER(BytecodeArray)
-  DECLARE_VERIFIER(BytecodeArray)
+  DECL_PRINTER(BytecodeArray)
+  DECL_VERIFIER(BytecodeArray)
 
   void Disassemble(std::ostream& os);
 
   void CopyBytecodesTo(BytecodeArray* to);
 
   // Bytecode aging
   bool IsOld() const;
   void MakeOlder();
 
   // Layout description.
@@ skipping 41 matching lines @@
 
   inline int Size();
 
   // Accessors for the next field.
   inline FreeSpace* next();
   inline void set_next(FreeSpace* next);
 
   inline static FreeSpace* cast(HeapObject* obj);
 
   // Dispatched behavior.
-  DECLARE_PRINTER(FreeSpace)
-  DECLARE_VERIFIER(FreeSpace)
+  DECL_PRINTER(FreeSpace)
+  DECL_VERIFIER(FreeSpace)
 
   // Layout description.
   // Size is smi tagged when it is stored.
   static const int kSizeOffset = HeapObject::kHeaderSize;
   static const int kNextOffset = POINTER_SIZE_ALIGN(kSizeOffset + kPointerSize);
   static const int kSize = kNextOffset + kPointerSize;
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(FreeSpace);
 };
@@ skipping 16 matching lines @@
  public:
   // [base_pointer]: Either points to the FixedTypedArrayBase itself or nullptr.
   DECL_ACCESSORS(base_pointer, Object)
 
   // [external_pointer]: Contains the offset between base_pointer and the start
   // of the data. If the base_pointer is a nullptr, the external_pointer
   // therefore points to the actual backing store.
   DECL_ACCESSORS(external_pointer, void)
 
   // Dispatched behavior.
-  DECLARE_CAST(FixedTypedArrayBase)
+  DECL_CAST(FixedTypedArrayBase)
 
   static const int kBasePointerOffset = FixedArrayBase::kHeaderSize;
   static const int kExternalPointerOffset = kBasePointerOffset + kPointerSize;
   static const int kHeaderSize =
       DOUBLE_POINTER_ALIGN(kExternalPointerOffset + kPointerSize);
 
   static const int kDataOffset = kHeaderSize;
 
   static const int kMaxElementSize = 8;
 
@@ skipping 28 matching lines @@
   DISALLOW_IMPLICIT_CONSTRUCTORS(FixedTypedArrayBase);
 };
 
 
 template <class Traits>
 class FixedTypedArray: public FixedTypedArrayBase {
  public:
   typedef typename Traits::ElementType ElementType;
   static const InstanceType kInstanceType = Traits::kInstanceType;
 
-  DECLARE_CAST(FixedTypedArray<Traits>)
+  DECL_CAST(FixedTypedArray<Traits>)
 
   inline ElementType get_scalar(int index);
   static inline Handle<Object> get(FixedTypedArray* array, int index);
   inline void set(int index, ElementType value);
 
   static inline ElementType from(int value);
   static inline ElementType from(uint32_t value);
   static inline ElementType from(double value);
 
   // This accessor applies the correct conversion from Smi, HeapNumber
   // and undefined.
   inline void SetValue(uint32_t index, Object* value);
 
-  DECLARE_PRINTER(FixedTypedArray)
-  DECLARE_VERIFIER(FixedTypedArray)
+  DECL_PRINTER(FixedTypedArray)
+  DECL_VERIFIER(FixedTypedArray)
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(FixedTypedArray);
 };
 
 #define FIXED_TYPED_ARRAY_TRAITS(Type, type, TYPE, elementType, size)    \
   STATIC_ASSERT(size <= FixedTypedArrayBase::kMaxElementSize);           \
   class Type##ArrayTraits {                                              \
    public: /* NOLINT */                                                  \
     typedef elementType ElementType;                                     \
@@ skipping 31 matching lines @@
   static const int kFirstDeoptEntryIndex = 9;
 
   // Offsets of deopt entry elements relative to the start of the entry.
   static const int kAstIdRawOffset = 0;
   static const int kTranslationIndexOffset = 1;
   static const int kArgumentsStackHeightOffset = 2;
   static const int kPcOffset = 3;
   static const int kDeoptEntrySize = 4;
 
   // Simple element accessors.
-#define DECLARE_ELEMENT_ACCESSORS(name, type) \
-  inline type* name();                        \
+#define DECL_ELEMENT_ACCESSORS(name, type) \
+  inline type* name();                     \
   inline void Set##name(type* value);
 
-  DECLARE_ELEMENT_ACCESSORS(TranslationByteArray, ByteArray)
-  DECLARE_ELEMENT_ACCESSORS(InlinedFunctionCount, Smi)
-  DECLARE_ELEMENT_ACCESSORS(LiteralArray, FixedArray)
-  DECLARE_ELEMENT_ACCESSORS(OsrAstId, Smi)
-  DECLARE_ELEMENT_ACCESSORS(OsrPcOffset, Smi)
-  DECLARE_ELEMENT_ACCESSORS(OptimizationId, Smi)
-  DECLARE_ELEMENT_ACCESSORS(SharedFunctionInfo, Object)
-  DECLARE_ELEMENT_ACCESSORS(WeakCellCache, Object)
-  DECLARE_ELEMENT_ACCESSORS(InliningPositions, PodArray<InliningPosition>)
+  DECL_ELEMENT_ACCESSORS(TranslationByteArray, ByteArray)
+  DECL_ELEMENT_ACCESSORS(InlinedFunctionCount, Smi)
+  DECL_ELEMENT_ACCESSORS(LiteralArray, FixedArray)
+  DECL_ELEMENT_ACCESSORS(OsrAstId, Smi)
+  DECL_ELEMENT_ACCESSORS(OsrPcOffset, Smi)
+  DECL_ELEMENT_ACCESSORS(OptimizationId, Smi)
+  DECL_ELEMENT_ACCESSORS(SharedFunctionInfo, Object)
+  DECL_ELEMENT_ACCESSORS(WeakCellCache, Object)
+  DECL_ELEMENT_ACCESSORS(InliningPositions, PodArray<InliningPosition>)
 
-#undef DECLARE_ELEMENT_ACCESSORS
+#undef DECL_ELEMENT_ACCESSORS
 
-  // Accessors for elements of the ith deoptimization entry.
-#define DECLARE_ENTRY_ACCESSORS(name, type) \
-  inline type* name(int i);                 \
+// Accessors for elements of the ith deoptimization entry.
+#define DECL_ENTRY_ACCESSORS(name, type) \
+  inline type* name(int i);              \
   inline void Set##name(int i, type* value);
 
-  DECLARE_ENTRY_ACCESSORS(AstIdRaw, Smi)
-  DECLARE_ENTRY_ACCESSORS(TranslationIndex, Smi)
-  DECLARE_ENTRY_ACCESSORS(ArgumentsStackHeight, Smi)
-  DECLARE_ENTRY_ACCESSORS(Pc, Smi)
+  DECL_ENTRY_ACCESSORS(AstIdRaw, Smi)
+  DECL_ENTRY_ACCESSORS(TranslationIndex, Smi)
+  DECL_ENTRY_ACCESSORS(ArgumentsStackHeight, Smi)
+  DECL_ENTRY_ACCESSORS(Pc, Smi)
 
-#undef DECLARE_ENTRY_ACCESSORS
+#undef DECL_ENTRY_ACCESSORS
 
   inline BailoutId AstId(int i);
 
   inline void SetAstId(int i, BailoutId value);
 
   inline int DeoptCount();
 
   static const int kNotInlinedIndex = -1;
 
   // Returns the inlined function at the given position in LiteralArray, or the
   // outer function if index == kNotInlinedIndex.
   class SharedFunctionInfo* GetInlinedFunction(int index);
 
   // Allocates a DeoptimizationInputData.
   static Handle<DeoptimizationInputData> New(Isolate* isolate,
                                              int deopt_entry_count,
                                              PretenureFlag pretenure);
 
-  DECLARE_CAST(DeoptimizationInputData)
+  DECL_CAST(DeoptimizationInputData)
 
 #ifdef ENABLE_DISASSEMBLER
   void DeoptimizationInputDataPrint(std::ostream& os);  // NOLINT
 #endif
 
  private:
   static int IndexForEntry(int i) {
     return kFirstDeoptEntryIndex + (i * kDeoptEntrySize);
   }
 
 
   static int LengthFor(int entry_count) { return IndexForEntry(entry_count); }
 };
 
 class TemplateList : public FixedArray {
  public:
   static Handle<TemplateList> New(Isolate* isolate, int size);
   inline int length() const;
   inline Object* get(int index) const;
   inline void set(int index, Object* value);
   static Handle<TemplateList> Add(Isolate* isolate, Handle<TemplateList> list,
                                   Handle<Object> value);
-  DECLARE_CAST(TemplateList)
+  DECL_CAST(TemplateList)
  private:
   static const int kLengthIndex = 0;
   static const int kFirstElementIndex = kLengthIndex + 1;
   DISALLOW_IMPLICIT_CONSTRUCTORS(TemplateList);
 };
 
 // Code describes objects with on-the-fly generated machine code.
 class Code: public HeapObject {
  public:
   // Opaque data type for encapsulating code flags like kind, inline
@@ skipping 352 matching lines @@
   // Returns the object size for a given body (used for allocation).
   static int SizeFor(int body_size) {
     DCHECK_SIZE_TAG_ALIGNED(body_size);
     return RoundUp(kHeaderSize + body_size, kCodeAlignment);
   }
 
   // Calculate the size of the code object to report for log events. This takes
   // the layout of the code object into account.
   inline int ExecutableSize();
 
-  DECLARE_CAST(Code)
+  DECL_CAST(Code)
 
   // Dispatched behavior.
   inline int CodeSize();
 
-  DECLARE_PRINTER(Code)
-  DECLARE_VERIFIER(Code)
+  DECL_PRINTER(Code)
+  DECL_VERIFIER(Code)
 
   void ClearInlineCaches();
 
   BailoutId TranslatePcOffsetToAstId(uint32_t pc_offset);
   uint32_t TranslateAstIdToPcOffset(BailoutId ast_id);
 
-#define DECLARE_CODE_AGE_ENUM(X) k##X##CodeAge,
+#define DECL_CODE_AGE_ENUM(X) k##X##CodeAge,
   enum Age {
     kToBeExecutedOnceCodeAge = -3,
     kNotExecutedCodeAge = -2,
     kExecutedOnceCodeAge = -1,
     kNoAgeCodeAge = 0,
-    CODE_AGE_LIST(DECLARE_CODE_AGE_ENUM)
-    kAfterLastCodeAge,
+    CODE_AGE_LIST(DECL_CODE_AGE_ENUM) kAfterLastCodeAge,
     kFirstCodeAge = kToBeExecutedOnceCodeAge,
     kLastCodeAge = kAfterLastCodeAge - 1,
     kCodeAgeCount = kAfterLastCodeAge - kFirstCodeAge - 1,
     kIsOldCodeAge = kSexagenarianCodeAge,
     kPreAgedCodeAge = kIsOldCodeAge - 1
   };
-#undef DECLARE_CODE_AGE_ENUM
+#undef DECL_CODE_AGE_ENUM
 
   // Code aging.  Indicates how many full GCs this code has survived without
   // being entered through the prologue.  Used to determine when to flush code
   // held in the compilation cache.
   static void MakeCodeAgeSequenceYoung(byte* sequence, Isolate* isolate);
   static void MarkCodeAsExecuted(byte* sequence, Isolate* isolate);
   void MakeYoung(Isolate* isolate);
   void PreAge(Isolate* isolate);
   void MarkToBeExecutedOnce(Isolate* isolate);
   void MakeOlder();
@@ skipping 205 matching lines @@
   // Returns true if pc is inside this object's instructions.
   inline bool contains(byte* pc);
 
   // Returns the AbstractCode::Kind of the code.
   inline Kind kind();
 
   // Calculate the size of the code object to report for log events. This takes
   // the layout of the code object into account.
   inline int ExecutableSize();
 
-  DECLARE_CAST(AbstractCode)
+  DECL_CAST(AbstractCode)
   inline Code* GetCode();
   inline BytecodeArray* GetBytecodeArray();
 
   // Max loop nesting marker used to postpose OSR. We don't take loop
   // nesting that is deeper than 5 levels into account.
   static const int kMaxLoopNestingMarker = 6;
   STATIC_ASSERT(Code::AllowOSRAtLoopNestingLevelField::kMax >=
                 kMaxLoopNestingMarker);
 };
 
@@ skipping 80 matching lines @@
   inline DependentCode* next_link();
   inline void set_next_link(DependentCode* next);
   inline int count();
   inline void set_count(int value);
   inline DependencyGroup group();
   inline void set_group(DependencyGroup group);
   inline Object* object_at(int i);
   inline void set_object_at(int i, Object* object);
   inline void clear_at(int i);
   inline void copy(int from, int to);
-  DECLARE_CAST(DependentCode)
+  DECL_CAST(DependentCode)
 
   static const char* DependencyGroupName(DependencyGroup group);
   static void SetMarkedForDeoptimization(Code* code, DependencyGroup group);
 
  private:
   static Handle<DependentCode> Insert(Handle<DependentCode> entries,
                                       DependencyGroup group,
                                       Handle<Object> object);
   static Handle<DependentCode> New(DependencyGroup group, Handle<Object> object,
                                    Handle<DependentCode> next);
@@ skipping 13 matching lines @@
 };
 
 class PrototypeInfo;
 
 // An abstract superclass, a marker class really, for simple structure classes.
 // It doesn't carry much functionality but allows struct classes to be
 // identified in the type system.
 class Struct: public HeapObject {
  public:
   inline void InitializeBody(int object_size);
-  DECLARE_CAST(Struct)
+  DECL_CAST(Struct)
 };
 
 // A container struct to hold state required for PromiseResolveThenableJob.
 class PromiseResolveThenableJobInfo : public Struct {
  public:
   DECL_ACCESSORS(thenable, JSReceiver)
   DECL_ACCESSORS(then, JSReceiver)
   DECL_ACCESSORS(resolve, JSFunction)
   DECL_ACCESSORS(reject, JSFunction)
 
   DECL_ACCESSORS(context, Context)
 
   static const int kThenableOffset = Struct::kHeaderSize;
   static const int kThenOffset = kThenableOffset + kPointerSize;
   static const int kResolveOffset = kThenOffset + kPointerSize;
   static const int kRejectOffset = kResolveOffset + kPointerSize;
   static const int kContextOffset = kRejectOffset + kPointerSize;
   static const int kSize = kContextOffset + kPointerSize;
 
-  DECLARE_CAST(PromiseResolveThenableJobInfo)
-  DECLARE_PRINTER(PromiseResolveThenableJobInfo)
-  DECLARE_VERIFIER(PromiseResolveThenableJobInfo)
+  DECL_CAST(PromiseResolveThenableJobInfo)
+  DECL_PRINTER(PromiseResolveThenableJobInfo)
+  DECL_VERIFIER(PromiseResolveThenableJobInfo)
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(PromiseResolveThenableJobInfo);
 };
 
 class JSPromise;
 
 // Struct to hold state required for PromiseReactionJob.
 class PromiseReactionJobInfo : public Struct {
  public:
@@ skipping 13 matching lines @@
   static const int kValueOffset = Struct::kHeaderSize;
   static const int kTasksOffset = kValueOffset + kPointerSize;
   static const int kDeferredPromiseOffset = kTasksOffset + kPointerSize;
   static const int kDeferredOnResolveOffset =
       kDeferredPromiseOffset + kPointerSize;
   static const int kDeferredOnRejectOffset =
       kDeferredOnResolveOffset + kPointerSize;
   static const int kContextOffset = kDeferredOnRejectOffset + kPointerSize;
   static const int kSize = kContextOffset + kPointerSize;
 
-  DECLARE_CAST(PromiseReactionJobInfo)
-  DECLARE_PRINTER(PromiseReactionJobInfo)
-  DECLARE_VERIFIER(PromiseReactionJobInfo)
+  DECL_CAST(PromiseReactionJobInfo)
+  DECL_PRINTER(PromiseReactionJobInfo)
+  DECL_VERIFIER(PromiseReactionJobInfo)
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(PromiseReactionJobInfo);
 };
 
 class AsyncGeneratorRequest : public Struct {
  public:
   // Holds an AsyncGeneratorRequest, or Undefined.
   DECL_ACCESSORS(next, Object)
   DECL_INT_ACCESSORS(resume_mode)
   DECL_ACCESSORS(value, Object)
   DECL_ACCESSORS(promise, Object)
 
   static const int kNextOffset = Struct::kHeaderSize;
   static const int kResumeModeOffset = kNextOffset + kPointerSize;
   static const int kValueOffset = kResumeModeOffset + kPointerSize;
   static const int kPromiseOffset = kValueOffset + kPointerSize;
   static const int kSize = kPromiseOffset + kPointerSize;
 
-  DECLARE_CAST(AsyncGeneratorRequest)
-  DECLARE_PRINTER(AsyncGeneratorRequest)
-  DECLARE_VERIFIER(AsyncGeneratorRequest)
+  DECL_CAST(AsyncGeneratorRequest)
+  DECL_PRINTER(AsyncGeneratorRequest)
+  DECL_VERIFIER(AsyncGeneratorRequest)
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(AsyncGeneratorRequest);
 };
 
 // Container for metadata stored on each prototype map.
 class PrototypeInfo : public Struct {
  public:
   static const int UNREGISTERED = -1;
 
@@ skipping 20 matching lines @@
   // and those of all "downstream" prototypes are invalidated; handlers for a
   // given receiver embed the currently valid cell for that receiver's prototype
   // during their compilation and check it on execution.
   DECL_ACCESSORS(validity_cell, Object)
   // [bit_field]
   inline int bit_field() const;
   inline void set_bit_field(int bit_field);
 
   DECL_BOOLEAN_ACCESSORS(should_be_fast_map)
 
-  DECLARE_CAST(PrototypeInfo)
+  DECL_CAST(PrototypeInfo)
 
   // Dispatched behavior.
-  DECLARE_PRINTER(PrototypeInfo)
-  DECLARE_VERIFIER(PrototypeInfo)
+  DECL_PRINTER(PrototypeInfo)
+  DECL_VERIFIER(PrototypeInfo)
 
   static const int kWeakCellOffset = HeapObject::kHeaderSize;
   static const int kPrototypeUsersOffset = kWeakCellOffset + kPointerSize;
   static const int kRegistrySlotOffset = kPrototypeUsersOffset + kPointerSize;
   static const int kValidityCellOffset = kRegistrySlotOffset + kPointerSize;
   static const int kObjectCreateMap = kValidityCellOffset + kPointerSize;
   static const int kBitFieldOffset = kObjectCreateMap + kPointerSize;
   static const int kSize = kBitFieldOffset + kPointerSize;
 
   // Bit field usage.
   static const int kShouldBeFastBit = 0;
 
  private:
   DECL_ACCESSORS(object_create_map, Object)
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(PrototypeInfo);
 };
 
 class Tuple2 : public Struct {
  public:
   DECL_ACCESSORS(value1, Object)
   DECL_ACCESSORS(value2, Object)
 
-  DECLARE_CAST(Tuple2)
+  DECL_CAST(Tuple2)
 
   // Dispatched behavior.
-  DECLARE_PRINTER(Tuple2)
-  DECLARE_VERIFIER(Tuple2)
+  DECL_PRINTER(Tuple2)
+  DECL_VERIFIER(Tuple2)
 
   static const int kValue1Offset = HeapObject::kHeaderSize;
   static const int kValue2Offset = kValue1Offset + kPointerSize;
   static const int kSize = kValue2Offset + kPointerSize;
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(Tuple2);
 };
 
 class Tuple3 : public Tuple2 {
  public:
   DECL_ACCESSORS(value3, Object)
 
-  DECLARE_CAST(Tuple3)
+  DECL_CAST(Tuple3)
 
   // Dispatched behavior.
-  DECLARE_PRINTER(Tuple3)
-  DECLARE_VERIFIER(Tuple3)
+  DECL_PRINTER(Tuple3)
+  DECL_VERIFIER(Tuple3)
 
   static const int kValue3Offset = Tuple2::kSize;
   static const int kSize = kValue3Offset + kPointerSize;
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(Tuple3);
 };
 
 // Pair used to store both a ScopeInfo and an extension object in the extension
 // slot of a block, catch, or with context. Needed in the rare case where a
 // declaration block scope (a "varblock" as used to desugar parameter
 // destructuring) also contains a sloppy direct eval, or for with and catch
 // scopes. (In no other case both are needed at the same time.)
 class ContextExtension : public Struct {
  public:
   // [scope_info]: Scope info.
   DECL_ACCESSORS(scope_info, ScopeInfo)
   // [extension]: Extension object.
   DECL_ACCESSORS(extension, Object)
 
-  DECLARE_CAST(ContextExtension)
+  DECL_CAST(ContextExtension)
 
   // Dispatched behavior.
-  DECLARE_PRINTER(ContextExtension)
-  DECLARE_VERIFIER(ContextExtension)
+  DECL_PRINTER(ContextExtension)
+  DECL_VERIFIER(ContextExtension)
 
   static const int kScopeInfoOffset = HeapObject::kHeaderSize;
   static const int kExtensionOffset = kScopeInfoOffset + kPointerSize;
   static const int kSize = kExtensionOffset + kPointerSize;
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(ContextExtension);
 };
 
 // List of builtin functions we want to identify to improve code
@@ skipping 142 matching lines @@
   V(Atomics, compareExchange, AtomicsCompareExchange) \
   V(Atomics, add, AtomicsAdd)                         \
   V(Atomics, sub, AtomicsSub)                         \
   V(Atomics, and, AtomicsAnd)                         \
   V(Atomics, or, AtomicsOr)                           \
   V(Atomics, xor, AtomicsXor)
 
 enum BuiltinFunctionId {
   kInvalidBuiltinFunctionId = -1,
   kArrayCode,
-#define DECLARE_FUNCTION_ID(ignored1, ignore2, name)    \
-  k##name,
-  FUNCTIONS_WITH_ID_LIST(DECLARE_FUNCTION_ID)
-      ATOMIC_FUNCTIONS_WITH_ID_LIST(DECLARE_FUNCTION_ID)
-#undef DECLARE_FUNCTION_ID
+#define DECL_FUNCTION_ID(ignored1, ignore2, name) k##name,
+  FUNCTIONS_WITH_ID_LIST(DECL_FUNCTION_ID)
+      ATOMIC_FUNCTIONS_WITH_ID_LIST(DECL_FUNCTION_ID)
+#undef DECL_FUNCTION_ID
   // Fake id for a special case of Math.pow. Note, it continues the
   // list of math functions.
   kMathPowHalf,
   // These are manually assigned to special getters during bootstrapping.
   kArrayBufferByteLength,
   kArrayEntries,
   kArrayKeys,
   kArrayValues,
   kArrayIteratorNext,
   kDataViewBuffer,
@@ skipping 54 matching lines @@
   inline bool is_executing() const;
   inline bool is_suspended() const;
 
   // For suspended generators: the source position at which the generator
   // is suspended.
   int source_position() const;
 
   // [register_file]: Saved interpreter register file.
   DECL_ACCESSORS(register_file, FixedArray)
 
-  DECLARE_CAST(JSGeneratorObject)
+  DECL_CAST(JSGeneratorObject)
 
   // Dispatched behavior.
-  DECLARE_VERIFIER(JSGeneratorObject)
+  DECL_VERIFIER(JSGeneratorObject)
 
   // Magic sentinel values for the continuation.
   static const int kGeneratorExecuting = -2;
   static const int kGeneratorClosed = -1;
 
   // Layout description.
   static const int kFunctionOffset = JSObject::kHeaderSize;
   static const int kContextOffset = kFunctionOffset + kPointerSize;
   static const int kReceiverOffset = kContextOffset + kPointerSize;
   static const int kInputOrDebugPosOffset = kReceiverOffset + kPointerSize;
   static const int kResumeModeOffset = kInputOrDebugPosOffset + kPointerSize;
   static const int kContinuationOffset = kResumeModeOffset + kPointerSize;
   static const int kRegisterFileOffset = kContinuationOffset + kPointerSize;
   static const int kSize = kRegisterFileOffset + kPointerSize;
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(JSGeneratorObject);
 };
 
 class JSAsyncGeneratorObject : public JSGeneratorObject {
  public:
-  DECLARE_CAST(JSAsyncGeneratorObject)
+  DECL_CAST(JSAsyncGeneratorObject)
 
   // Dispatched behavior.
-  DECLARE_VERIFIER(JSAsyncGeneratorObject)
+  DECL_VERIFIER(JSAsyncGeneratorObject)
 
   // [queue]
   // Pointer to the head of a singly linked list of AsyncGeneratorRequest, or
   // undefined.
   DECL_ACCESSORS(queue, HeapObject)
 
   // [await_input_or_debug_pos]
   // Holds the value to resume generator with after an Await(), in order to
   // avoid clobbering function.sent. If awaited_promise is not undefined, holds
   // current bytecode offset for debugging instead.
@@ skipping 12 matching lines @@
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(JSAsyncGeneratorObject);
 };
 
 // When importing a module namespace (import * as foo from "bar"), a
 // JSModuleNamespace object (representing module "bar") is created and bound to
 // the declared variable (foo).  A module can have at most one namespace object.
 class JSModuleNamespace : public JSObject {
  public:
-  DECLARE_CAST(JSModuleNamespace)
-  DECLARE_PRINTER(JSModuleNamespace)
-  DECLARE_VERIFIER(JSModuleNamespace)
+  DECL_CAST(JSModuleNamespace)
+  DECL_PRINTER(JSModuleNamespace)
+  DECL_VERIFIER(JSModuleNamespace)
 
   // The actual module whose namespace is being represented.
   DECL_ACCESSORS(module, Module)
 
   // Retrieve the value exported by [module] under the given [name]. If there is
   // no such export, return Just(undefined). If the export is uninitialized,
   // schedule an exception and return Nothing.
   MUST_USE_RESULT MaybeHandle<Object> GetExport(Handle<String> name);
 
   // In-object fields.
   enum {
     kToStringTagFieldIndex,
     kInObjectFieldCount,
   };
 
   static const int kModuleOffset = JSObject::kHeaderSize;
   static const int kHeaderSize = kModuleOffset + kPointerSize;
 
   static const int kSize = kHeaderSize + kPointerSize * kInObjectFieldCount;
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(JSModuleNamespace);
 };
 
 // A Module object is a mapping from export names to cells
 // This is still very much in flux.
 class Module : public Struct {
  public:
-  DECLARE_CAST(Module)
-  DECLARE_VERIFIER(Module)
-  DECLARE_PRINTER(Module)
+  DECL_CAST(Module)
+  DECL_VERIFIER(Module)
+  DECL_PRINTER(Module)
 
   // The code representing this Module, or an abstraction thereof.
   // This is either a SharedFunctionInfo or a JSFunction or a ModuleInfo
   // depending on whether the module has been instantiated and evaluated.  See
   // Module::ModuleVerify() for the precise invariant.
   DECL_ACCESSORS(code, Object)
 
   // Arrays of cells corresponding to regular exports and regular imports.
   // A cell's position in the array is determined by the cell index of the
   // associated module entry (which coincides with the variable index of the
@@ skipping 149 matching lines @@
 
   // [bound_arguments]: A list of values whose elements are used as the first
   // arguments to any call to the wrapped function.
   DECL_ACCESSORS(bound_arguments, FixedArray)
 
   static MaybeHandle<String> GetName(Isolate* isolate,
                                      Handle<JSBoundFunction> function);
   static MaybeHandle<Context> GetFunctionRealm(
       Handle<JSBoundFunction> function);
 
-  DECLARE_CAST(JSBoundFunction)
+  DECL_CAST(JSBoundFunction)
 
   // Dispatched behavior.
-  DECLARE_PRINTER(JSBoundFunction)
-  DECLARE_VERIFIER(JSBoundFunction)
+  DECL_PRINTER(JSBoundFunction)
+  DECL_VERIFIER(JSBoundFunction)
 
   // The bound function's string representation implemented according
   // to ES6 section 19.2.3.5 Function.prototype.toString ( ).
   static Handle<String> ToString(Handle<JSBoundFunction> function);
 
   // Layout description.
   static const int kBoundTargetFunctionOffset = JSObject::kHeaderSize;
   static const int kBoundThisOffset = kBoundTargetFunctionOffset + kPointerSize;
   static const int kBoundArgumentsOffset = kBoundThisOffset + kPointerSize;
   static const int kSize = kBoundArgumentsOffset + kPointerSize;
@@ skipping 144 matching lines @@
   inline bool is_compiled();
 
   // [next_function_link]: Links functions into various lists, e.g. the list
   // of optimized functions hanging off the native_context. Treated weakly
   // by the garbage collector.
   DECL_ACCESSORS(next_function_link, Object)
 
   // Prints the name of the function using PrintF.
   void PrintName(FILE* out = stdout);
 
-  DECLARE_CAST(JSFunction)
+  DECL_CAST(JSFunction)
 
   // Calculate the instance size and in-object properties count.
   static void CalculateInstanceSizeForDerivedClass(
       Handle<JSFunction> function, InstanceType instance_type,
       int requested_embedder_fields, int* instance_size,
       int* in_object_properties);
   static void CalculateInstanceSizeHelper(InstanceType instance_type,
                                           int requested_embedder_fields,
                                           int requested_in_object_properties,
                                           int* instance_size,
                                           int* in_object_properties);
   enum BodyVisitingPolicy { kIgnoreWeakness, kRespectWeakness };
   // Iterates the function object according to the visiting policy.
   template <BodyVisitingPolicy>
   class BodyDescriptorImpl;
 
   typedef BodyDescriptorImpl<kIgnoreWeakness> BodyDescriptor;
   typedef BodyDescriptorImpl<kRespectWeakness> BodyDescriptorWeak;
 
   // Dispatched behavior.
-  DECLARE_PRINTER(JSFunction)
-  DECLARE_VERIFIER(JSFunction)
+  DECL_PRINTER(JSFunction)
+  DECL_VERIFIER(JSFunction)
 
   // The function's name if it is configured, otherwise shared function info
   // debug name.
   static Handle<String> GetName(Handle<JSFunction> function);
 
   // ES6 section 9.2.11 SetFunctionName
   // Because of the way this abstract operation is used in the spec,
   // it should never fail.
   static void SetName(Handle<JSFunction> function, Handle<Name> name,
                       Handle<String> prefix);
@@ skipping 35 matching lines @@
 
 class JSGlobalProxy : public JSObject {
  public:
   // [native_context]: the owner native context of this global proxy object.
   // It is null value if this object is not used by any context.
   DECL_ACCESSORS(native_context, Object)
 
   // [hash]: The hash code property (undefined if not initialized yet).
   DECL_ACCESSORS(hash, Object)
 
-  DECLARE_CAST(JSGlobalProxy)
+  DECL_CAST(JSGlobalProxy)
 
   inline bool IsDetachedFrom(JSGlobalObject* global) const;
 
   static int SizeWithEmbedderFields(int embedder_field_count);
 
   // Dispatched behavior.
-  DECLARE_PRINTER(JSGlobalProxy)
-  DECLARE_VERIFIER(JSGlobalProxy)
+  DECL_PRINTER(JSGlobalProxy)
+  DECL_VERIFIER(JSGlobalProxy)
 
   // Layout description.
   static const int kNativeContextOffset = JSObject::kHeaderSize;
   static const int kHashOffset = kNativeContextOffset + kPointerSize;
   static const int kSize = kHashOffset + kPointerSize;
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(JSGlobalProxy);
 };
 
 
 // JavaScript global object.
 class JSGlobalObject : public JSObject {
  public:
   // [native context]: the natives corresponding to this global object.
   DECL_ACCESSORS(native_context, Context)
 
   // [global proxy]: the global proxy object of the context
   DECL_ACCESSORS(global_proxy, JSObject)
 
 
   static void InvalidatePropertyCell(Handle<JSGlobalObject> object,
                                      Handle<Name> name);
   // Ensure that the global object has a cell for the given property name.
   static Handle<PropertyCell> EnsureEmptyPropertyCell(
       Handle<JSGlobalObject> global, Handle<Name> name,
       PropertyCellType cell_type, int* entry_out = nullptr);
 
-  DECLARE_CAST(JSGlobalObject)
+  DECL_CAST(JSGlobalObject)
 
   inline bool IsDetached();
 
   // Dispatched behavior.
-  DECLARE_PRINTER(JSGlobalObject)
-  DECLARE_VERIFIER(JSGlobalObject)
+  DECL_PRINTER(JSGlobalObject)
+  DECL_VERIFIER(JSGlobalObject)
 
   // Layout description.
   static const int kNativeContextOffset = JSObject::kHeaderSize;
   static const int kGlobalProxyOffset = kNativeContextOffset + kPointerSize;
   static const int kHeaderSize = kGlobalProxyOffset + kPointerSize;
   static const int kSize = kHeaderSize;
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(JSGlobalObject);
 };
 
 
 // Representation for JS Wrapper objects, String, Number, Boolean, etc.
 class JSValue: public JSObject {
  public:
   // [value]: the object being wrapped.
   DECL_ACCESSORS(value, Object)
 
-  DECLARE_CAST(JSValue)
+  DECL_CAST(JSValue)
 
   // Dispatched behavior.
-  DECLARE_PRINTER(JSValue)
-  DECLARE_VERIFIER(JSValue)
+  DECL_PRINTER(JSValue)
+  DECL_VERIFIER(JSValue)
 
   // Layout description.
   static const int kValueOffset = JSObject::kHeaderSize;
   static const int kSize = kValueOffset + kPointerSize;
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(JSValue);
 };
 
 
@@ skipping 20 matching lines @@
   // [hour]: caches hours. Either undefined, smi, or NaN.
   DECL_ACCESSORS(hour, Object)
   // [min]: caches minutes. Either undefined, smi, or NaN.
   DECL_ACCESSORS(min, Object)
   // [sec]: caches seconds. Either undefined, smi, or NaN.
   DECL_ACCESSORS(sec, Object)
   // [cache stamp]: sample of the date cache stamp at the
   // moment when chached fields were cached.
   DECL_ACCESSORS(cache_stamp, Object)
 
-  DECLARE_CAST(JSDate)
+  DECL_CAST(JSDate)
 
   // Returns the time value (UTC) identifying the current time.
   static double CurrentTimeValue(Isolate* isolate);
 
   // Returns the date field with the specified index.
   // See FieldIndex for the list of date fields.
   static Object* GetField(Object* date, Smi* index);
 
   static Handle<Object> SetValue(Handle<JSDate> date, double v);
 
   void SetValue(Object* value, bool is_value_nan);
 
   // Dispatched behavior.
-  DECLARE_PRINTER(JSDate)
-  DECLARE_VERIFIER(JSDate)
+  DECL_PRINTER(JSDate)
+  DECL_VERIFIER(JSDate)
 
   // The order is important. It must be kept in sync with date macros
   // in macros.py.
   enum FieldIndex {
     kDateValue,
     kYear,
     kMonth,
     kDay,
     kWeekday,
     kHour,
@@ skipping 76 matching lines @@
   // Returns the offset of the given position within the containing line.
   int GetColumnNumber() const;
 
   // Returns the source code line containing the given source
   // position, or the empty string if the position is invalid.
   Handle<String> GetSourceLine() const;
 
   inline int error_level() const;
   inline void set_error_level(int level);
 
-  DECLARE_CAST(JSMessageObject)
+  DECL_CAST(JSMessageObject)
 
   // Dispatched behavior.
-  DECLARE_PRINTER(JSMessageObject)
-  DECLARE_VERIFIER(JSMessageObject)
+  DECL_PRINTER(JSMessageObject)
+  DECL_VERIFIER(JSMessageObject)
 
   // Layout description.
   static const int kTypeOffset = JSObject::kHeaderSize;
   static const int kArgumentsOffset = kTypeOffset + kPointerSize;
   static const int kScriptOffset = kArgumentsOffset + kPointerSize;
   static const int kStackFramesOffset = kScriptOffset + kPointerSize;
   static const int kStartPositionOffset = kStackFramesOffset + kPointerSize;
   static const int kEndPositionOffset = kStartPositionOffset + kPointerSize;
   static const int kErrorLevelOffset = kEndPositionOffset + kPointerSize;
   static const int kSize = kErrorLevelOffset + kPointerSize;
 
   typedef FixedBodyDescriptor<HeapObject::kMapOffset,
                               kStackFramesOffset + kPointerSize,
                               kSize> BodyDescriptor;
   // No weak fields.
   typedef BodyDescriptor BodyDescriptorWeak;
 };
 
 class JSPromise;
 
 // TODO(caitp): Make this a Struct once properties are no longer accessed from
 // JS
 class JSPromiseCapability : public JSObject {
  public:
-  DECLARE_CAST(JSPromiseCapability)
+  DECL_CAST(JSPromiseCapability)
 
-  DECLARE_VERIFIER(JSPromiseCapability)
+  DECL_VERIFIER(JSPromiseCapability)
 
   DECL_ACCESSORS(promise, Object)
   DECL_ACCESSORS(resolve, Object)
   DECL_ACCESSORS(reject, Object)
 
   static const int kPromiseOffset = JSObject::kHeaderSize;
   static const int kResolveOffset = kPromiseOffset + kPointerSize;
   static const int kRejectOffset = kResolveOffset + kPointerSize;
   static const int kSize = kRejectOffset + kPointerSize;
 
@@ skipping 36 matching lines @@
 
   // [has_handler]: Whether this promise has a reject handler or not.
   DECL_BOOLEAN_ACCESSORS(has_handler)
 
   // [handled_hint]: Whether this promise will be handled by a catch
   // block in an async function.
   DECL_BOOLEAN_ACCESSORS(handled_hint)
 
   static const char* Status(int status);
 
-  DECLARE_CAST(JSPromise)
+  DECL_CAST(JSPromise)
 
   // Dispatched behavior.
-  DECLARE_PRINTER(JSPromise)
-  DECLARE_VERIFIER(JSPromise)
+  DECL_PRINTER(JSPromise)
+  DECL_VERIFIER(JSPromise)
 
   // Layout description.
   static const int kStatusOffset = JSObject::kHeaderSize;
   static const int kResultOffset = kStatusOffset + kPointerSize;
   static const int kDeferredPromiseOffset = kResultOffset + kPointerSize;
   static const int kDeferredOnResolveOffset =
       kDeferredPromiseOffset + kPointerSize;
   static const int kDeferredOnRejectOffset =
       kDeferredOnResolveOffset + kPointerSize;
   static const int kFulfillReactionsOffset =
@@ skipping 83 matching lines @@
   }
 
   static int saved_code_index(bool is_latin1) {
     if (is_latin1) {
       return kIrregexpLatin1CodeSavedIndex;
     } else {
       return kIrregexpUC16CodeSavedIndex;
     }
   }
 
-  DECLARE_CAST(JSRegExp)
+  DECL_CAST(JSRegExp)
 
   // Dispatched behavior.
-  DECLARE_PRINTER(JSRegExp)
-  DECLARE_VERIFIER(JSRegExp)
+  DECL_PRINTER(JSRegExp)
+  DECL_VERIFIER(JSRegExp)
 
   static const int kDataOffset = JSObject::kHeaderSize;
   static const int kSourceOffset = kDataOffset + kPointerSize;
   static const int kFlagsOffset = kSourceOffset + kPointerSize;
   static const int kSize = kFlagsOffset + kPointerSize;
 
   // Indices in the data array.
   static const int kTagIndex = 0;
   static const int kSourceIndex = kTagIndex + 1;
   static const int kFlagsIndex = kSourceIndex + 1;
@@ skipping 63 matching lines @@
   inline void change_ic_generic_count(int delta);
 
   inline void initialize_storage();
 
   inline void change_own_type_change_checksum();
   inline int own_type_change_checksum();
 
   inline void set_inlined_type_change_checksum(int checksum);
   inline bool matches_inlined_type_change_checksum(int checksum);
 
-  DECLARE_CAST(TypeFeedbackInfo)
+  DECL_CAST(TypeFeedbackInfo)
 
   static const int kStorage1Offset = kValue1Offset;
   static const int kStorage2Offset = kValue2Offset;
   static const int kStorage3Offset = kValue3Offset;
 
  private:
   static const int kTypeChangeChecksumBits = 7;
 
   class ICTotalCountField: public BitField<int, 0,
       kSmiValueSize - kTypeChangeChecksumBits> {};  // NOLINT
@@ skipping 97 matching lines @@
   inline bool CanInlineCall();
   inline void SetDoNotInlineCall();
 
   inline bool SitePointsToLiteral();
 
   template <AllocationSiteUpdateMode update_or_check =
                 AllocationSiteUpdateMode::kUpdate>
   static bool DigestTransitionFeedback(Handle<AllocationSite> site,
                                        ElementsKind to_kind);
 
-  DECLARE_PRINTER(AllocationSite)
-  DECLARE_VERIFIER(AllocationSite)
+  DECL_PRINTER(AllocationSite)
+  DECL_VERIFIER(AllocationSite)
 
-  DECLARE_CAST(AllocationSite)
+  DECL_CAST(AllocationSite)
   static inline bool ShouldTrack(ElementsKind boilerplate_elements_kind);
   static bool ShouldTrack(ElementsKind from, ElementsKind to);
   static inline bool CanTrack(InstanceType type);
 
   static const int kTransitionInfoOffset = HeapObject::kHeaderSize;
   static const int kNestedSiteOffset = kTransitionInfoOffset + kPointerSize;
   static const int kPretenureDataOffset = kNestedSiteOffset + kPointerSize;
   static const int kPretenureCreateCountOffset =
       kPretenureDataOffset + kPointerSize;
   static const int kDependentCodeOffset =
@@ skipping 26 matching lines @@
  public:
   static const int kAllocationSiteOffset = HeapObject::kHeaderSize;
   static const int kSize = kAllocationSiteOffset + kPointerSize;
 
   DECL_ACCESSORS(allocation_site, Object)
 
   inline bool IsValid();
   inline AllocationSite* GetAllocationSite();
   inline Address GetAllocationSiteUnchecked();
 
-  DECLARE_PRINTER(AllocationMemento)
-  DECLARE_VERIFIER(AllocationMemento)
+  DECL_PRINTER(AllocationMemento)
+  DECL_VERIFIER(AllocationMemento)
 
-  DECLARE_CAST(AllocationMemento)
+  DECL_CAST(AllocationMemento)
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(AllocationMemento);
 };
 
 
 // Utility superclass for stack-allocated objects that must be updated
 // on gc.  It provides two ways for the gc to update instances, either
 // iterating or updating after gc.
 class Relocatable BASE_EMBEDDED {
@@ skipping 45 matching lines @@
 
   // [typeof]: Cached type_of computed at startup.
   DECL_ACCESSORS(type_of, String)
 
   inline byte kind() const;
   inline void set_kind(byte kind);
 
   // ES6 section 7.1.3 ToNumber for Boolean, Null, Undefined.
   MUST_USE_RESULT static inline Handle<Object> ToNumber(Handle<Oddball> input);
 
-  DECLARE_CAST(Oddball)
+  DECL_CAST(Oddball)
 
   // Dispatched behavior.
-  DECLARE_VERIFIER(Oddball)
+  DECL_VERIFIER(Oddball)
 
   // Initialize the fields.
   static void Initialize(Isolate* isolate, Handle<Oddball> oddball,
                          const char* to_string, Handle<Object> to_number,
                          const char* type_of, byte kind);
 
   // Layout description.
   static const int kToNumberRawOffset = HeapObject::kHeaderSize;
   static const int kToStringOffset = kToNumberRawOffset + kDoubleSize;
   static const int kToNumberOffset = kToStringOffset + kPointerSize;
@@ skipping 27 matching lines @@
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(Oddball);
 };
 
 
 class Cell: public HeapObject {
  public:
   // [value]: value of the cell.
   DECL_ACCESSORS(value, Object)
 
-  DECLARE_CAST(Cell)
+  DECL_CAST(Cell)
 
   static inline Cell* FromValueAddress(Address value) {
     Object* result = FromAddress(value - kValueOffset);
     return static_cast<Cell*>(result);
   }
 
   inline Address ValueAddress() {
     return address() + kValueOffset;
   }
 
   // Dispatched behavior.
-  DECLARE_PRINTER(Cell)
-  DECLARE_VERIFIER(Cell)
+  DECL_PRINTER(Cell)
+  DECL_VERIFIER(Cell)
 
   // Layout description.
   static const int kValueOffset = HeapObject::kHeaderSize;
   static const int kSize = kValueOffset + kPointerSize;
 
   typedef FixedBodyDescriptor<kValueOffset,
                               kValueOffset + kPointerSize,
                               kSize> BodyDescriptor;
   // No weak fields.
   typedef BodyDescriptor BodyDescriptorWeak;
@@ skipping 31 matching lines @@
   static Handle<PropertyCell> PrepareForValue(
       Handle<GlobalDictionary> dictionary, int entry, Handle<Object> value,
       PropertyDetails details);
 
   static Handle<PropertyCell> InvalidateEntry(
       Handle<GlobalDictionary> dictionary, int entry);
 
   static void SetValueWithInvalidation(Handle<PropertyCell> cell,
                                        Handle<Object> new_value);
 
-  DECLARE_CAST(PropertyCell)
+  DECL_CAST(PropertyCell)
 
   // Dispatched behavior.
-  DECLARE_PRINTER(PropertyCell)
-  DECLARE_VERIFIER(PropertyCell)
+  DECL_PRINTER(PropertyCell)
+  DECL_VERIFIER(PropertyCell)
 
   // Layout description.
   static const int kDetailsOffset = HeapObject::kHeaderSize;
   static const int kNameOffset = kDetailsOffset + kPointerSize;
   static const int kValueOffset = kNameOffset + kPointerSize;
   static const int kDependentCodeOffset = kValueOffset + kPointerSize;
   static const int kSize = kDependentCodeOffset + kPointerSize;
 
   typedef FixedBodyDescriptor<kNameOffset, kSize, kSize> BodyDescriptor;
   // No weak fields.
@@ skipping 15 matching lines @@
   inline void initialize(HeapObject* value);
 
   inline bool cleared() const;
 
   DECL_ACCESSORS(next, Object)
 
   inline void clear_next(Object* the_hole_value);
 
   inline bool next_cleared();
 
-  DECLARE_CAST(WeakCell)
+  DECL_CAST(WeakCell)
 
-  DECLARE_PRINTER(WeakCell)
-  DECLARE_VERIFIER(WeakCell)
+  DECL_PRINTER(WeakCell)
+  DECL_VERIFIER(WeakCell)
 
   // Layout description.
   static const int kValueOffset = HeapObject::kHeaderSize;
   static const int kNextOffset = kValueOffset + kPointerSize;
   static const int kSize = kNextOffset + kPointerSize;
 
   typedef FixedBodyDescriptor<kValueOffset, kSize, kSize> BodyDescriptor;
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(WeakCell);
 };
 
 
 // The JSProxy describes EcmaScript Harmony proxies
 class JSProxy: public JSReceiver {
  public:
   MUST_USE_RESULT static MaybeHandle<JSProxy> New(Isolate* isolate,
                                                   Handle<Object>,
                                                   Handle<Object>);
 
   // [handler]: The handler property.
   DECL_ACCESSORS(handler, Object)
   // [target]: The target property.
   DECL_ACCESSORS(target, JSReceiver)
   // [hash]: The hash code property (undefined if not initialized yet).
   DECL_ACCESSORS(hash, Object)
 
   static MaybeHandle<Context> GetFunctionRealm(Handle<JSProxy> proxy);
 
-  DECLARE_CAST(JSProxy)
+  DECL_CAST(JSProxy)
 
   INLINE(bool IsRevoked() const);
   static void Revoke(Handle<JSProxy> proxy);
 
   // ES6 9.5.1
   static MaybeHandle<Object> GetPrototype(Handle<JSProxy> receiver);
 
   // ES6 9.5.2
   MUST_USE_RESULT static Maybe<bool> SetPrototype(Handle<JSProxy> proxy,
                                                   Handle<Object> value,
@@ skipping 42 matching lines @@
 
   // ES6 9.5.12
   MUST_USE_RESULT static Maybe<bool> OwnPropertyKeys(
       Isolate* isolate, Handle<JSReceiver> receiver, Handle<JSProxy> proxy,
       PropertyFilter filter, KeyAccumulator* accumulator);
 
   MUST_USE_RESULT static Maybe<PropertyAttributes> GetPropertyAttributes(
       LookupIterator* it);
 
   // Dispatched behavior.
-  DECLARE_PRINTER(JSProxy)
-  DECLARE_VERIFIER(JSProxy)
+  DECL_PRINTER(JSProxy)
+  DECL_VERIFIER(JSProxy)
 
   static const int kMaxIterationLimit = 100 * 1024;
 
   // Layout description.
   static const int kTargetOffset = JSReceiver::kHeaderSize;
   static const int kHandlerOffset = kTargetOffset + kPointerSize;
   static const int kHashOffset = kHandlerOffset + kPointerSize;
   static const int kSize = kHashOffset + kPointerSize;
 
   typedef FixedBodyDescriptor<JSReceiver::kPropertiesOffset, kSize, kSize>
@@ skipping 26 matching lines @@
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(JSCollection);
 };
 
 
 // The JSSet describes EcmaScript Harmony sets
 // TODO(marja): When moving JSSet out of objects.h, move JSSetIterator (from
 // objects/hash-table.h) into the same file.
 class JSSet : public JSCollection {
  public:
-  DECLARE_CAST(JSSet)
+  DECL_CAST(JSSet)
 
   static void Initialize(Handle<JSSet> set, Isolate* isolate);
   static void Clear(Handle<JSSet> set);
 
   // Dispatched behavior.
-  DECLARE_PRINTER(JSSet)
-  DECLARE_VERIFIER(JSSet)
+  DECL_PRINTER(JSSet)
+  DECL_VERIFIER(JSSet)
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(JSSet);
 };
 
 
 // The JSMap describes EcmaScript Harmony maps
 // TODO(marja): When moving JSMap out of objects.h, move JSMapIterator (from
 // objects/hash-table.h) into the same file.
 class JSMap : public JSCollection {
  public:
-  DECLARE_CAST(JSMap)
+  DECL_CAST(JSMap)
 
   static void Initialize(Handle<JSMap> map, Isolate* isolate);
   static void Clear(Handle<JSMap> map);
 
   // Dispatched behavior.
-  DECLARE_PRINTER(JSMap)
-  DECLARE_VERIFIER(JSMap)
+  DECL_PRINTER(JSMap)
+  DECL_VERIFIER(JSMap)
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(JSMap);
 };
 
 class JSArrayIterator : public JSObject {
  public:
-  DECLARE_PRINTER(JSArrayIterator)
-  DECLARE_VERIFIER(JSArrayIterator)
+  DECL_PRINTER(JSArrayIterator)
+  DECL_VERIFIER(JSArrayIterator)
 
-  DECLARE_CAST(JSArrayIterator)
+  DECL_CAST(JSArrayIterator)
 
   // [object]: the [[IteratedObject]] inobject property.
   DECL_ACCESSORS(object, Object)
 
   // [index]: The [[ArrayIteratorNextIndex]] inobject property.
   DECL_ACCESSORS(index, Object)
 
   // [map]: The Map of the [[IteratedObject]] field at the time the iterator is
   // allocated.
   DECL_ACCESSORS(object_map, Object)
@@ skipping 11 matching lines @@
   DISALLOW_IMPLICIT_CONSTRUCTORS(JSArrayIterator);
 };
 
 // The [Async-from-Sync Iterator] object
 // (proposal-async-iteration/#sec-async-from-sync-iterator-objects)
 // An object which wraps an ordinary Iterator and converts it to behave
 // according to the Async Iterator protocol.
 // (See https://tc39.github.io/proposal-async-iteration/#sec-iteration)
 class JSAsyncFromSyncIterator : public JSObject {
  public:
-  DECLARE_CAST(JSAsyncFromSyncIterator)
-  DECLARE_PRINTER(JSAsyncFromSyncIterator)
-  DECLARE_VERIFIER(JSAsyncFromSyncIterator)
+  DECL_CAST(JSAsyncFromSyncIterator)
+  DECL_PRINTER(JSAsyncFromSyncIterator)
+  DECL_VERIFIER(JSAsyncFromSyncIterator)
 
   // Async-from-Sync Iterator instances are ordinary objects that inherit
   // properties from the %AsyncFromSyncIteratorPrototype% intrinsic object.
   // Async-from-Sync Iterator instances are initially created with the internal
   // slots listed in Table 4.
   // (proposal-async-iteration/#table-async-from-sync-iterator-internal-slots)
   DECL_ACCESSORS(sync_iterator, JSReceiver)
 
   // Offsets of object fields.
   static const int kSyncIteratorOffset = JSObject::kHeaderSize;
   static const int kSize = kSyncIteratorOffset + kPointerSize;
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(JSAsyncFromSyncIterator);
 };
 
 class JSStringIterator : public JSObject {
  public:
   // Dispatched behavior.
-  DECLARE_PRINTER(JSStringIterator)
-  DECLARE_VERIFIER(JSStringIterator)
+  DECL_PRINTER(JSStringIterator)
+  DECL_VERIFIER(JSStringIterator)
 
-  DECLARE_CAST(JSStringIterator)
+  DECL_CAST(JSStringIterator)
 
   // [string]: the [[IteratedString]] inobject property.
   DECL_ACCESSORS(string, String)
 
   // [index]: The [[StringIteratorNextIndex]] inobject property.
   inline int index() const;
   inline void set_index(int value);
 
   static const int kStringOffset = JSObject::kHeaderSize;
   static const int kNextIndexOffset = kStringOffset + kPointerSize;
   static const int kSize = kNextIndexOffset + kPointerSize;
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(JSStringIterator);
 };
 
 // Base class for both JSWeakMap and JSWeakSet
 class JSWeakCollection: public JSObject {
  public:
-  DECLARE_CAST(JSWeakCollection)
+  DECL_CAST(JSWeakCollection)
 
   // [table]: the backing hash table mapping keys to values.
   DECL_ACCESSORS(table, Object)
 
   // [next]: linked list of encountered weak maps during GC.
   DECL_ACCESSORS(next, Object)
 
   static void Initialize(Handle<JSWeakCollection> collection, Isolate* isolate);
   static void Set(Handle<JSWeakCollection> collection, Handle<Object> key,
                   Handle<Object> value, int32_t hash);
@@ skipping 21 matching lines @@
   typedef BodyDescriptorImpl<kRespectWeakness> BodyDescriptorWeak;
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(JSWeakCollection);
 };
 
 
 // The JSWeakMap describes EcmaScript Harmony weak maps
 class JSWeakMap: public JSWeakCollection {
  public:
-  DECLARE_CAST(JSWeakMap)
+  DECL_CAST(JSWeakMap)
 
   // Dispatched behavior.
-  DECLARE_PRINTER(JSWeakMap)
-  DECLARE_VERIFIER(JSWeakMap)
+  DECL_PRINTER(JSWeakMap)
+  DECL_VERIFIER(JSWeakMap)
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(JSWeakMap);
 };
 
 
 // The JSWeakSet describes EcmaScript Harmony weak sets
 class JSWeakSet: public JSWeakCollection {
  public:
-  DECLARE_CAST(JSWeakSet)
+  DECL_CAST(JSWeakSet)
 
   // Dispatched behavior.
-  DECLARE_PRINTER(JSWeakSet)
-  DECLARE_VERIFIER(JSWeakSet)
+  DECL_PRINTER(JSWeakSet)
+  DECL_VERIFIER(JSWeakSet)
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(JSWeakSet);
 };
 
 
 // Whether a JSArrayBuffer is a SharedArrayBuffer or not.
 enum class SharedFlag { kNotShared, kShared };
 
 
@@ skipping 33 matching lines @@
   inline void set_is_shared(bool value);
 
   inline bool has_guard_region() const;
   inline void set_has_guard_region(bool value);
 
   // TODO(gdeepti): This flag is introduced to disable asm.js optimizations in
   // js-typer-lowering.cc, remove when the asm.js case is fixed.
   inline bool is_wasm_buffer();
   inline void set_is_wasm_buffer(bool value);
 
-  DECLARE_CAST(JSArrayBuffer)
+  DECL_CAST(JSArrayBuffer)
 
   void Neuter();
 
   inline ArrayBuffer::Allocator::AllocationMode allocation_mode() const;
 
   void FreeBackingStore();
 
   V8_EXPORT_PRIVATE static void Setup(
       Handle<JSArrayBuffer> array_buffer, Isolate* isolate, bool is_external,
       void* data, size_t allocated_length,
       SharedFlag shared = SharedFlag::kNotShared);
 
   V8_EXPORT_PRIVATE static void Setup(
       Handle<JSArrayBuffer> array_buffer, Isolate* isolate, bool is_external,
       void* allocation_base, size_t allocation_length, void* data,
       size_t byte_length, SharedFlag shared = SharedFlag::kNotShared);
 
   // Returns false if array buffer contents could not be allocated.
   // In this case, |array_buffer| will not be set up.
   static bool SetupAllocatingData(
       Handle<JSArrayBuffer> array_buffer, Isolate* isolate,
       size_t allocated_length, bool initialize = true,
       SharedFlag shared = SharedFlag::kNotShared) WARN_UNUSED_RESULT;
 
   // Dispatched behavior.
-  DECLARE_PRINTER(JSArrayBuffer)
-  DECLARE_VERIFIER(JSArrayBuffer)
+  DECL_PRINTER(JSArrayBuffer)
+  DECL_VERIFIER(JSArrayBuffer)
 
   static const int kByteLengthOffset = JSObject::kHeaderSize;
   // The rest of the fields are not JSObjects, so they are not iterated over in
   // objects-body-descriptors-inl.h.
   static const int kBackingStoreOffset = kByteLengthOffset + kPointerSize;
   static const int kAllocationBaseOffset = kBackingStoreOffset + kPointerSize;
   static const int kAllocationLengthOffset =
       kAllocationBaseOffset + kPointerSize;
   static const int kBitFieldSlot = kAllocationLengthOffset + kSizetSize;
 #if V8_TARGET_LITTLE_ENDIAN || !V8_HOST_ARCH_64_BIT
@@ skipping 28 matching lines @@
  public:
   // [buffer]: ArrayBuffer that this typed array views.
   DECL_ACCESSORS(buffer, Object)
 
   // [byte_offset]: offset of typed array in bytes.
   DECL_ACCESSORS(byte_offset, Object)
 
   // [byte_length]: length of typed array in bytes.
   DECL_ACCESSORS(byte_length, Object)
 
-  DECLARE_CAST(JSArrayBufferView)
+  DECL_CAST(JSArrayBufferView)
 
-  DECLARE_VERIFIER(JSArrayBufferView)
+  DECL_VERIFIER(JSArrayBufferView)
 
   inline bool WasNeutered() const;
 
   static const int kBufferOffset = JSObject::kHeaderSize;
   static const int kByteOffsetOffset = kBufferOffset + kPointerSize;
   static const int kByteLengthOffset = kByteOffsetOffset + kPointerSize;
   static const int kViewSize = kByteLengthOffset + kPointerSize;
 
  private:
 #ifdef VERIFY_HEAP
   DECL_ACCESSORS(raw_byte_offset, Object)
   DECL_ACCESSORS(raw_byte_length, Object)
 #endif
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(JSArrayBufferView);
 };
 
 
 class JSTypedArray: public JSArrayBufferView {
  public:
   // [length]: length of typed array in elements.
   DECL_ACCESSORS(length, Object)
   inline uint32_t length_value() const;
 
   // ES6 9.4.5.3
   MUST_USE_RESULT static Maybe<bool> DefineOwnProperty(
       Isolate* isolate, Handle<JSTypedArray> o, Handle<Object> key,
       PropertyDescriptor* desc, ShouldThrow should_throw);
 
-  DECLARE_CAST(JSTypedArray)
+  DECL_CAST(JSTypedArray)
 
   ExternalArrayType type();
   V8_EXPORT_PRIVATE size_t element_size();
 
   Handle<JSArrayBuffer> GetBuffer();
 
   static inline MaybeHandle<JSTypedArray> Validate(Isolate* isolate,
                                                    Handle<Object> receiver,
                                                    const char* method_name);
   // ES7 section 22.2.4.6 Create ( constructor, argumentList )
   static MaybeHandle<JSTypedArray> Create(Isolate* isolate,
                                           Handle<Object> default_ctor, int argc,
                                           Handle<Object>* argv,
                                           const char* method_name);
   // ES7 section 22.2.4.7 TypedArraySpeciesCreate ( exemplar, argumentList )
   static MaybeHandle<JSTypedArray> SpeciesCreate(Isolate* isolate,
                                                  Handle<JSTypedArray> exemplar,
                                                  int argc, Handle<Object>* argv,
                                                  const char* method_name);
 
   // Dispatched behavior.
-  DECLARE_PRINTER(JSTypedArray)
-  DECLARE_VERIFIER(JSTypedArray)
+  DECL_PRINTER(JSTypedArray)
+  DECL_VERIFIER(JSTypedArray)
 
   static const int kLengthOffset = kViewSize + kPointerSize;
   static const int kSize = kLengthOffset + kPointerSize;
 
   static const int kSizeWithEmbedderFields =
       kSize + v8::ArrayBufferView::kEmbedderFieldCount * kPointerSize;
 
  private:
   static Handle<JSArrayBuffer> MaterializeArrayBuffer(
       Handle<JSTypedArray> typed_array);
 #ifdef VERIFY_HEAP
   DECL_ACCESSORS(raw_length, Object)
 #endif
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(JSTypedArray);
 };
 
 
 class JSDataView: public JSArrayBufferView {
  public:
-  DECLARE_CAST(JSDataView)
+  DECL_CAST(JSDataView)
 
   // Dispatched behavior.
-  DECLARE_PRINTER(JSDataView)
-  DECLARE_VERIFIER(JSDataView)
+  DECL_PRINTER(JSDataView)
+  DECL_VERIFIER(JSDataView)
 
   static const int kSize = kViewSize;
 
   static const int kSizeWithEmbedderFields =
       kSize + v8::ArrayBufferView::kEmbedderFieldCount * kPointerSize;
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(JSDataView);
 };
 
 
 // Foreign describes objects pointing from JavaScript to C structures.
 class Foreign: public HeapObject {
  public:
   // [address]: field containing the address.
   inline Address foreign_address();
   inline void set_foreign_address(Address value);
 
-  DECLARE_CAST(Foreign)
+  DECL_CAST(Foreign)
 
   // Dispatched behavior.
-  DECLARE_PRINTER(Foreign)
-  DECLARE_VERIFIER(Foreign)
+  DECL_PRINTER(Foreign)
+  DECL_VERIFIER(Foreign)
 
   // Layout description.
 
   static const int kForeignAddressOffset = HeapObject::kHeaderSize;
   static const int kSize = kForeignAddressOffset + kPointerSize;
 
   STATIC_ASSERT(kForeignAddressOffset == Internals::kForeignAddressOffset);
 
   class BodyDescriptor;
   // No weak fields.
@@ skipping 52 matching lines @@
                                                     Handle<JSArray> a,
                                                     PropertyDescriptor* desc,
                                                     ShouldThrow should_throw);
 
   // Checks whether the Array has the current realm's Array.prototype as its
   // prototype. This function is best-effort and only gives a conservative
   // approximation, erring on the side of false, in particular with respect
   // to Proxies and objects with a hidden prototype.
   inline bool HasArrayPrototype(Isolate* isolate);
 
-  DECLARE_CAST(JSArray)
+  DECL_CAST(JSArray)
 
   // Dispatched behavior.
-  DECLARE_PRINTER(JSArray)
-  DECLARE_VERIFIER(JSArray)
+  DECL_PRINTER(JSArray)
+  DECL_VERIFIER(JSArray)
 
   // Number of element slots to pre-allocate for an empty array.
   static const int kPreallocatedArrayElements = 4;
 
   // Layout description.
   static const int kLengthOffset = JSObject::kHeaderSize;
   static const int kSize = kLengthOffset + kPointerSize;
 
   // Max. number of elements being copied in Array builtins.
   static const int kMaxCopyElements = 100;
@@ skipping 52 matching lines @@
   // This either points at the same as above, or a trampoline in case we are
   // running with the simulator. Use these entries from generated code.
   DECL_ACCESSORS(js_getter, Object)
   DECL_ACCESSORS(data, Object)
 
   static Address redirect(Isolate* isolate, Address address,
                           AccessorComponent component);
   Address redirected_getter() const;
 
   // Dispatched behavior.
-  DECLARE_PRINTER(AccessorInfo)
+  DECL_PRINTER(AccessorInfo)
 
   inline bool all_can_read();
   inline void set_all_can_read(bool value);
 
   inline bool all_can_write();
   inline void set_all_can_write(bool value);
 
   inline bool is_special_data_property();
   inline void set_is_special_data_property(bool value);
 
   inline bool replace_on_access();
   inline void set_replace_on_access(bool value);
 
   inline bool is_sloppy();
   inline void set_is_sloppy(bool value);
 
   inline PropertyAttributes property_attributes();
   inline void set_property_attributes(PropertyAttributes attributes);
 
   // Checks whether the given receiver is compatible with this accessor.
   static bool IsCompatibleReceiverMap(Isolate* isolate,
                                       Handle<AccessorInfo> info,
                                       Handle<Map> map);
   inline bool IsCompatibleReceiver(Object* receiver);
 
-  DECLARE_CAST(AccessorInfo)
+  DECL_CAST(AccessorInfo)
 
   // Dispatched behavior.
-  DECLARE_VERIFIER(AccessorInfo)
+  DECL_VERIFIER(AccessorInfo)
 
   // Append all descriptors to the array that are not already there.
   // Return number added.
   static int AppendUnique(Handle<Object> descriptors,
                           Handle<FixedArray> array,
                           int valid_descriptors);
 
   static const int kNameOffset = HeapObject::kHeaderSize;
   static const int kFlagOffset = kNameOffset + kPointerSize;
   static const int kExpectedReceiverTypeOffset = kFlagOffset + kPointerSize;
@@ skipping 23 matching lines @@
 // accessor can either be
 //   * a pointer to a JavaScript function or proxy: a real accessor
 //   * undefined: considered an accessor by the spec, too, strangely enough
 //   * the hole: an accessor which has not been set
 //   * a pointer to a map: a transition used to ensure map sharing
 class AccessorPair: public Struct {
  public:
   DECL_ACCESSORS(getter, Object)
   DECL_ACCESSORS(setter, Object)
 
-  DECLARE_CAST(AccessorPair)
+  DECL_CAST(AccessorPair)
 
   static Handle<AccessorPair> Copy(Handle<AccessorPair> pair);
 
   inline Object* get(AccessorComponent component);
   inline void set(AccessorComponent component, Object* value);
 
   // Note: Returns undefined instead in case of a hole.
   static Handle<Object> GetComponent(Handle<AccessorPair> accessor_pair,
                                      AccessorComponent component);
 
   // Set both components, skipping arguments which are a JavaScript null.
   inline void SetComponents(Object* getter, Object* setter);
 
   inline bool Equals(AccessorPair* pair);
   inline bool Equals(Object* getter_value, Object* setter_value);
 
   inline bool ContainsAccessor();
 
   // Dispatched behavior.
-  DECLARE_PRINTER(AccessorPair)
-  DECLARE_VERIFIER(AccessorPair)
+  DECL_PRINTER(AccessorPair)
+  DECL_VERIFIER(AccessorPair)
 
   static const int kGetterOffset = HeapObject::kHeaderSize;
   static const int kSetterOffset = kGetterOffset + kPointerSize;
   static const int kSize = kSetterOffset + kPointerSize;
 
  private:
   // Strangely enough, in addition to functions and harmony proxies, the spec
   // requires us to consider undefined as a kind of accessor, too:
   //    var obj = {};
   //    Object.defineProperty(obj, "foo", {get: undefined});
   //    assertTrue("foo" in obj);
   inline bool IsJSAccessor(Object* obj);
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(AccessorPair);
 };
 
 
 class AccessCheckInfo: public Struct {
  public:
   DECL_ACCESSORS(callback, Object)
   DECL_ACCESSORS(named_interceptor, Object)
   DECL_ACCESSORS(indexed_interceptor, Object)
   DECL_ACCESSORS(data, Object)
 
-  DECLARE_CAST(AccessCheckInfo)
+  DECL_CAST(AccessCheckInfo)
 
   // Dispatched behavior.
-  DECLARE_PRINTER(AccessCheckInfo)
-  DECLARE_VERIFIER(AccessCheckInfo)
+  DECL_PRINTER(AccessCheckInfo)
+  DECL_VERIFIER(AccessCheckInfo)
 
   static AccessCheckInfo* Get(Isolate* isolate, Handle<JSObject> receiver);
 
   static const int kCallbackOffset = HeapObject::kHeaderSize;
   static const int kNamedInterceptorOffset = kCallbackOffset + kPointerSize;
   static const int kIndexedInterceptorOffset =
       kNamedInterceptorOffset + kPointerSize;
   static const int kDataOffset = kIndexedInterceptorOffset + kPointerSize;
   static const int kSize = kDataOffset + kPointerSize;
 
@@ skipping 12 matching lines @@
   DECL_ACCESSORS(enumerator, Object)
   DECL_ACCESSORS(definer, Object)
   DECL_ACCESSORS(data, Object)
   DECL_BOOLEAN_ACCESSORS(can_intercept_symbols)
   DECL_BOOLEAN_ACCESSORS(all_can_read)
   DECL_BOOLEAN_ACCESSORS(non_masking)
 
   inline int flags() const;
   inline void set_flags(int flags);
 
-  DECLARE_CAST(InterceptorInfo)
+  DECL_CAST(InterceptorInfo)
 
   // Dispatched behavior.
-  DECLARE_PRINTER(InterceptorInfo)
-  DECLARE_VERIFIER(InterceptorInfo)
+  DECL_PRINTER(InterceptorInfo)
+  DECL_VERIFIER(InterceptorInfo)
 
   static const int kGetterOffset = HeapObject::kHeaderSize;
   static const int kSetterOffset = kGetterOffset + kPointerSize;
   static const int kQueryOffset = kSetterOffset + kPointerSize;
   static const int kDescriptorOffset = kQueryOffset + kPointerSize;
   static const int kDeleterOffset = kDescriptorOffset + kPointerSize;
   static const int kEnumeratorOffset = kDeleterOffset + kPointerSize;
   static const int kDefinerOffset = kEnumeratorOffset + kPointerSize;
   static const int kDataOffset = kDefinerOffset + kPointerSize;
   static const int kFlagsOffset = kDataOffset + kPointerSize;
   static const int kSize = kFlagsOffset + kPointerSize;
 
   static const int kCanInterceptSymbolsBit = 0;
   static const int kAllCanReadBit = 1;
   static const int kNonMasking = 2;
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(InterceptorInfo);
 };
 
 class CallHandlerInfo : public Tuple2 {
  public:
   DECL_ACCESSORS(callback, Object)
   DECL_ACCESSORS(data, Object)
 
-  DECLARE_CAST(CallHandlerInfo)
+  DECL_CAST(CallHandlerInfo)
 
   static const int kCallbackOffset = kValue1Offset;
   static const int kDataOffset = kValue2Offset;
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(CallHandlerInfo);
 };
 
 
 class TemplateInfo: public Struct {
  public:
   DECL_ACCESSORS(tag, Object)
   DECL_ACCESSORS(serial_number, Object)
   DECL_INT_ACCESSORS(number_of_properties)
   DECL_ACCESSORS(property_list, Object)
   DECL_ACCESSORS(property_accessors, Object)
 
-  DECLARE_VERIFIER(TemplateInfo)
+  DECL_VERIFIER(TemplateInfo)
 
-  DECLARE_CAST(TemplateInfo)
+  DECL_CAST(TemplateInfo)
 
   static const int kTagOffset = HeapObject::kHeaderSize;
   static const int kSerialNumberOffset = kTagOffset + kPointerSize;
   static const int kNumberOfProperties = kSerialNumberOffset + kPointerSize;
   static const int kPropertyListOffset = kNumberOfProperties + kPointerSize;
   static const int kPropertyAccessorsOffset =
       kPropertyListOffset + kPointerSize;
   static const int kHeaderSize = kPropertyAccessorsOffset + kPointerSize;
 
   static const int kFastTemplateInstantiationsCacheSize = 1 * KB;
@@ skipping 34 matching lines @@
   // If the bit is set, object instances created by this function
   // requires access check.
   DECL_BOOLEAN_ACCESSORS(needs_access_check)
   DECL_BOOLEAN_ACCESSORS(read_only_prototype)
   DECL_BOOLEAN_ACCESSORS(remove_prototype)
   DECL_BOOLEAN_ACCESSORS(do_not_cache)
   DECL_BOOLEAN_ACCESSORS(accept_any_receiver)
 
   DECL_ACCESSORS(cached_property_name, Object)
 
-  DECLARE_CAST(FunctionTemplateInfo)
+  DECL_CAST(FunctionTemplateInfo)
 
   // Dispatched behavior.
-  DECLARE_PRINTER(FunctionTemplateInfo)
-  DECLARE_VERIFIER(FunctionTemplateInfo)
+  DECL_PRINTER(FunctionTemplateInfo)
+  DECL_VERIFIER(FunctionTemplateInfo)
 
   static const int kInvalidSerialNumber = 0;
 
   static const int kCallCodeOffset = TemplateInfo::kHeaderSize;
   static const int kPrototypeTemplateOffset =
       kCallCodeOffset + kPointerSize;
   static const int kPrototypeProviderTemplateOffset =
       kPrototypeTemplateOffset + kPointerSize;
   static const int kParentTemplateOffset =
       kPrototypeProviderTemplateOffset + kPointerSize;
@@ skipping 42 matching lines @@
 };
 
 
 class ObjectTemplateInfo: public TemplateInfo {
  public:
   DECL_ACCESSORS(constructor, Object)
   DECL_ACCESSORS(data, Object)
   DECL_INT_ACCESSORS(embedder_field_count)
   DECL_BOOLEAN_ACCESSORS(immutable_proto)
 
-  DECLARE_CAST(ObjectTemplateInfo)
+  DECL_CAST(ObjectTemplateInfo)
 
   // Dispatched behavior.
-  DECLARE_PRINTER(ObjectTemplateInfo)
-  DECLARE_VERIFIER(ObjectTemplateInfo)
+  DECL_PRINTER(ObjectTemplateInfo)
+  DECL_VERIFIER(ObjectTemplateInfo)
 
   static const int kConstructorOffset = TemplateInfo::kHeaderSize;
   // LSB is for immutable_proto, higher bits for embedder_field_count
   static const int kDataOffset = kConstructorOffset + kPointerSize;
   static const int kSize = kDataOffset + kPointerSize;
 
   // Starting from given object template's constructor walk up the inheritance
   // chain till a function template that has an instance template is found.
   inline ObjectTemplateInfo* GetParent(Isolate* isolate);
 
@@ skipping 10 matching lines @@
   DECL_INT_ACCESSORS(script_id)
   DECL_ACCESSORS(script_name, Object)
   DECL_ACCESSORS(script_name_or_source_url, Object)
   DECL_ACCESSORS(function_name, Object)
   DECL_BOOLEAN_ACCESSORS(is_eval)
   DECL_BOOLEAN_ACCESSORS(is_constructor)
   DECL_BOOLEAN_ACCESSORS(is_wasm)
   DECL_INT_ACCESSORS(flag)
   DECL_INT_ACCESSORS(id)
 
-  DECLARE_CAST(StackFrameInfo)
+  DECL_CAST(StackFrameInfo)
 
   // Dispatched behavior.
-  DECLARE_PRINTER(StackFrameInfo)
-  DECLARE_VERIFIER(StackFrameInfo)
+  DECL_PRINTER(StackFrameInfo)
+  DECL_VERIFIER(StackFrameInfo)
 
   static const int kLineNumberIndex = Struct::kHeaderSize;
   static const int kColumnNumberIndex = kLineNumberIndex + kPointerSize;
   static const int kScriptIdIndex = kColumnNumberIndex + kPointerSize;
   static const int kScriptNameIndex = kScriptIdIndex + kPointerSize;
   static const int kScriptNameOrSourceUrlIndex =
       kScriptNameIndex + kPointerSize;
   static const int kFunctionNameIndex =
       kScriptNameOrSourceUrlIndex + kPointerSize;
   static const int kFlagIndex = kFunctionNameIndex + kPointerSize;
   static const int kIdIndex = kFlagIndex + kPointerSize;
   static const int kSize = kIdIndex + kPointerSize;
 
  private:
   // Bit position in the flag, from least significant bit position.
   static const int kIsEvalBit = 0;
   static const int kIsConstructorBit = 1;
   static const int kIsWasmBit = 2;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(StackFrameInfo);
 };
 
 class SourcePositionTableWithFrameCache : public Tuple2 {
  public:
   DECL_ACCESSORS(source_position_table, ByteArray)
   DECL_ACCESSORS(stack_frame_cache, UnseededNumberDictionary)
 
-  DECLARE_CAST(SourcePositionTableWithFrameCache)
+  DECL_CAST(SourcePositionTableWithFrameCache)
 
   static const int kSourcePositionTableIndex = Struct::kHeaderSize;
   static const int kStackFrameCacheIndex =
       kSourcePositionTableIndex + kPointerSize;
   static const int kSize = kStackFrameCacheIndex + kPointerSize;
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(SourcePositionTableWithFrameCache);
 };
 
@@ skipping 72 matching lines @@
   }
 };
 
 
 }  // NOLINT, false-positive due to second-order macros.
 }  // NOLINT, false-positive due to second-order macros.
 
 #include "src/objects/object-macros-undef.h"
 
 #endif  // V8_OBJECTS_H_