@@ -1315,7 +1315,7 @@ - (JSValue *)initWithValue:(JSValueRef)value inContext:(JSContext *)context
     });
 
     // Step 3: clean up - remove entries where we found prospective valueWith<Foo>:inContext: conversions, but no matching to<Foo> methods.
-    typedef HashSet<String> RemoveSet;
+    typedef UncheckedKeyHashSet<String> RemoveSet;
     RemoveSet removeSet;
     for (StructHandlers::iterator iter = structHandlers->begin(); iter != structHandlers->end(); ++iter) {
         StructTagHandler& handler = iter->value;
 
@@ -56,7 +56,7 @@ inline void forEachProtocolImplementingProtocol(Class cls, Protocol *target, voi
     ASSERT(target);
 
     Vector<Protocol*> worklist;
-    HashSet<void*> visited;
+    UncheckedKeyHashSet<void*> visited;
 
     // Initially fill the worklist with the Class's protocols.
     {
 
@@ -63,7 +63,7 @@ bool canonicalizePrePostIncrements(Procedure& proc)
     UncheckedKeyHashMap<MemoryValue*, Vector<Value*>> preIndexCandidates;
 
     UncheckedKeyHashMap<Value*, unsigned> memoryToIndex;
-    UncheckedKeyHashMap<BasicBlock*, HashSet<MemoryValue*>> blockToPrePostIndexCandidates;
+    UncheckedKeyHashMap<BasicBlock*, UncheckedKeyHashSet<MemoryValue*>> blockToPrePostIndexCandidates;
 
     auto tryFindCandidates = [&](Value* value, unsigned index) ALWAYS_INLINE_LAMBDA {
         switch (value->opcode()) {
@@ -96,7 +96,7 @@ bool canonicalizePrePostIncrements(Procedure& proc)
                     if (uses != addressUses.end() && uses->value.size() > 0)
                         continue;
                     preIndexCandidates.add(memory, Vector<Value*>()).iterator->value.append(address);
-                    blockToPrePostIndexCandidates.add(memory->owner, HashSet<MemoryValue*>()).iterator->value.add(memory);
+                    blockToPrePostIndexCandidates.add(memory->owner, UncheckedKeyHashSet<MemoryValue*>()).iterator->value.add(memory);
                 }
             } else
                 baseToMemories.add(base, Vector<MemoryValue*>()).iterator->value.append(memory);
@@ -129,7 +129,7 @@ bool canonicalizePrePostIncrements(Procedure& proc)
                 break;
             for (MemoryValue* memory : memories->value) {
                 postIndexCandidates.add(memory, Vector<Value*>()).iterator->value.append(address);
-                blockToPrePostIndexCandidates.add(memory->owner, HashSet<MemoryValue*>()).iterator->value.add(memory);
+                blockToPrePostIndexCandidates.add(memory->owner, UncheckedKeyHashSet<MemoryValue*>()).iterator->value.add(memory);
             }
             break;
         }
 
@@ -1287,7 +1287,7 @@ class LowerInt64 {
     bool m_changed;
     UncheckedKeyHashMap<Value*, Value*> m_rewrittenTupleResults;
     UncheckedKeyHashMap<Value*, std::pair<Value*, Value*>> m_mapping;
-    HashSet<Value*> m_syntheticValues;
+    UncheckedKeyHashSet<Value*> m_syntheticValues;
     UncheckedKeyHashMap<Variable*, std::pair<Variable*, Variable*>> m_variableMapping;
 };
 
 
@@ -252,8 +252,8 @@ bool OptimizeAssociativeExpressionTrees::run()
     m_proc.resetValueOwners();
 
     Vector<unsigned> useCounts(m_proc.values().size(), 0); // Mapping from Value::m_index to use counts.
-    HashSet<Value*> expressionTreeRoots;
-    HashSet<BasicBlock*> rootOwners;
+    UncheckedKeyHashSet<Value*> expressionTreeRoots;
+    UncheckedKeyHashSet<BasicBlock*> rootOwners;
 
     for (BasicBlock* block : m_proc) {
         for (Value* value : *block) {
 
@@ -316,7 +316,7 @@ class Procedure {
     std::unique_ptr<NaturalLoops> m_naturalLoops;
     std::unique_ptr<BackwardsCFG> m_backwardsCFG;
     std::unique_ptr<BackwardsDominators> m_backwardsDominators;
-    HashSet<ValueKey> m_fastConstants;
+    UncheckedKeyHashSet<ValueKey> m_fastConstants;
     const char* m_lastPhaseName;
     std::unique_ptr<OpaqueByproducts> m_byproducts;
     std::unique_ptr<Air::Code> m_code;
 
@@ -67,8 +67,8 @@ class Validater {
 
     void run()
     {
-        HashSet<BasicBlock*> blocks;
-        HashSet<Value*> valueInProc;
+        UncheckedKeyHashSet<BasicBlock*> blocks;
+        UncheckedKeyHashSet<Value*> valueInProc;
         UncheckedKeyHashMap<Value*, unsigned> valueInBlock;
         UncheckedKeyHashMap<Value*, BasicBlock*> valueOwner;
         UncheckedKeyHashMap<Value*, unsigned> valueIndex;
@@ -114,15 +114,15 @@ class Validater {
             }
         }
 
-        UncheckedKeyHashMap<BasicBlock*, HashSet<BasicBlock*>> allPredecessors;
+        UncheckedKeyHashMap<BasicBlock*, UncheckedKeyHashSet<BasicBlock*>> allPredecessors;
         for (BasicBlock* block : blocks) {
             VALIDATE(block->size() >= 1, ("At ", *block));
             for (unsigned i = 0; i < block->size() - 1; ++i)
                 VALIDATE(!block->at(i)->effects().terminal, ("At ", *block->at(i)));
             VALIDATE(block->last()->effects().terminal, ("At ", *block->last()));
 
             for (BasicBlock* successor : block->successorBlocks()) {
-                allPredecessors.add(successor, HashSet<BasicBlock*>()).iterator->value.add(block);
+                allPredecessors.add(successor, UncheckedKeyHashSet<BasicBlock*>()).iterator->value.add(block);
                 VALIDATE(
                     blocks.contains(successor), ("At ", *block, "->", pointerDump(successor)));
             }
@@ -131,7 +131,7 @@ class Validater {
         // Note that this totally allows dead code.
         for (auto& entry : allPredecessors) {
             BasicBlock* successor = entry.key;
-            HashSet<BasicBlock*>& predecessors = entry.value;
+            UncheckedKeyHashSet<BasicBlock*>& predecessors = entry.value;
             VALIDATE(predecessors == successor->predecessors(), ("At ", *successor));
         }
 
@@ -870,7 +870,7 @@ class Validater {
 
         for (BasicBlock* block : m_procedure) {
             // We expect the predecessor list to be de-duplicated.
-            HashSet<BasicBlock*> predecessors;
+            UncheckedKeyHashSet<BasicBlock*> predecessors;
             for (BasicBlock* predecessor : block->predecessors())
                 predecessors.add(predecessor);
             VALIDATE(block->numPredecessors() == predecessors.size(), ("At ", *block));
@@ -969,15 +969,15 @@ class Validater {
     {
         bool changed = true;
         BitVector blocksToVisit;
-        IndexMap<BasicBlock*, HashSet<Value*>> undominatedPhisAtTail(m_procedure.size());
+        IndexMap<BasicBlock*, UncheckedKeyHashSet<Value*>> undominatedPhisAtTail(m_procedure.size());
         for (BasicBlock* block : m_procedure)
             blocksToVisit.set(block->index());
         while (changed) {
             changed = false;
             for (BasicBlock* block : m_procedure.blocksInPostOrder()) {
                 if (!blocksToVisit.quickClear(block->index()))
                     continue;
-                HashSet<Value*> undominatedPhis = undominatedPhisAtTail[block];
+                UncheckedKeyHashSet<Value*> undominatedPhis = undominatedPhisAtTail[block];
                 for (unsigned index = block->size()-1; index--;) {
                     Value* value = block->at(index);
                     switch (value->opcode()) {
 
@@ -507,8 +507,8 @@ void GenerateAndAllocateRegisters::prepareForGeneration()
         UnifiedTmpLiveness liveness(m_code);
         for (BasicBlock* block : m_code) {
             auto assertLivenessAreEqual = [&] (auto a, auto b) {
-                HashSet<Tmp> livenessA;
-                HashSet<Tmp> livenessB;
+                UncheckedKeyHashSet<Tmp> livenessA;
+                UncheckedKeyHashSet<Tmp> livenessB;
                 for (Tmp tmp : a) {
                     if (tmp.isReg() && isDisallowedRegister(tmp.reg()))
                         continue;
 
@@ -456,7 +456,7 @@ class AbstractColoringAllocator {
     {
         out.print("graph InterferenceGraph { \n");
 
-        HashSet<Tmp> tmpsWithInterferences;
+        UncheckedKeyHashSet<Tmp> tmpsWithInterferences;
 
         m_interferenceEdges.forEach([&tmpsWithInterferences] (std::pair<IndexType, IndexType> edge) {
             tmpsWithInterferences.add(TmpMapper::tmpFromAbsoluteIndex(edge.first));
@@ -1330,7 +1330,7 @@ class IRC : public AbstractColoringAllocator<IndexType, InterferenceSet, bank> {
 
     // Work lists.
     // Low-degree, Move related.
-    HashSet<IndexType> m_freezeWorklist;
+    UncheckedKeyHashSet<IndexType> m_freezeWorklist;
     // Set of "move" enabled for possible coalescing.
     OrderedMoveSet m_worklistMoves;
     // Set of "move" not yet ready for coalescing.
 
@@ -148,7 +148,7 @@ bool ShuffleCustom::isValidForm(Inst& inst)
     // - Closed loops. These loops consist of nodes that have one successor and one predecessor, so
     //   there is no way to "get into" the loop from outside of it. These can be executed using swaps
     //   or by saving one of the Args to a scratch register and executing it as a shift.
-    HashSet<Arg> dsts;
+    UncheckedKeyHashSet<Arg> dsts;
 
     for (unsigned i = 0; i < inst.args.size(); ++i) {
         Arg arg = inst.args[i];
Original file line number	Diff line number	Diff line change
`@@ -56,7 +56,7 @@ inline void forEachProtocolImplementingProtocol(Class cls, Protocol *target, voi`
`56`	`56`	`ASSERT(target);`
`57`	`57`
`58`	`58`	`Vector<Protocol*> worklist;`
`59`		`- HashSet<void*> visited;`
	`59`	`+ UncheckedKeyHashSet<void*> visited;`
`60`	`60`
`61`	`61`	`// Initially fill the worklist with the Class's protocols.`
`62`	`62`	`{`