replace COMPILE_ASSERT with static_assert in platform/

Source/platform/heap/Heap.h

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 162 matching lines @@
     explicit HeapObjectHeader(size_t encodedSize)
         : m_size(encodedSize)
 #if ENABLE(ASSERT)
         , m_magic(magic)
 #endif
     {
         // sizeof(HeapObjectHeader) must be equal to or smaller than
         // allocationGranurarity, because HeapObjectHeader is used as a header
         // for an freed entry.  Given that the smallest entry size is
         // allocationGranurarity, HeapObjectHeader must fit into the size.
-        COMPILE_ASSERT(sizeof(HeapObjectHeader) <= allocationGranularity, SizeOfHeapObjectHeaderMustBeSmallerThanAllocationGranularity);
+        static_assert(sizeof(HeapObjectHeader) <= allocationGranularity, "size of HeapObjectHeader must be smaller than allocationGranularity");
     }
 
     NO_SANITIZE_ADDRESS
     HeapObjectHeader(size_t encodedSize, const GCInfo*)
         : m_size(encodedSize)
 #if ENABLE(ASSERT)
         , m_magic(magic)
 #endif
     {
-        COMPILE_ASSERT(sizeof(HeapObjectHeader) <= allocationGranularity, SizeOfHeapObjectHeaderMustBeSmallerThanAllocationGranularity);
+        static_assert(sizeof(HeapObjectHeader) <= allocationGranularity, "size of HeapObjectHeader must be smaller than allocationGranularity");
     }
 
     static size_t freeListEncodedSize(size_t size) { return size | freeListMask; }
 
     NO_SANITIZE_ADDRESS
     bool isFree() { return m_size & freeListMask; }
     NO_SANITIZE_ADDRESS
     bool isPromptlyFreed() { return (m_size & promptlyFreedMask) == promptlyFreedMask; }
     NO_SANITIZE_ADDRESS
     void markPromptlyFreed() { m_size |= promptlyFreedMask; }
@@ skipping 330 matching lines @@
 // object.
 //
 // The layout of a large heap object is as follows:
 //
 // | BaseHeapPage | next pointer | GeneralHeapObjectHeader or HeapObjectHeader | payload |
 template<typename Header>
 class LargeObject final : public BaseHeapPage {
 public:
     LargeObject(PageMemory* storage, const GCInfo* gcInfo, ThreadState* state) : BaseHeapPage(storage, gcInfo, state)
     {
-        COMPILE_ASSERT(!(sizeof(LargeObject<Header>) & allocationMask), large_heap_object_header_misaligned);
+        static_assert(!(sizeof(LargeObject<Header>) & allocationMask), "LargeObject<Header> misaligned");
     }
 
     virtual void checkAndMarkPointer(Visitor*, Address) override;
     virtual bool isLargeObject() override { return true; }
 
 #if ENABLE(GC_PROFILE_MARKING)
     virtual const GCInfo* findGCInfo(Address address)
     {
         if (!objectContains(address))
             return nullptr;
@@ skipping 1085 matching lines @@
         void swap(AllocatorProvider& other) { }
     };
 
     void deallocate(void* dummy) { }
 
     // This is not a static method even though it could be, because it needs to
     // match the one that the (off-heap) ListHashSetAllocator has.  The 'this'
     // pointer will always be null.
     void* allocateNode()
     {
-        COMPILE_ASSERT(!WTF::IsWeak<ValueArg>::value, WeakPointersInAListHashSetWillJustResultInNullEntriesInTheSetThatsNotWhatYouWantConsiderUsingLinkedHashSetInstead);
+        // Consider using a LinkedHashSet instead if this compile-time assert fails:
+        static_assert(!WTF::IsWeak<ValueArg>::value, "weak pointers in a ListHashSet will result in null entries in the set");
+
         return malloc<void*, Node>(sizeof(Node));
     }
 
     static void traceValue(Visitor* visitor, Node* node)
     {
         traceListHashSetValue(visitor, node->m_value);
     }
 };
 
 // FIXME: These should just be template aliases:
@@ skipping 468 matching lines @@
 // Vector backing that needs marking. We don't support weak members in vectors.
 template<ShouldWeakPointersBeMarkedStrongly strongify, typename T, typename Traits>
 struct TraceInCollectionTrait<NoWeakHandlingInCollections, strongify, blink::HeapVectorBacking<T, Traits>, void> {
     static bool trace(blink::Visitor* visitor, void* self)
     {
         // The allocator can oversize the allocation a little, according to
         // the allocation granularity.  The extra size is included in the
         // payloadSize call below, since there is nowhere to store the
         // originally allocated memory.  This assert ensures that visiting the
         // last bit of memory can't cause trouble.
-        COMPILE_ASSERT(!ShouldBeTraced<Traits>::value || sizeof(T) > blink::allocationGranularity || Traits::canInitializeWithMemset, HeapOverallocationCanCauseSpuriousVisits);
+        static_assert(!ShouldBeTraced<Traits>::value || sizeof(T) > blink::allocationGranularity || Traits::canInitializeWithMemset, "heap overallocation can cause spurious visits");
 
         T* array = reinterpret_cast<T*>(self);
         blink::GeneralHeapObjectHeader* header = blink::GeneralHeapObjectHeader::fromPayload(self);
         // Use the payload size as recorded by the heap to determine how many
         // elements to mark.
         size_t length = header->payloadSize() / sizeof(T);
         for (size_t i = 0; i < length; ++i)
             blink::CollectionBackingTraceTrait<ShouldBeTraced<Traits>::value, Traits::weakHandlingFlag, WeakPointersActStrong, T, Traits>::trace(visitor, array[i]);
         return false;
     }
@@ skipping 75 matching lines @@
         // side is alive, which causes the strong pointer on the key side to be
         // marked.  If that then results in the object pointed to by the weak
         // pointer on the value side being marked live, then the whole
         // key-value entry is leaked.  To avoid unexpected leaking, we disallow
         // this case, but if you run into this assert, please reach out to Blink
         // reviewers, and we may relax it.
         const bool keyIsWeak = Traits::KeyTraits::weakHandlingFlag == WeakHandlingInCollections;
         const bool valueIsWeak = Traits::ValueTraits::weakHandlingFlag == WeakHandlingInCollections;
         const bool keyHasStrongRefs = ShouldBeTraced<typename Traits::KeyTraits>::value;
         const bool valueHasStrongRefs = ShouldBeTraced<typename Traits::ValueTraits>::value;
-        COMPILE_ASSERT(!keyIsWeak || !valueIsWeak || !keyHasStrongRefs || !valueHasStrongRefs, ThisConfigurationWasDisallowedToAvoidUnexpectedLeaks);
+        static_assert(!keyIsWeak || !valueIsWeak || !keyHasStrongRefs || !valueHasStrongRefs, "this configuration is disallowed to avoid unexpected leaks");
         if ((valueIsWeak && !keyIsWeak) || (valueIsWeak && keyIsWeak && !valueHasStrongRefs)) {
             // Check value first.
             bool deadWeakObjectsFoundOnValueSide = blink::CollectionBackingTraceTrait<ShouldBeTraced<typename Traits::ValueTraits>::value, Traits::ValueTraits::weakHandlingFlag, strongify, Value, typename Traits::ValueTraits>::trace(visitor, self.value);
             if (deadWeakObjectsFoundOnValueSide)
                 return true;
             return blink::CollectionBackingTraceTrait<ShouldBeTraced<typename Traits::KeyTraits>::value, Traits::KeyTraits::weakHandlingFlag, strongify, Key, typename Traits::KeyTraits>::trace(visitor, self.key);
         }
         // Check key first.
         bool deadWeakObjectsFoundOnKeySide = blink::CollectionBackingTraceTrait<ShouldBeTraced<typename Traits::KeyTraits>::value, Traits::KeyTraits::weakHandlingFlag, strongify, Key, typename Traits::KeyTraits>::trace(visitor, self.key);
         if (deadWeakObjectsFoundOnKeySide)
@@ skipping 53 matching lines @@
 };
 
 template<typename T>
 static void verifyGarbageCollectedIfMember(T*)
 {
 }
 
 template<typename T>
 static void verifyGarbageCollectedIfMember(Member<T>* t)
 {
-    COMPILE_ASSERT_IS_GARBAGE_COLLECTED(T, NonGarbageCollectedObjectInMember);
+    STATIC_ASSERT_IS_GARBAGE_COLLECTED(T, "non garbage collected object in member");
 }
 
 // Specialization for things that either need marking or have weak pointers or
 // both.
 template<bool needsTracing, WTF::WeakHandlingFlag weakHandlingFlag, WTF::ShouldWeakPointersBeMarkedStrongly strongify, typename T, typename Traits>
 struct CollectionBackingTraceTrait {
     static bool trace(Visitor* visitor, T&t)
     {
         verifyGarbageCollectedIfMember(reinterpret_cast<T*>(0));
         return WTF::TraceInCollectionTrait<weakHandlingFlag, strongify, T, Traits>::trace(visitor, t);
@@ skipping 24 matching lines @@
     {
         return t.traceInCollection(visitor, strongify);
     }
 };
 
 template<typename T, typename Traits>
 struct TraceTrait<HeapVectorBacking<T, Traits>> {
     using Backing = HeapVectorBacking<T, Traits>;
     static void trace(Visitor* visitor, void* self)
     {
-        COMPILE_ASSERT(!WTF::IsWeak<T>::value, WeDontSupportWeaknessInHeapVectorsOrDeques);
+        static_assert(!WTF::IsWeak<T>::value, "weakness in HeapVectors and Deques are not supported");
         if (WTF::ShouldBeTraced<Traits>::value)
             WTF::TraceInCollectionTrait<WTF::NoWeakHandlingInCollections, WTF::WeakPointersActWeak, HeapVectorBacking<T, Traits>, void>::trace(visitor, self);
     }
     static void mark(Visitor* visitor, const Backing* backing)
     {
         visitor->mark(backing, &trace);
     }
     static void checkGCInfo(Visitor* visitor, const Backing* backing)
     {
 #if ENABLE(ASSERT)
@@ skipping 59 matching lines @@
 template<typename T, size_t inlineCapacity>
 struct GCInfoTrait<HeapVector<T, inlineCapacity>> : public GCInfoTrait<Vector<T, inlineCapacity, HeapAllocator>> { };
 template<typename T, size_t inlineCapacity>
 struct GCInfoTrait<HeapDeque<T, inlineCapacity>> : public GCInfoTrait<Deque<T, inlineCapacity, HeapAllocator>> { };
 template<typename T, typename U, typename V>
 struct GCInfoTrait<HeapHashCountedSet<T, U, V>> : public GCInfoTrait<HashCountedSet<T, U, V, HeapAllocator>> { };
 
 } // namespace blink
 
 #endif // Heap_h