Ensure proper finalization of garbage-collected types.

Source/wtf/HashTable.h

 /*
  * Copyright (C) 2005, 2006, 2007, 2008, 2011, 2012 Apple Inc. All rights reserved.
  * Copyright (C) 2008 David Levin <levin@chromium.org>
  *
  * 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,
@@ skipping 200 matching lines @@
         bool isNewEntry;
     };
 
     template<typename Value, typename Extractor, typename KeyTraits>
     struct HashTableHelper {
         static bool isEmptyBucket(const Value& value) { return isHashTraitsEmptyValue<KeyTraits>(Extractor::extract(value)); }
         static bool isDeletedBucket(const Value& value) { return KeyTraits::isDeletedValue(Extractor::extract(value)); }
         static bool isEmptyOrDeletedBucket(const Value& value) { return isEmptyBucket(value) || isDeletedBucket(value); }
     };
 
+    // Don't declare a destructor for HeapAllocated hash tables.
+    template<typename Derived, bool isGarbageCollected>
+    class HashTableDestructorBase;
+
+    template<typename Derived>
+    class HashTableDestructorBase<Derived, true> { };
+
+    template<typename Derived>
+    class HashTableDestructorBase<Derived, false> {
+    public:
+        ~HashTableDestructorBase() { static_cast<Derived*>(this)->finalize(); }
+    };
+
     template<typename Key, typename Value, typename Extractor, typename HashFunctions, typename Traits, typename KeyTraits, typename Allocator>
-    class HashTable {
+    class HashTable : public HashTableDestructorBase<HashTable<Key, Value, Extractor, HashFunctions, Traits, KeyTraits, Allocator>, Allocator::isGarbageCollected> {

[Mikhail, 2014/03/11 09:58:13]

imho this inheritance looks a bit over-complicated, maybe we could follow the
"VectorDestructor" approach, and have for instance:
~HashTable()
{
HashTableDestructor<Allocator::isGarbageCollected>::destruct(m_table,
m_tableSize);
}

[zerny-chromium, 2014/03/11 10:04:48]

The issue with doing so is that then HashTable will have a non-trivial
destructor (because it is user-declared) and thus we can not in the clang
compiler plugin use its semantic knowledge of when a class has a trivial
finalizer to determine when a non-finalized garbage collected base class is
correct.

So while I agree that your proposed code is much nicer, it does not solve the
same issue.

[Mikhail, 2014/03/11 12:02:53]

Ah I see, thanks for the explanation.

     public:
         typedef HashTableIterator<Key, Value, Extractor, HashFunctions, Traits, KeyTraits, Allocator> iterator;
         typedef HashTableConstIterator<Key, Value, Extractor, HashFunctions, Traits, KeyTraits, Allocator> const_iterator;
         typedef Traits ValueTraits;
         typedef Key KeyType;
         typedef typename KeyTraits::PeekInType KeyPeekInType;
         typedef typename KeyTraits::PassInType KeyPassInType;
         typedef Value ValueType;
         typedef typename Traits::PeekInType ValuePeekInType;
         typedef IdentityHashTranslator<HashFunctions> IdentityTranslatorType;
@@ skipping 38 matching lines @@
                 for (int i = 1; i <= maxCollisions; i++) {
                     dataLogF("  %d lookups with exactly %d collisions (%.2f%% , %.2f%% with this many or more)\n", collisionGraph[i], i, 100.0 * (collisionGraph[i] - collisionGraph[i+1]) / numAccesses, 100.0 * collisionGraph[i] / numAccesses);
                 }
                 dataLogF("%d rehashes\n", numRehashes);
                 dataLogF("%d reinserts\n", numReinserts);
             }
         };
 #endif
 
         HashTable();
-        ~HashTable()
+        void finalize()
         {
-            if (Allocator::isGarbageCollected)
-                return;
+            ASSERT(!Allocator::isGarbageCollected);
             if (LIKELY(!m_table))
                 return;
             deallocateTable(m_table, m_tableSize);
             m_table = 0;
         }
 
         HashTable(const HashTable&);
         void swap(HashTable&);
         HashTable& operator=(const HashTable&);
 
@@ skipping 873 matching lines @@
     inline bool operator!=(const HashTableIteratorAdapter<T, U>& a, const HashTableConstIteratorAdapter<T, U>& b)
     {
         return a.m_impl != b.m_impl;
     }
 
 } // namespace WTF
 
 #include "wtf/HashIterators.h"
 
 #endif // WTF_HashTable_h