Unreviewed, relanding with TestWTF fix

https://bugs.webkit.org/show_bug.cgi?id=309200
rdar://171758273

Zero is empty key, so you need to use
WTF::UnsignedWithZeroKeyHashTraits explicitly.

Test: Tools/TestWebKitAPI/Tests/WTF/SmallSet.cpp

* Source/JavaScriptCore/b3/air/AirAllocateRegistersByGraphColoring.cpp:
* Source/JavaScriptCore/b3/air/AirCode.h:
* Source/WTF/wtf/SmallSet.h:
* Tools/TestWebKitAPI/Tests/WTF/SmallSet.cpp:
(TestWebKitAPI::testSmallSetOfUnsigned):
(TestWebKitAPI::testVectorsOfSmallSetsOfUnsigned):

Canonical link: https://commits.webkit.org/308679@main

Author: Constellation

Source/JavaScriptCore/b3/air/AirAllocateRegistersByGraphColoring.cpp

@@ -486,7 +486,7 @@ class AbstractColoringAllocator {
     Vector<Vector<IndexType, 0, UnsafeVectorOverflow, 4>, 0, UnsafeVectorOverflow> m_adjacencyList;
     Vector<IndexType, 0, UnsafeVectorOverflow> m_degrees;
 
-    using IndexTypeSet = SmallSet<IndexType, IntHash<IndexType>>;
+    using IndexTypeSet = SmallSet<IndexType, IntHash<IndexType>, WTF::UnsignedWithZeroKeyHashTraits<IndexType>>;
 
     UncheckedKeyHashMap<IndexType, IndexTypeSet, DefaultHash<IndexType>, WTF::UnsignedWithZeroKeyHashTraits<IndexType>> m_biases;
 
@@ -499,7 +499,7 @@ class AbstractColoringAllocator {
     Vector<MoveOperands, 0, UnsafeVectorOverflow> m_coalescingCandidates;
 
     // List of every move instruction associated with a Tmp.
-    Vector<SmallSet<unsigned, IntHash<unsigned>>> m_moveList;
+    Vector<SmallSet<unsigned, IntHash<unsigned>, WTF::UnsignedWithZeroKeyHashTraits<unsigned>>> m_moveList;
 
     // Colors.
     Vector<Reg, 0, UnsafeVectorOverflow> m_coloredTmp;

Source/JavaScriptCore/b3/air/AirCode.h

@@ -396,7 +396,7 @@ class Code {
     Vector<std::unique_ptr<BasicBlock>> m_blocks;
     SparseCollection<Special> m_specials;
     std::unique_ptr<CFG> m_cfg;
-    SmallSet<Tmp, DefaultHash<Tmp>, 2> m_fastTmps;
+    SmallSet<Tmp, DefaultHash<Tmp>, HashTraits<Tmp>, 2> m_fastTmps;
     CCallSpecial* m_cCallSpecial { nullptr };
     unsigned m_numGPTmps { 0 };
     unsigned m_numFPTmps { 0 };

Source/WTF/wtf/SmallSet.h

@@ -29,6 +29,7 @@
 #include <wtf/Assertions.h>
 #include <wtf/FastMalloc.h>
 #include <wtf/HashFunctions.h>
+#include <wtf/HashTraits.h>
 #include <wtf/MallocSpan.h>
 #include <wtf/Noncopyable.h>
 #include <wtf/StdLibExtras.h>
@@ -40,10 +41,9 @@ DECLARE_ALLOCATOR_WITH_HEAP_IDENTIFIER(SmallSet);
 // Functionally, this class is very similar to Variant<Vector<T, SmallArraySize>, HashSet<T>>
 // It is optimized primarily for space, but is also quite fast
 // Its main limitation is that it has no way to remove elements once they have been added to it
-// Also, instead of being fully parameterized by a HashTrait parameter, it always uses -1 (all ones) as its empty value
-// Relatedly, it can only store objects of up to 64 bit size (but that particular limitation should be fairly easy to lift if needed)
+// It uses HashTraits to determine its empty value.
 // Use it whenever you need to store an unbounded but probably small number of unsigned integers or pointers.
-template<typename T, typename Hash = PtrHashBase<T, false /* isSmartPtr */>, unsigned SmallArraySize = 8>
+template<typename T, typename Hash = PtrHashBase<T, false /* isSmartPtr */>, typename Traits = HashTraits<T>, unsigned SmallArraySize = 8>
 class SmallSet {
     WTF_DEPRECATED_MAKE_FAST_ALLOCATED(SmallSet);
     WTF_MAKE_NONCOPYABLE(SmallSet);
@@ -101,7 +101,7 @@ class SmallSet {
         {
             ++m_index;
             ASSERT(m_index <= m_buffer.size());
-            while (m_index < m_buffer.size() && m_buffer[m_index] == emptyValue())
+            while (m_index < m_buffer.size() && isEmptyBucket(m_buffer[m_index]))
                 ++m_index;
             return *this;
         }
@@ -111,7 +111,7 @@ class SmallSet {
         bool operator==(const iterator& other) const { ASSERT(m_buffer.data() == other.m_buffer.data()); return m_index == other.m_index; }
 
     private:
-        template<typename U, typename H, unsigned S> friend class WTF::SmallSet;
+        template<typename U, typename H, typename TR, unsigned S> friend class WTF::SmallSet;
         unsigned m_index;
         std::span<T> m_buffer;
     };
@@ -203,11 +203,9 @@ class SmallSet {
     }
 
 private:
-    constexpr static T emptyValue()
+    static bool isEmptyBucket(const T& value)
     {
-        if constexpr (std::is_pointer<T>::value)
-            return static_cast<T>(std::bit_cast<void*>(std::numeric_limits<uintptr_t>::max()));
-        return std::numeric_limits<T>::max();
+        return isHashTraitsEmptyValue<Traits>(value);
     }
 
     bool equal(const T left, const T right) const
@@ -216,14 +214,12 @@ class SmallSet {
             return Hash::equal(left, right);
         if (isValidEntry(left) && isValidEntry(right))
             return Hash::equal(left, right);
-        return left == right; 
+        return left == right;
     }
 
-    bool isValidEntry(const T value) const
+    bool isValidEntry(const T& value) const
     {
-        if constexpr (Hash::safeToCompareToEmptyOrDeleted)
-            return !Hash::equal(value, emptyValue());
-        return value != emptyValue();
+        return !isEmptyBucket(value);
     }
 
     inline bool isSmall() const
@@ -235,34 +231,28 @@ class SmallSet {
     {
         m_size = 0;
         m_capacity = SmallArraySize;
-        memsetSpan(std::span { m_inline.smallStorage }, -1);
+        initializeBuckets(std::span { m_inline.smallStorage });
         ASSERT(isSmall());
     }
 
-    inline void grow(unsigned size)
+    static void initializeBuckets(std::span<T> span)
     {
-        // We memset the new buffer with -1, so for consistency emptyValue() must return something which is all 1s.
-#if !defined(NDEBUG)
-        if constexpr (std::is_pointer<T>::value)
-            ASSERT(std::bit_cast<intptr_t>(emptyValue()) == -1ll);
-        else if constexpr (sizeof(T) == 8)
-            ASSERT(std::bit_cast<int64_t>(emptyValue()) == -1ll);
-        else if constexpr (sizeof(T) == 4)
-            ASSERT(std::bit_cast<int32_t>(emptyValue()) == -1);
-        else if constexpr (sizeof(T) == 2)
-            ASSERT(std::bit_cast<int16_t>(emptyValue()) == -1);
-        else if constexpr (sizeof(T) == 1)
-            ASSERT(std::bit_cast<int8_t>(emptyValue()) == -1);
-        else
-            RELEASE_ASSERT_NOT_REACHED();
-#endif
+        if constexpr (Traits::emptyValueIsZero)
+            memsetSpan(span, 0);
+        else {
+            for (auto& entry : span)
+                entry = Traits::emptyValue();
+        }
+    }
 
+    inline void grow(unsigned size)
+    {
         size_t allocationSize = sizeof(T) * size;
         auto oldBuffer = buffer();
 
         unsigned oldCapacity = m_capacity;
         auto newBuffer = MallocSpan<T, SmallSetMalloc>::malloc(allocationSize);
-        memsetSpan(newBuffer.mutableSpan(), -1);
+        initializeBuckets(newBuffer.mutableSpan());
         m_capacity = size;
 
         for (unsigned i = 0; i < oldCapacity; i++) {

Tools/TestWebKitAPI/Tests/WTF/SmallSet.cpp

@@ -38,7 +38,7 @@ namespace TestWebKitAPI {
 template<typename T>
 void testSmallSetOfUnsigned(unsigned n)
 {
-    SmallSet<T, IntHash<T>> set;
+    SmallSet<T, IntHash<T>, WTF::UnsignedWithZeroKeyHashTraits<T>> set;
 
     EXPECT_TRUE(set.isEmpty());
     EXPECT_EQ(set.size(), 0u);
@@ -107,7 +107,7 @@ void testSmallSetOfPointers()
 template<typename T>
 void testVectorsOfSmallSetsOfUnsigned()
 {
-    Vector<SmallSet<T, IntHash<T>>, 2> vector;
+    Vector<SmallSet<T, IntHash<T>, WTF::UnsignedWithZeroKeyHashTraits<T>>, 2> vector;
     vector.append({ });
     vector.append({ });