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

src/objects/hash-table.h

 // Copyright 2017 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_HASH_TABLE_H_
 #define V8_OBJECTS_HASH_TABLE_H_
 
 #include "src/objects.h"
 
 #include "src/base/compiler-specific.h"
@@ skipping 122 matching lines @@
  public:
   typedef Shape ShapeT;
   typedef typename Shape::Key Key;
 
   // Returns a new HashTable object.
   MUST_USE_RESULT static Handle<Derived> New(
       Isolate* isolate, int at_least_space_for,
       PretenureFlag pretenure = NOT_TENURED,
       MinimumCapacity capacity_option = USE_DEFAULT_MINIMUM_CAPACITY);
 
-  DECLARE_CAST(HashTable)
+  DECL_CAST(HashTable)
 
   // Garbage collection support.
   void IteratePrefix(ObjectVisitor* visitor);
   void IterateElements(ObjectVisitor* visitor);
 
   // Find entry for key otherwise return kNotFound.
   inline int FindEntry(Key key);
   inline int FindEntry(Isolate* isolate, Key key, int32_t hash);
   int FindEntry(Isolate* isolate, Key key);
 
@@ skipping 121 matching lines @@
   static const bool kNeedsHoleCheck = false;
 };
 
 // ObjectHashTable maps keys that are arbitrary objects to object values by
 // using the identity hash of the key for hashing purposes.
 class ObjectHashTable
     : public HashTable<ObjectHashTable, ObjectHashTableShape> {
   typedef HashTable<ObjectHashTable, ObjectHashTableShape> DerivedHashTable;
 
  public:
-  DECLARE_CAST(ObjectHashTable)
+  DECL_CAST(ObjectHashTable)
 
   // Attempt to shrink hash table after removal of key.
   MUST_USE_RESULT static inline Handle<ObjectHashTable> Shrink(
       Handle<ObjectHashTable> table);
 
   // Looks up the value associated with the given key. The hole value is
   // returned in case the key is not present.
   Object* Lookup(Handle<Object> key);
   Object* Lookup(Handle<Object> key, int32_t hash);
   Object* Lookup(Isolate* isolate, Handle<Object> key, int32_t hash);
@@ skipping 34 matching lines @@
 };
 
 class ObjectHashSet : public HashTable<ObjectHashSet, ObjectHashSetShape> {
  public:
   static Handle<ObjectHashSet> Add(Handle<ObjectHashSet> set,
                                    Handle<Object> key);
 
   inline bool Has(Isolate* isolate, Handle<Object> key, int32_t hash);
   inline bool Has(Isolate* isolate, Handle<Object> key);
 
-  DECLARE_CAST(ObjectHashSet)
+  DECL_CAST(ObjectHashSet)
 };
 
 // OrderedHashTable is a HashTable with Object keys that preserves
 // insertion order. There are Map and Set interfaces (OrderedHashMap
 // and OrderedHashTable, below). It is meant to be used by JSMap/JSSet.
 //
 // Only Object* keys are supported, with Object::SameValueZero() used as the
 // equality operator and Object::GetHash() for the hash function.
 //
 // Based on the "Deterministic Hash Table" as described by Jason Orendorff at
@@ skipping 185 matching lines @@
 
   void SetRemovedIndexAt(int index, int removed_index) {
     return set(kRemovedHolesIndex + index, Smi::FromInt(removed_index));
   }
 
   static const int kRemovedHolesIndex = kHashTableStartIndex;
 };
 
 class OrderedHashSet : public OrderedHashTable<OrderedHashSet, 1> {
  public:
-  DECLARE_CAST(OrderedHashSet)
+  DECL_CAST(OrderedHashSet)
 
   static Handle<OrderedHashSet> Add(Handle<OrderedHashSet> table,
                                     Handle<Object> value);
   static Handle<FixedArray> ConvertToKeysArray(Handle<OrderedHashSet> table,
                                                GetKeysConversion convert);
 };
 
 class OrderedHashMap : public OrderedHashTable<OrderedHashMap, 2> {
  public:
-  DECLARE_CAST(OrderedHashMap)
+  DECL_CAST(OrderedHashMap)
 
   // Returns a value if the OrderedHashMap contains the key, otherwise
   // returns undefined.
   static Object* Get(Isolate* isolate, OrderedHashMap* table, Object* key);
   static Handle<OrderedHashMap> Add(Handle<OrderedHashMap> table,
                                     Handle<Object> key, Handle<Object> value);
   Object* ValueAt(int entry);
 
   static const int kValueOffset = 1;
 };
@@ skipping 10 matching lines @@
   static const bool kNeedsHoleCheck = false;
 };
 
 // WeakHashTable maps keys that are arbitrary heap objects to heap object
 // values. The table wraps the keys in weak cells and store values directly.
 // Thus it references keys weakly and values strongly.
 class WeakHashTable : public HashTable<WeakHashTable, WeakHashTableShape<2>> {
   typedef HashTable<WeakHashTable, WeakHashTableShape<2>> DerivedHashTable;
 
  public:
-  DECLARE_CAST(WeakHashTable)
+  DECL_CAST(WeakHashTable)
 
   // Looks up the value associated with the given key. The hole value is
   // returned in case the key is not present.
   Object* Lookup(Handle<HeapObject> key);
 
   // Adds (or overwrites) the value associated with the given key. Mapping a
   // key to the hole value causes removal of the whole entry.
   MUST_USE_RESULT static Handle<WeakHashTable> Put(Handle<WeakHashTable> table,
                                                    Handle<HeapObject> key,
                                                    Handle<HeapObject> value);
@@ skipping 159 matching lines @@
   static const int kLoadFactor = 2;
   static const int kBitsPerPointer = kPointerSize * kBitsPerByte;
 
   // Our growth strategy involves doubling the capacity until we reach
   // kMaxCapacity, but since the kMaxCapacity is always less than 256,
   // we will never fully utilize this table. We special case for 256,
   // by changing the new capacity to be kMaxCapacity in
   // SmallOrderedHashTable::Grow.
   static const int kGrowthHack = 256;
 
-  DECLARE_VERIFIER(SmallOrderedHashTable)
+  DECL_VERIFIER(SmallOrderedHashTable)
 
  protected:
   // This is used for accessing the non |DataTable| part of the
   // structure.
   byte get(int index) {
     return READ_BYTE_FIELD(this, kHeaderSize + (index * kOneByteSize));
   }
 
   void set(int index, byte value) {
     WRITE_BYTE_FIELD(this, kHeaderSize + (index * kOneByteSize), value);
   }
 
   int GetDataEntryOffset(int entry, int relative_index) {
     int datatable_start = GetDataTableStartOffset();
     int offset_in_datatable = entry * Derived::kEntrySize * kPointerSize;
     int offset_in_entry = relative_index * kPointerSize;
     return datatable_start + offset_in_datatable + offset_in_entry;
   }
 
   // Returns the number elements that can fit into the allocated buffer.
   int Capacity() { return NumberOfBuckets() * kLoadFactor; }
 
   int UsedCapacity() { return NumberOfElements() + NumberOfDeletedElements(); }
 };
 
 class SmallOrderedHashSet : public SmallOrderedHashTable<SmallOrderedHashSet> {
  public:
-  DECLARE_CAST(SmallOrderedHashSet)
+  DECL_CAST(SmallOrderedHashSet)
 
-  DECLARE_PRINTER(SmallOrderedHashSet)
+  DECL_PRINTER(SmallOrderedHashSet)
 
   static const int kKeyIndex = 0;
   static const int kEntrySize = 1;
 
   // Adds |value| to |table|, if the capacity isn't enough, a new
   // table is created. The original |table| is returned if there is
   // capacity to store |value| otherwise the new table is returned.
   static Handle<SmallOrderedHashSet> Add(Handle<SmallOrderedHashSet> table,
                                          Handle<Object> key);
 };
 
 class SmallOrderedHashMap : public SmallOrderedHashTable<SmallOrderedHashMap> {
  public:
-  DECLARE_CAST(SmallOrderedHashMap)
+  DECL_CAST(SmallOrderedHashMap)
 
-  DECLARE_PRINTER(SmallOrderedHashMap)
+  DECL_PRINTER(SmallOrderedHashMap)
 
   static const int kKeyIndex = 0;
   static const int kValueIndex = 1;
   static const int kEntrySize = 2;
 
   // Adds |value| to |table|, if the capacity isn't enough, a new
   // table is created. The original |table| is returned if there is
   // capacity to store |value| otherwise the new table is returned.
   static Handle<SmallOrderedHashMap> Add(Handle<SmallOrderedHashMap> table,
                                          Handle<Object> key,
@@ skipping 56 matching lines @@
   // if the [table] is not obsolete.
   void Transition();
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(OrderedHashTableIterator);
 };
 
 class JSSetIterator
     : public OrderedHashTableIterator<JSSetIterator, OrderedHashSet> {
  public:
   // Dispatched behavior.
-  DECLARE_PRINTER(JSSetIterator)
-  DECLARE_VERIFIER(JSSetIterator)
+  DECL_PRINTER(JSSetIterator)
+  DECL_VERIFIER(JSSetIterator)
 
-  DECLARE_CAST(JSSetIterator)
+  DECL_CAST(JSSetIterator)
 
   // Called by |Next| to populate the array. This allows the subclasses to
   // populate the array differently.
   inline void PopulateValueArray(FixedArray* array);
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(JSSetIterator);
 };
 
 class JSMapIterator
     : public OrderedHashTableIterator<JSMapIterator, OrderedHashMap> {
  public:
   // Dispatched behavior.
-  DECLARE_PRINTER(JSMapIterator)
-  DECLARE_VERIFIER(JSMapIterator)
+  DECL_PRINTER(JSMapIterator)
+  DECL_VERIFIER(JSMapIterator)
 
-  DECLARE_CAST(JSMapIterator)
+  DECL_CAST(JSMapIterator)
 
   // Called by |Next| to populate the array. This allows the subclasses to
   // populate the array differently.
   inline void PopulateValueArray(FixedArray* array);
 
   // Returns the current value of the iterator. This should only be called when
   // |HasMore| returns true.
   inline Object* CurrentValue();
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(JSMapIterator);
 };
 
 }  // namespace internal
 }  // namespace v8
 
 #include "src/objects/object-macros-undef.h"
 
 #endif  // V8_OBJECTS_HASH_TABLE_H_