Fix rehash functionality

CHANGELOG.md

@@ -13,7 +13,7 @@ Bug fixes:
 * Fix `Thread.handle_interrupt` to defer non-pure interrupts until the end of the `handle_interrupt` block (#2219).
 * Clear and restore errinfo on entry and normal return from methods in C extensions (#2227).
 * Fix extra whitespace in squiggly heredoc with escaped newline (#2238, @wildmaples and @norswap).
-
+* Fix `Hash#rehash` to remove duplicate keys after modifications (#2266, @MattAlp)
 Compatibility:
 
 * Implemented `$LOAD_PATH.resolve_feature_path`.

src/main/java/org/truffleruby/core/hash/HashNodes.java

@@ -845,6 +845,7 @@ protected int sizePackedArray(RubyHash hash) {
     public abstract static class InternalRehashNode extends RubyContextNode {
 
         @Child private HashingNodes.ToHash hashNode = HashingNodes.ToHash.create();
+        @Child private CompareHashKeysNode compareHashKeysNode = new CompareHashKeysNode();
 
         public static InternalRehashNode create() {
             return InternalRehashNodeGen.create();
@@ -866,14 +867,8 @@ protected RubyHash rehashPackedArray(RubyHash hash,
             final Object[] store = (Object[]) hash.store;
             final int size = hash.size;
 
-            for (int n = 0; n < getLanguage().options.HASH_PACKED_ARRAY_MAX; n++) {
-                if (n < size) {
-                    PackedArrayStrategy.setHashed(
-                            store,
-                            n,
-                            hashNode.execute(PackedArrayStrategy.getKey(store, n), compareByIdentity));
-                }
-            }
+            PackedArrayStrategy.promoteToBuckets(getContext(), hash, store, size);
+            rehashBuckets(hash, byIdentityProfile);
 
             assert HashOperations.verifyStore(getContext(), hash);
 
@@ -890,6 +885,7 @@ protected RubyHash rehashBuckets(RubyHash hash,
             Arrays.fill(entries, null);
 
             Entry entry = hash.firstInSequence;
+            Entry previousEntry = null;
 
             while (entry != null) {
                 final int newHash = hashNode.execute(entry.getKey(), compareByIdentity);
@@ -900,14 +896,37 @@ protected RubyHash rehashBuckets(RubyHash hash,
 
                 if (bucketEntry == null) {
                     entries[index] = entry;
+                    previousEntry = entry;
                 } else {
+                    boolean encounteredDuplicateKey = false;
                     while (bucketEntry.getNextInLookup() != null) {
+                        if (compareHashKeysNode.equalKeys(
+                                compareByIdentity,
+                                entry.getKey(),
+                                entry.getHashed(),
+                                bucketEntry.getKey(),
+                                bucketEntry.getHashed())) {
+                            encounteredDuplicateKey = true;
+                            break;
+                        }
                         bucketEntry = bucketEntry.getNextInLookup();
                     }
+                    if (encounteredDuplicateKey || compareHashKeysNode.equalKeys(
+                            compareByIdentity,
+                            entry.getKey(),
+                            entry.getHashed(),
+                            bucketEntry.getKey(),
+                            bucketEntry.getHashed())) { // If the bucket contains a single entry, we never set the flag
+                        if (previousEntry != null) {
+                            previousEntry.setNextInSequence(entry.getNextInSequence());
+                        }
+                        hash.size--;
+                    } else {
+                        bucketEntry.setNextInLookup(entry);
+                        previousEntry = entry;
+                    }
 
-                    bucketEntry.setNextInLookup(entry);
                 }
-
                 entry = entry.getNextInSequence();
             }