replace COMPILE_ASSERT with static_assert in platform/

Source/platform/heap/Visitor.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 47 matching lines @@
 template<typename T> class GarbageCollected;
 template<typename T> class GarbageCollectedFinalized;
 class GarbageCollectedMixin;
 class GeneralHeapObjectHeader;
 class HeapObjectHeader;
 template<typename T> class Member;
 template<typename T> class WeakMember;
 class Visitor;
 
 template <typename T> struct IsGarbageCollectedType;
-#define COMPILE_ASSERT_IS_GARBAGE_COLLECTED(T, ErrorMessage) \
-    COMPILE_ASSERT(IsGarbageCollectedType<T>::value, ErrorMessage)
-#define COMPILE_ASSERT_IS_NOT_GARBAGE_COLLECTED(T, ErrorMessage) \
-    COMPILE_ASSERT(!IsGarbageCollectedType<T>::value, ErrorMessage)
+#define STATIC_ASSERT_IS_GARBAGE_COLLECTED(T, ErrorMessage) \
+    static_assert(IsGarbageCollectedType<T>::value, ErrorMessage)
+#define STATIC_ASSERT_IS_NOT_GARBAGE_COLLECTED(T, ErrorMessage) \
+    static_assert(!IsGarbageCollectedType<T>::value, ErrorMessage)
 
 template<bool needsTracing, WTF::WeakHandlingFlag weakHandlingFlag, WTF::ShouldWeakPointersBeMarkedStrongly strongify, typename T, typename Traits> struct CollectionBackingTraceTrait;
 
 // The TraceMethodDelegate is used to convert a trace method for type T to a TraceCallback.
 // This allows us to pass a type's trace method as a parameter to the PersistentNode
 // constructor. The PersistentNode constructor needs the specific trace method due an issue
 // with the Windows compiler which instantiates even unused variables. This causes problems
 // in header files where we have only forward declarations of classes.
 template<typename T, void (T::*method)(Visitor*)>
 struct TraceMethodDelegate {
@@ skipping 195 matching lines @@
     template<typename T>
     void mark(T* t)
     {
         if (!t)
             return;
 #if ENABLE(ASSERT)
         TraceTrait<T>::checkGCInfo(t);
 #endif
         TraceTrait<T>::mark(toDerived(), t);
 
-        COMPILE_ASSERT_IS_GARBAGE_COLLECTED(T, AttemptedToMarkNonGarbageCollectedObject);
+        STATIC_ASSERT_IS_GARBAGE_COLLECTED(T, "attempted to mark non garbage collected object");
     }
 
     // Member version of the one-argument templated trace method.
     template<typename T>
     void trace(const Member<T>& t)
     {
         toDerived()->mark(t.get());
     }
 
     // Fallback method used only when we need to trace raw pointers of T.
@@ skipping 13 matching lines @@
     // WeakMember version of the templated trace method. It doesn't keep
     // the traced thing alive, but will write null to the WeakMember later
     // if the pointed-to object is dead. It's lying for this to be const,
     // but the overloading resolver prioritizes constness too high when
     // picking the correct overload, so all these trace methods have to have
     // the same constness on their argument to allow the type to decide.
     template<typename T>
     void trace(const WeakMember<T>& t)
     {
         // Check that we actually know the definition of T when tracing.
-        COMPILE_ASSERT(sizeof(T), WeNeedToKnowTheDefinitionOfTheTypeWeAreTracing);
+        static_assert(sizeof(T), "we need to know the definition of the type we are tracing");
         registerWeakCell(const_cast<WeakMember<T>&>(t).cell());
-        COMPILE_ASSERT_IS_GARBAGE_COLLECTED(T, AttemptedToWeakTraceNonGarbageCollectedObject);
+        STATIC_ASSERT_IS_GARBAGE_COLLECTED(T, "cannot weak trace non garbage collected object");
     }
 
     template<typename T>
     void traceInCollection(T& t, WTF::ShouldWeakPointersBeMarkedStrongly strongify)
     {
         HashTraits<T>::traceInCollection(toDerived(), t, strongify);
     }
 
     // Fallback trace method for part objects to allow individual trace methods
     // to trace through a part object with visitor->trace(m_partObject). This
@@ skipping 53 matching lines @@
     template<typename T> void trace(const RawPtr<T>&) { }
     template<typename T> void trace(const WeakPtr<T>&) { }
 
     // On non-oilpan builds, it is convenient to allow calling trace on
     // WillBeHeap{Vector,Deque}<FooPtrWillBeMember<T>>.
     // Forbid tracing on-heap objects in off-heap collections.
     // This is forbidden because convservative marking cannot identify
     // those off-heap collection backing stores.
     template<typename T, size_t inlineCapacity> void trace(const Vector<OwnPtr<T>, inlineCapacity>& vector)
     {
-        COMPILE_ASSERT_IS_NOT_GARBAGE_COLLECTED(T, AttemptedToTraceGarbageCollectedObjectInsideVector);
+        STATIC_ASSERT_IS_NOT_GARBAGE_COLLECTED(T, "cannot trace garbage collected object inside Vector");
     }
     template<typename T, size_t inlineCapacity> void trace(const Vector<RefPtr<T>, inlineCapacity>& vector)
     {
-        COMPILE_ASSERT_IS_NOT_GARBAGE_COLLECTED(T, AttemptedToTraceGarbageCollectedObjectInsideVector);
+        STATIC_ASSERT_IS_NOT_GARBAGE_COLLECTED(T, "cannot trace garbage collected object inside Vector");
     }
     template<typename T, size_t inlineCapacity> void trace(const Vector<RawPtr<T>, inlineCapacity>& vector)
     {
-        COMPILE_ASSERT_IS_NOT_GARBAGE_COLLECTED(T, AttemptedToTraceGarbageCollectedObjectInsideVector);
+        STATIC_ASSERT_IS_NOT_GARBAGE_COLLECTED(T, "cannot trace garbage collected object inside Vector");
     }
     template<typename T, size_t inlineCapacity> void trace(const Vector<WeakPtr<T>, inlineCapacity>& vector)
     {
-        COMPILE_ASSERT_IS_NOT_GARBAGE_COLLECTED(T, AttemptedToTraceGarbageCollectedObjectInsideVector);
+        STATIC_ASSERT_IS_NOT_GARBAGE_COLLECTED(T, "cannot trace garbage collected object inside Vector");
     }
     template<typename T, size_t N> void trace(const Deque<OwnPtr<T>, N>& deque)
     {
-        COMPILE_ASSERT_IS_NOT_GARBAGE_COLLECTED(T, AttemptedToTraceGarbageCollectedObjectInsideDeque);
+        STATIC_ASSERT_IS_NOT_GARBAGE_COLLECTED(T, "cannot trace garbage collected object inside Deque");
     }
     template<typename T, size_t N> void trace(const Deque<RefPtr<T>, N>& deque)
     {
-        COMPILE_ASSERT_IS_NOT_GARBAGE_COLLECTED(T, AttemptedToTraceGarbageCollectedObjectInsideDeque);
+        STATIC_ASSERT_IS_NOT_GARBAGE_COLLECTED(T, "cannot trace garbage collected object inside Deque");
     }
     template<typename T, size_t N> void trace(const Deque<RawPtr<T>, N>& deque)
     {
-        COMPILE_ASSERT_IS_NOT_GARBAGE_COLLECTED(T, AttemptedToTraceGarbageCollectedObjectInsideDeque);
+        STATIC_ASSERT_IS_NOT_GARBAGE_COLLECTED(T, "cannot trace garbage collected object inside Deque");
     }
     template<typename T, size_t N> void trace(const Deque<WeakPtr<T>, N>& deque)
     {
-        COMPILE_ASSERT_IS_NOT_GARBAGE_COLLECTED(T, AttemptedToTraceGarbageCollectedObjectInsideDeque);
+        STATIC_ASSERT_IS_NOT_GARBAGE_COLLECTED(T, "cannot trace garbage collected object inside Deque");
     }
 #endif
 
     void markNoTracing(const void* pointer) { toDerived()->mark(pointer, reinterpret_cast<TraceCallback>(0)); }
     void markHeaderNoTracing(HeapObjectHeader* header) { toDerived()->markHeader(header, reinterpret_cast<TraceCallback>(0)); }
     void markHeaderNoTracing(GeneralHeapObjectHeader* header) { toDerived()->markHeader(header, reinterpret_cast<TraceCallback>(0)); }
     template<typename T> void markNoTracing(const T* pointer) { toDerived()->mark(pointer, reinterpret_cast<TraceCallback>(0)); }
 
     template<typename T> inline bool isAlive(T* obj)
     {
         // Check that we actually know the definition of T when tracing.
-        COMPILE_ASSERT(sizeof(T), WeNeedToKnowTheDefinitionOfTheTypeWeAreTracing);
+        static_assert(sizeof(T), "T must be fully defined");
         // The strongification of collections relies on the fact that once a
         // collection has been strongified, there is no way that it can contain
         // non-live entries, so no entries will be removed. Since you can't set
         // the mark bit on a null pointer, that means that null pointers are
         // always 'alive'.
         if (!obj)
             return true;
         return ObjectAliveTrait<T>::isHeapObjectAlive(toDerived(), obj);
     }
     template<typename T> inline bool isAlive(const Member<T>& member)
@@ skipping 303 matching lines @@
     virtual void adjustAndMark(Visitor*) const = 0;
     virtual bool isHeapObjectAlive(Visitor*) const = 0;
     virtual void trace(Visitor*) { }
 };
 
 #define USING_GARBAGE_COLLECTED_MIXIN(TYPE) \
 public: \
     virtual void adjustAndMark(blink::Visitor* visitor) const override \
     { \
         typedef WTF::IsSubclassOfTemplate<typename WTF::RemoveConst<TYPE>::Type, blink::GarbageCollected> IsSubclassOfGarbageCollected; \
-        COMPILE_ASSERT(IsSubclassOfGarbageCollected::value, OnlyGarbageCollectedObjectsCanHaveGarbageCollectedMixins);                  \
+        static_assert(IsSubclassOfGarbageCollected::value, "only garbage collected objects can have garbage collected mixins");         \
         if (TraceEagerlyTrait<TYPE>::value) {                                           \
             if (visitor->ensureMarked(static_cast<const TYPE*>(this)))                  \
                 TraceTrait<TYPE>::trace(visitor, const_cast<TYPE*>(this));              \
             return;                                                                     \
         }                                                                               \
         visitor->mark(static_cast<const TYPE*>(this), &blink::TraceTrait<TYPE>::trace); \
     } \
     virtual bool isHeapObjectAlive(blink::Visitor* visitor) const override              \
     { \
         return visitor->isAlive(this); \
@@ skipping 50 matching lines @@
 struct GCInfoTrait {
     static const GCInfo* get()
     {
         return GCInfoAtBase<typename GetGarbageCollectedBase<T>::type>::get();
     }
 };
 
 }
 
 #endif