 }
 
 extension _HashTable {
-  @usableFromInline
-  internal typealias Bucket = Index
-
   @_fixed_layout
   @usableFromInline
-  internal struct Index {
+  internal struct Bucket {
     @usableFromInline
     internal var offset: Int
 
-    internal var bucket: Int {
-      @inline(__always) get { return offset }
-      @inline(__always) set { offset = newValue }
-    }
-
     @inlinable
     @inline(__always)
-    internal init(bucket: Int) {
-      _sanityCheck(bucket >= 0)
-      self.bucket = bucket
+    internal init(offset: Int) {
+      _sanityCheck(offset >= 0)
+      self.offset = offset
     }
 
     @inlinable
     @inline(__always)
     internal init(word: Int, bit: Int) {
-      self.bucket = _UnsafeBitset.join(word: word, bit: bit)
+      self.offset = _UnsafeBitset.join(word: word, bit: bit)
     }
 
     @inlinable
     internal var word: Int {
       @inline(__always) get {
-        return _UnsafeBitset.word(for: bucket)
+        return _UnsafeBitset.word(for: offset)
       }
     }
 
     @inlinable
     internal var bit: Int {
       @inline(__always) get {
-        return _UnsafeBitset.bit(for: bucket)
-      }
-    }
-  }
-}
-
-extension _HashTable.Index: Equatable {
+        return _UnsafeBitset.bit(for: offset)
+      }
+    }
+  }
+}
+
+extension _HashTable.Bucket: Equatable {
   @inlinable
   @inline(__always)
   internal
-  static func == (lhs: _HashTable.Index, rhs: _HashTable.Index) -> Bool {
-    return lhs.bucket == rhs.bucket
-  }
-}
-
-extension _HashTable.Index: Comparable {
+  static func == (lhs: _HashTable.Bucket, rhs: _HashTable.Bucket) -> Bool {
+    return lhs.offset == rhs.offset
+  }
+}
+
+extension _HashTable.Bucket: Comparable {
   @inlinable
   @inline(__always)
   internal
-  static func < (lhs: _HashTable.Index, rhs: _HashTable.Index) -> Bool {
-    return lhs.bucket < rhs.bucket
+  static func < (lhs: _HashTable.Bucket, rhs: _HashTable.Bucket) -> Bool {
+    return lhs.offset < rhs.offset
   }
 }
 

  /// The entry must not already exist in the table -- duplicates are ignored.
  @inlinable
  @inline(__always)
  internal func insertNew(hashValue: Int) -> Index {
    let hole = nextHole(atOrAfter: idealIndex(forHashValue: hashValue))
    insert(hole)
    return hole
  }

  internal func clear() {
    if bucketCount < Word.capacity {
      // We have only a single partial word. Set all out of bounds bits, so that
      // `occupiedBucket(after:)` and `nextHole(atOrAfter:)` works correctly
      // without a special case.
      words[0] = Word.allBits.subtracting(elementsBelow: bucketCount)
    } else {
      words.assign(repeating: .empty, count: wordCount)
