Check that classes with non-trivial destructors have finalization support.

tools/clang/blink_gc_plugin/tests/heap/stubs.h

 // Copyright 2014 The Chromium 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 HEAP_STUBS_H_
 #define HEAP_STUBS_H_
 
 #include "stddef.h"
 
 namespace WTF {
 
 template<typename T> class RefCounted { };
 
 template<typename T> class RawPtr {
 public:
     operator T*() const { return 0; }
 };
 
 template<typename T> class RefPtr {
 public:
     operator T*() const { return 0; }
 };
 
 template<typename T> class OwnPtr {
 public:
     operator T*() const { return 0; }
 };
 
-class DefaultAllocator { };
+class DefaultAllocator {
+public:
+    static const bool isGarbageCollected = false;
+};
+
+template<typename T>
+struct VectorTraits {
+    static const bool needsDestruction = true;
+};
+
+template<size_t inlineCapacity, bool isGarbageCollected, bool tNeedsDestruction>
+class VectorDestructorBase {
+public:
+    ~VectorDestructorBase() {}
+};
+
+template<size_t inlineCapacity>
+class VectorDestructorBase<inlineCapacity, true, false> {};
+
+template<>
+class VectorDestructorBase<0, true, true> {};
 
 template<typename T,
          size_t inlineCapacity = 0,
          typename Allocator = DefaultAllocator>
-class Vector { };
+class Vector : public VectorDestructorBase<inlineCapacity,
+                                           Allocator::isGarbageCollected,
+                                           VectorTraits<T>::needsDestruction> {
+};
 
 }
 
 namespace WebCore {
 
 using namespace WTF;
 
 #define DISALLOW_ALLOCATION()                   \
     private:                                    \
     void* operator new(size_t) = delete;
@@ skipping 19 matching lines @@
 template<typename T> class Member {
 public:
     operator T*() const { return 0; }
 };
 
 template<typename T> class Persistent {
 public:
     operator T*() const { return 0; }
 };
 
-class HeapAllocator { };
+class HeapAllocator {
+public:
+    static const bool isGarbageCollected = true;
+};
 
-template<typename T>
-class HeapVector : public Vector<T, 0, HeapAllocator> { };
+template<typename T, size_t inlineCapacity = 0>
+class HeapVector : public Vector<T, inlineCapacity, HeapAllocator> { };
 
 template<typename T>
 class PersistentHeapVector : public Vector<T, 0, HeapAllocator> { };
 
 class Visitor {
 public:
     template<typename T> void trace(const T&);
 };
 
 class GarbageCollectedMixin {
     virtual void adjustAndMark(Visitor*) const = 0;
     virtual bool isAlive(Visitor*) const = 0;
 };
 
 }
 
+namespace WTF {
+
+template<typename T>
+struct VectorTraits<WebCore::Member<T> > {
+    static const bool needsDestruction = false;
+};
+
+}
+
 #endif