Merge pull request swiftlang#19574 from lorentey/buckets

[stdlib] Rename _HashTable.Index in preparation of upcoming index validation enhancements

Author: lorentey

stdlib/public/core/Dictionary.swift

@@ -792,31 +792,36 @@ extension Dictionary {
       // FIXME: This code should be moved to _variant, with Dictionary.subscript
       // yielding `&_variant[key]`.
 
-      let (index, found) = _variant.mutatingFind(key)
+      let (bucket, found) = _variant.mutatingFind(key)
 
       // FIXME: Mark this entry as being modified in hash table metadata
       // so that lldb can recognize it's not valid.
 
       // Move the old value (if any) out of storage, wrapping it into an
       // optional before yielding it.
       let native = _variant.asNative
-      var value: Value? = found ? (native._values + index.bucket).move() : nil
+      var value: Value?
+      if found {
+        value = (native._values + bucket.offset).move()
+      } else {
+        value = nil
+      }
       yield &value
 
       // Value is now potentially different. Check which one of the four
       // possible cases apply.
       switch (value, found) {
       case (let value?, true): // Mutation
         // Initialize storage to new value.
-        (native._values + index.bucket).initialize(to: value)
+        (native._values + bucket.offset).initialize(to: value)
       case (let value?, false): // Insertion
         // Insert the new entry at the correct place.
         // We've already ensured we have enough capacity.
-        native._insert(at: index, key: key, value: value)
+        native._insert(at: bucket, key: key, value: value)
       case (nil, true): // Removal
         // We've already removed the value; deinitialize and remove the key too.
-        (native._values + index.bucket).deinitialize(count: 1)
-        native._delete(at: index)
+        (native._values + bucket.offset).deinitialize(count: 1)
+        native._delete(at: bucket)
       case (nil, false): // Noop
         // Easy!
         break
@@ -848,9 +853,9 @@ extension Dictionary: ExpressibleByDictionaryLiteral {
   public init(dictionaryLiteral elements: (Key, Value)...) {
     let native = _NativeDictionary<Key, Value>(capacity: elements.count)
     for (key, value) in elements {
-      let (index, found) = native.find(key)
+      let (bucket, found) = native.find(key)
       _precondition(!found, "Dictionary literal contains duplicate keys")
-      native._insert(at: index, key: key, value: value)
+      native._insert(at: bucket, key: key, value: value)
     }
     self.init(_native: native)
   }
@@ -916,13 +921,13 @@ extension Dictionary {
       return _variant.lookup(key) ?? defaultValue()
     }
     _modify {
-      let (index, found) = _variant.mutatingFind(key)
+      let (bucket, found) = _variant.mutatingFind(key)
       let native = _variant.asNative
       if !found {
         let value = defaultValue()
-        native._insert(at: index, key: key, value: value)
+        native._insert(at: bucket, key: key, value: value)
       }
-      let address = native._values + index.bucket
+      let address = native._values + bucket.offset
       yield &address.pointee
       _fixLifetime(self)
     }
@@ -1451,7 +1456,7 @@ extension Dictionary {
       }
       _modify {
         let index = _variant.ensureUniqueNative(preserving: position)
-        let address = _variant.asNative._values + index.bucket
+        let address = _variant.asNative._values + index.offset
         yield &address.pointee
         _fixLifetime(self)
       }
@@ -1498,8 +1503,8 @@ extension Dictionary: Equatable where Value: Equatable {
       }
 
       for (k, v) in lhs {
-        let (index, found) = rhsNative.find(k)
-        guard found, rhsNative.uncheckedValue(at: index) == v else {
+        let (bucket, found) = rhsNative.find(k)
+        guard found, rhsNative.uncheckedValue(at: bucket) == v else {
           return false
         }
       }
@@ -1515,8 +1520,9 @@ extension Dictionary: Equatable where Value: Equatable {
       }
 
       defer { _fixLifetime(lhsNative) }
-      for index in lhsNative.hashTable {
-        let (key, value) = lhsNative.lookup(index)
+      for bucket in lhsNative.hashTable {
+        let key = lhsNative.uncheckedKey(at: bucket)
+        let value = lhsNative.uncheckedValue(at: bucket)
         guard
           let rhsValue = rhsCocoa.lookup(_bridgeAnythingToObjectiveC(key)),
           value == _forceBridgeFromObjectiveC(rhsValue, Value.self)
@@ -1805,14 +1811,14 @@ extension Dictionary.Index: Hashable {
     switch _variant {
     case .native(let nativeIndex):
       hasher.combine(0 as UInt8)
-      hasher.combine(nativeIndex.bucket)
+      hasher.combine(nativeIndex.offset)
     case .cocoa(let cocoaIndex):
       _cocoaPath()
       hasher.combine(1 as UInt8)
       hasher.combine(cocoaIndex.currentKeyIndex)
     }
   #else
-    hasher.combine(_asNative.bucket)
+    hasher.combine(_asNative.offset)
   #endif
   }
 }

stdlib/public/core/DictionaryBridging.swift

@@ -62,8 +62,8 @@ final internal class _SwiftDictionaryNSEnumerator<Key: Hashable, Value>
 
   @nonobjc internal var base: _NativeDictionary<Key, Value>
   @nonobjc internal var bridgedKeys: _BridgingHashBuffer?
-  @nonobjc internal var nextIndex: _NativeDictionary<Key, Value>.Index
-  @nonobjc internal var endIndex: _NativeDictionary<Key, Value>.Index
+  @nonobjc internal var nextBucket: _NativeDictionary<Key, Value>.Bucket
+  @nonobjc internal var endBucket: _NativeDictionary<Key, Value>.Bucket
 
   @objc
   internal override required init() {
@@ -74,35 +74,35 @@ final internal class _SwiftDictionaryNSEnumerator<Key: Hashable, Value>
     _sanityCheck(_isBridgedVerbatimToObjectiveC(Key.self))
     self.base = base
     self.bridgedKeys = nil
-    self.nextIndex = base.startIndex
-    self.endIndex = base.endIndex
+    self.nextBucket = base.hashTable.startBucket
+    self.endBucket = base.hashTable.endBucket
   }
 
   @nonobjc
   internal init(_ deferred: __owned _SwiftDeferredNSDictionary<Key, Value>) {
     _sanityCheck(!_isBridgedVerbatimToObjectiveC(Key.self))
     self.base = deferred.native
     self.bridgedKeys = deferred.bridgeKeys()
-    self.nextIndex = base.startIndex
-    self.endIndex = base.endIndex
+    self.nextBucket = base.hashTable.startBucket
+    self.endBucket = base.hashTable.endBucket
   }
 
-  private func bridgedKey(at index: _HashTable.Index) -> AnyObject {
-    _sanityCheck(base.hashTable.isOccupied(index))
+  private func bridgedKey(at bucket: _HashTable.Bucket) -> AnyObject {
+    _sanityCheck(base.hashTable.isOccupied(bucket))
     if let bridgedKeys = self.bridgedKeys {
-      return bridgedKeys[index]
+      return bridgedKeys[bucket]
     }
-    return _bridgeAnythingToObjectiveC(base.uncheckedKey(at: index))
+    return _bridgeAnythingToObjectiveC(base.uncheckedKey(at: bucket))
   }
 
   @objc
   internal func nextObject() -> AnyObject? {
-    if nextIndex == endIndex {
+    if nextBucket == endBucket {
       return nil
     }
-    let index = nextIndex
-    nextIndex = base.index(after: nextIndex)
-    return self.bridgedKey(at: index)
+    let bucket = nextBucket
+    nextBucket = base.hashTable.occupiedBucket(after: nextBucket)
+    return self.bridgedKey(at: bucket)
   }
 
   @objc(countByEnumeratingWithState:objects:count:)
@@ -118,16 +118,16 @@ final internal class _SwiftDictionaryNSEnumerator<Key: Hashable, Value>
       theState.mutationsPtr = _fastEnumerationStorageMutationsPtr
     }
 
-    if nextIndex == endIndex {
+    if nextBucket == endBucket {
       state.pointee = theState
       return 0
     }
 
     // Return only a single element so that code can start iterating via fast
     // enumeration, terminate it, and continue via NSEnumerator.
     let unmanagedObjects = _UnmanagedAnyObjectArray(objects)
-    unmanagedObjects[0] = self.bridgedKey(at: nextIndex)
-    nextIndex = base.index(after: nextIndex)
+    unmanagedObjects[0] = self.bridgedKey(at: nextBucket)
+    nextBucket = base.hashTable.occupiedBucket(after: nextBucket)
     state.pointee = theState
     return 1
   }
@@ -141,6 +141,9 @@ final internal class _SwiftDictionaryNSEnumerator<Key: Hashable, Value>
 final internal class _SwiftDeferredNSDictionary<Key: Hashable, Value>
   : __SwiftNativeNSDictionary, _NSDictionaryCore {
 
+  @usableFromInline
+  internal typealias Bucket = _HashTable.Bucket
+
   // This stored property must be stored at offset zero.  We perform atomic
   // operations on it.
   //
@@ -225,9 +228,9 @@ final internal class _SwiftDeferredNSDictionary<Key: Hashable, Value>
     let bridged = _BridgingHashBuffer.allocate(
       owner: native._storage,
       hashTable: native.hashTable)
-    for index in native.hashTable {
-      let object = _bridgeAnythingToObjectiveC(native.uncheckedKey(at: index))
-      bridged.initialize(at: index, to: object)
+    for bucket in native.hashTable {
+      let object = _bridgeAnythingToObjectiveC(native.uncheckedKey(at: bucket))
+      bridged.initialize(at: bucket, to: object)
     }
 
     // Atomically put the bridged keys in place.
@@ -244,59 +247,54 @@ final internal class _SwiftDeferredNSDictionary<Key: Hashable, Value>
     let bridged = _BridgingHashBuffer.allocate(
       owner: native._storage,
       hashTable: native.hashTable)
-    for index in native.hashTable {
-      let object = _bridgeAnythingToObjectiveC(native.uncheckedValue(at: index))
-      bridged.initialize(at: index, to: object)
+    for bucket in native.hashTable {
+      let value = native.uncheckedValue(at: bucket)
+      let cocoaValue = _bridgeAnythingToObjectiveC(value)
+      bridged.initialize(at: bucket, to: cocoaValue)
     }
 
     // Atomically put the bridged values in place.
     _initializeBridgedValues(bridged)
     return _bridgedValues!
   }
 
-  @usableFromInline
-  internal typealias Index = _HashTable.Index
-
   @objc(copyWithZone:)
   internal func copy(with zone: _SwiftNSZone?) -> AnyObject {
     // Instances of this class should be visible outside of standard library as
     // having `NSDictionary` type, which is immutable.
     return self
   }
 
-  @objc(objectForKey:)
-  internal func object(forKey aKey: AnyObject) -> AnyObject? {
-    guard let nativeKey = _conditionallyBridgeFromObjectiveC(aKey, Key.self)
-    else { return nil }
-
-    let (index, found) = native.find(nativeKey)
-    guard found else { return nil }
-    if let bridgedValues = bridgeValues() {
-      return bridgedValues[index]
-    }
-    return _bridgeAnythingToObjectiveC(native.uncheckedValue(at: index))
-  }
-
   @inline(__always)
   private func _key(
-    at index: Index,
+    at bucket: Bucket,
     bridgedKeys: _BridgingHashBuffer?
   ) -> AnyObject {
     if let bridgedKeys = bridgedKeys {
-      return bridgedKeys[index]
+      return bridgedKeys[bucket]
     }
-    return _bridgeAnythingToObjectiveC(native.uncheckedKey(at: index))
+    return _bridgeAnythingToObjectiveC(native.uncheckedKey(at: bucket))
   }
 
   @inline(__always)
   private func _value(
-    at index: Index,
+    at bucket: Bucket,
     bridgedValues: _BridgingHashBuffer?
   ) -> AnyObject {
     if let bridgedValues = bridgedValues {
-      return bridgedValues[index]
+      return bridgedValues[bucket]
     }
-    return _bridgeAnythingToObjectiveC(native.uncheckedValue(at: index))
+    return _bridgeAnythingToObjectiveC(native.uncheckedValue(at: bucket))
+  }
+
+  @objc(objectForKey:)
+  internal func object(forKey aKey: AnyObject) -> AnyObject? {
+    guard let nativeKey = _conditionallyBridgeFromObjectiveC(aKey, Key.self)
+    else { return nil }
+
+    let (bucket, found) = native.find(nativeKey)
+    guard found else { return nil }
+    return _value(at: bucket, bridgedValues: bridgeValues())
   }
 
   @objc
@@ -324,21 +322,21 @@ final internal class _SwiftDeferredNSDictionary<Key: Hashable, Value>
 
     switch (_UnmanagedAnyObjectArray(keys), _UnmanagedAnyObjectArray(objects)) {
     case (let unmanagedKeys?, let unmanagedObjects?):
-      for index in native.hashTable {
-        unmanagedKeys[i] = _key(at: index, bridgedKeys: bridgedKeys)
-        unmanagedObjects[i] = _value(at: index, bridgedValues: bridgedValues)
+      for bucket in native.hashTable {
+        unmanagedKeys[i] = _key(at: bucket, bridgedKeys: bridgedKeys)
+        unmanagedObjects[i] = _value(at: bucket, bridgedValues: bridgedValues)
         i += 1
         guard i < count else { break }
       }
     case (let unmanagedKeys?, nil):
-      for index in native.hashTable {
-        unmanagedKeys[i] = _key(at: index, bridgedKeys: bridgedKeys)
+      for bucket in native.hashTable {
+        unmanagedKeys[i] = _key(at: bucket, bridgedKeys: bridgedKeys)
         i += 1
         guard i < count else { break }
       }
     case (nil, let unmanagedObjects?):
-      for index in native.hashTable {
-        unmanagedObjects[i] = _value(at: index, bridgedValues: bridgedValues)
+      for bucket in native.hashTable {
+        unmanagedObjects[i] = _value(at: bucket, bridgedValues: bridgedValues)
         i += 1
         guard i < count else { break }
       }
@@ -362,9 +360,9 @@ final internal class _SwiftDeferredNSDictionary<Key: Hashable, Value>
     defer { _fixLifetime(self) }
 
     var stop: UInt8 = 0
-    for index in native.hashTable {
-      let key = _key(at: index, bridgedKeys: bridgedKeys)
-      let value = _value(at: index, bridgedValues: bridgedValues)
+    for bucket in native.hashTable {
+      let key = _key(at: bucket, bridgedKeys: bridgedKeys)
+      let value = _value(at: bucket, bridgedValues: bridgedValues)
       block(
         Unmanaged.passUnretained(key),
         Unmanaged.passUnretained(value),
@@ -384,12 +382,15 @@ final internal class _SwiftDeferredNSDictionary<Key: Hashable, Value>
     objects: UnsafeMutablePointer<AnyObject>?,
     count: Int
   ) -> Int {
+    defer { _fixLifetime(self) }
+    let hashTable = native.hashTable
+
     var theState = state.pointee
     if theState.state == 0 {
       theState.state = 1 // Arbitrary non-zero value.
       theState.itemsPtr = AutoreleasingUnsafeMutablePointer(objects)
       theState.mutationsPtr = _fastEnumerationStorageMutationsPtr
-      theState.extra.0 = CUnsignedLong(native.startIndex.bucket)
+      theState.extra.0 = CUnsignedLong(hashTable.startBucket.offset)
     }
 
     // Test 'objects' rather than 'count' because (a) this is very rare anyway,
@@ -400,21 +401,21 @@ final internal class _SwiftDeferredNSDictionary<Key: Hashable, Value>
     }
 
     let unmanagedObjects = _UnmanagedAnyObjectArray(objects!)
-    var index = _HashTable.Index(bucket: Int(theState.extra.0))
-    let endIndex = native.endIndex
-    _precondition(index == endIndex || native.hashTable.isOccupied(index))
+    var bucket = _HashTable.Bucket(offset: Int(theState.extra.0))
+    let endBucket = hashTable.endBucket
+    _precondition(bucket == endBucket || hashTable.isOccupied(bucket))
     var stored = 0
 
     // Only need to bridge once, so we can hoist it out of the loop.
     let bridgedKeys = bridgeKeys()
     for i in 0..<count {
-      if index == endIndex { break }
+      if bucket == endBucket { break }
 
-      unmanagedObjects[i] = _key(at: index, bridgedKeys: bridgedKeys)
+      unmanagedObjects[i] = _key(at: bucket, bridgedKeys: bridgedKeys)
       stored += 1
-      index = native.index(after: index)
+      bucket = hashTable.occupiedBucket(after: bucket)
     }
-    theState.extra.0 = CUnsignedLong(index.bucket)
+    theState.extra.0 = CUnsignedLong(bucket.offset)
     state.pointee = theState
     return stored
   }