Ensure proper finalization of garbage-collected types.

Source/wtf/Vector.h

 /*
  *  Copyright (C) 2005, 2006, 2007, 2008 Apple Inc. All rights reserved.
  *
  *  This library is free software; you can redistribute it and/or
  *  modify it under the terms of the GNU Library General Public
  *  License as published by the Free Software Foundation; either
  *  version 2 of the License, or (at your option) any later version.
  *
  *  This library is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ skipping 295 matching lines @@
             , m_capacity(0)
         {
         }
 
         VectorBufferBase(T* buffer, size_t capacity)
             : m_buffer(buffer)
             , m_capacity(capacity)
         {
         }
 
-        ~VectorBufferBase()
-        {
-        }
-
         T* m_buffer;
         unsigned m_capacity;
         unsigned m_size;
     };
 
     template<typename T, size_t inlineCapacity, typename Allocator = DefaultAllocator>
     class VectorBuffer;
 
     template<typename T, typename Allocator>
     class VectorBuffer<T, 0, Allocator> : private VectorBufferBase<T, Allocator> {
     private:
         typedef VectorBufferBase<T, Allocator> Base;
     public:
         VectorBuffer()
         {
         }
 
         VectorBuffer(size_t capacity)
         {
             // Calling malloc(0) might take a lock and may actually do an
             // allocation on some systems.
             if (capacity)
                 allocateBuffer(capacity);
         }
 
-        ~VectorBuffer()
-        {
-        }
-
         void destruct()
         {
             deallocateBuffer(m_buffer);
             m_buffer = 0;
         }
 
         void deallocateBuffer(T* bufferToDeallocate)
         {
             Allocator::backingFree(bufferToDeallocate);
         }
@@ skipping 41 matching lines @@
         {
         }
 
         VectorBuffer(size_t capacity)
             : Base(inlineBuffer(), inlineCapacity)
         {
             if (capacity > inlineCapacity)
                 Base::allocateBuffer(capacity);
         }
 
-        ~VectorBuffer()
-        {
-        }
-
         void destruct()
         {
             deallocateBuffer(m_buffer);
             m_buffer = 0;
         }
 
         NEVER_INLINE void reallyDeallocateBuffer(T* bufferToDeallocate)
         {
             Allocator::backingFree(bufferToDeallocate);
         }
@@ skipping 62 matching lines @@
         using Base::m_buffer;
         using Base::m_capacity;
 
         static const size_t m_inlineBufferSize = inlineCapacity * sizeof(T);
         T* inlineBuffer() { return reinterpret_cast_ptr<T*>(m_inlineBuffer.buffer); }
         const T* inlineBuffer() const { return reinterpret_cast_ptr<const T*>(m_inlineBuffer.buffer); }
 
         AlignedBuffer<m_inlineBufferSize, WTF_ALIGN_OF(T)> m_inlineBuffer;
     };
 
+    template<typename T, size_t inlineCapacity, typename Allocator>
+    class Vector;
+
+    // VectorDestructorBase defines the destructor of a vector. This base is used in order to
+    // completely avoid creating a destructor for a vector that does not need to be destructed.
+    // By doing so, the clang compiler will have correct information about whether or not a
+    // vector has a trivial destructor and we use that in a compiler plugin to ensure the
+    // correctness of non-finalized garbage-collected classes and the use of VectorTraits::needsDestruction.
+
+    // All non-GC managed vectors needs a destructor. This destructor will simply call finalize on the actual vector type.
+    template<typename Derived, typename Elements, bool hasInlineCapacity, bool isGarbageCollected>
+    class VectorDestructorBase {
+    public:
+        ~VectorDestructorBase() { static_cast<Derived*>(this)->finalize(); }
+    };
+
+    // Heap-allocated vectors with no inlineCapacity never need a destructor.
+    template<typename Derived, typename Elements>
+    class VectorDestructorBase<Derived, Elements, false, true> { };
+
+    // Heap-allocator vectors with inlineCapacity need a destructor if the inline elements do.
+    // The use of VectorTraits<Elements>::needsDestruction is delayed until we know that
+    // inlineCapacity is non-zero to allow classes that recursively refer to themselves in vector
+    // members. If inlineCapacity is non-zero doing so would have undefined meaning, so in this
+    // case we can use HeapVectorWithInlineCapacityDestructorBase to define a destructor
+    // depending on the value of VectorTraits<Elements>::needsDestruction.
+    template<typename Derived, bool elementsNeedsDestruction>
+    class HeapVectorWithInlineCapacityDestructorBase;
+
+    template<typename Derived>
+    class HeapVectorWithInlineCapacityDestructorBase<Derived, true> {
+    public:
+        ~HeapVectorWithInlineCapacityDestructorBase() { static_cast<Derived*>(this)->finalize(); }
+    };
+
+    template<typename Derived>
+    class HeapVectorWithInlineCapacityDestructorBase<Derived, false> { };
+
+    template<typename Derived, typename Elements>
+    class VectorDestructorBase<Derived, Elements, true, true> : public HeapVectorWithInlineCapacityDestructorBase<Derived, VectorTraits<Elements>::needsDestruction> { };
+
     template<typename T, size_t inlineCapacity = 0, typename Allocator = DefaultAllocator>
-    class Vector : private VectorBuffer<T, inlineCapacity, Allocator> {
+    class Vector : private VectorBuffer<T, inlineCapacity, Allocator>, public VectorDestructorBase<Vector<T, inlineCapacity, Allocator>, T, (inlineCapacity > 0), Allocator::isGarbageCollected> {
     private:
         typedef VectorBuffer<T, inlineCapacity, Allocator> Base;
         typedef VectorTypeOperations<T> TypeOperations;
 
     public:
         typedef T ValueType;
 
         typedef T* iterator;
         typedef const T* const_iterator;
         typedef std::reverse_iterator<iterator> reverse_iterator;
@@ skipping 21 matching lines @@
             : Base(size)
         {
             m_size = size;
             TypeOperations::initialize(begin(), end());
         }
 
         // Off-GC-heap vectors: Destructor should be called.
         // On-GC-heap vectors: Destructor should be called for inline buffers
         // (if any) but destructor shouldn't be called for vector backing since
         // it is managed by the traced GC heap.
-        ~Vector()
+        void finalize()
         {
             if (!inlineCapacity) {
                 if (LIKELY(!Base::buffer()))
                     return;
             }
             if (LIKELY(m_size) && !(Allocator::isGarbageCollected && this->hasOutOfLineBuffer())) {
                 TypeOperations::destruct(begin(), end());
                 m_size = 0; // Partial protection against use-after-free.
             }
 
             Base::destruct();
         }
 
-        void finalize()
-        {
-            this->~Vector();
-        }
-
         void clearUnusedSlots(T* from, T* to)
         {
             VectorUnusedSlotClearer<Allocator::isGarbageCollected && (VectorTraits<T>::needsDestruction || ShouldBeTraced<VectorTraits<T> >::value || VectorTraits<T>::isWeak), T>::clear(from, to);
         }
 
         Vector(const Vector&);
         template<size_t otherCapacity>
         explicit Vector(const Vector<T, otherCapacity, Allocator>&);
 
         Vector& operator=(const Vector&);
@@ skipping 577 matching lines @@
         }
         if (this->hasOutOfLineBuffer())
             Allocator::markNoTracing(visitor, buffer());
     }
 
 } // namespace WTF
 
 using WTF::Vector;
 
 #endif // WTF_Vector_h