stdlib: Address StrictMemorySafety warnings in Dictionary related code.

Author: tshortli

stdlib/public/core/Bitset.swift

@@ -150,6 +150,7 @@ extension _UnsafeBitset: @unsafe Sequence {
     return unsafe Iterator(self)
   }
 
+  @unsafe
   @usableFromInline
   @frozen
   internal struct Iterator: IteratorProtocol {

stdlib/public/core/Dictionary.swift

@@ -838,7 +838,7 @@ extension Dictionary: ExpressibleByDictionaryLiteral {
     for (key, value) in elements {
       let (bucket, found) = native.find(key)
       _precondition(!found, "Dictionary literal contains duplicate keys")
-      native._insert(at: bucket, key: key, value: value)
+      unsafe native._insert(at: bucket, key: key, value: value)
     }
     self.init(_native: native)
   }
@@ -904,11 +904,11 @@ extension Dictionary {
     }
     @inline(__always)
     _modify {
-      let (bucket, found) = _variant.mutatingFind(key)
+      let (bucket, found) = unsafe _variant.mutatingFind(key)
       let native = _variant.asNative
       if !found {
         let value = defaultValue()
-        native._insert(at: bucket, key: key, value: value)
+        unsafe native._insert(at: bucket, key: key, value: value)
       }
       let address = unsafe native._values + bucket.offset
       defer { _fixLifetime(self) }
@@ -1376,7 +1376,7 @@ extension Dictionary {
       if
         lhs._variant.isNative,
         rhs._variant.isNative,
-        lhs._variant.asNative._storage === rhs._variant.asNative._storage
+        unsafe (lhs._variant.asNative._storage === rhs._variant.asNative._storage)
       {
         return true
       }
@@ -1388,7 +1388,7 @@ extension Dictionary {
         return true
       }
 #else
-      if lhs._variant.asNative._storage === rhs._variant.asNative._storage {
+      if unsafe (lhs._variant.asNative._storage === rhs._variant.asNative._storage) {
         return true
       }
 #endif
@@ -1458,7 +1458,7 @@ extension Dictionary {
       }
       _modify {
         let native = _variant.ensureUniqueNative()
-        let bucket = native.validatedBucket(for: position)
+        let bucket = unsafe native.validatedBucket(for: position)
         let address = unsafe native._values + bucket.offset
         defer { _fixLifetime(self) }
         yield unsafe &address.pointee
@@ -1491,9 +1491,9 @@ extension Dictionary {
 #endif
       let isUnique = _variant.isUniquelyReferenced()
       let native = _variant.asNative
-      let a = native.validatedBucket(for: i)
-      let b = native.validatedBucket(for: j)
-      _variant.asNative.swapValuesAt(a, b, isUnique: isUnique)
+      let a = unsafe native.validatedBucket(for: i)
+      let b = unsafe native.validatedBucket(for: j)
+      unsafe _variant.asNative.swapValuesAt(a, b, isUnique: isUnique)
     }
   }
 }
@@ -1793,7 +1793,7 @@ extension Dictionary {
     @inlinable
     @inline(__always)
     internal init(_native index: _HashTable.Index) {
-      self.init(_variant: .native(index))
+      unsafe self.init(_variant: .native(index))
     }
 
 #if _runtime(_ObjC)
@@ -1876,7 +1876,7 @@ extension Dictionary.Index {
           "Attempting to access Dictionary elements using an invalid index")
       }
       let dummy = unsafe _HashTable.Index(bucket: _HashTable.Bucket(offset: 0), age: 0)
-      _variant = .native(dummy)
+      _variant = unsafe .native(dummy)
       defer { _variant = .cocoa(cocoa) }
       yield &cocoa
     }

stdlib/public/core/DictionaryBridging.swift

@@ -71,9 +71,9 @@ final internal class _SwiftDictionaryNSEnumerator<Key: Hashable, Value>
     _internalInvariant(_isBridgedVerbatimToObjectiveC(Key.self))
     _internalInvariant(_orphanedFoundationSubclassesReparented)
     self.base = base
-    self.bridgedKeys = nil
-    self.nextBucket = unsafe base.hashTable.startBucket
-    self.endBucket = unsafe base.hashTable.endBucket
+    unsafe self.bridgedKeys = nil
+    unsafe self.nextBucket = base.hashTable.startBucket
+    unsafe self.endBucket = base.hashTable.endBucket
     super.init()
   }
 
@@ -82,28 +82,28 @@ final internal class _SwiftDictionaryNSEnumerator<Key: Hashable, Value>
     _internalInvariant(!_isBridgedVerbatimToObjectiveC(Key.self))
     _internalInvariant(_orphanedFoundationSubclassesReparented)
     self.base = deferred.native
-    self.bridgedKeys = unsafe deferred.bridgeKeys()
-    self.nextBucket = unsafe base.hashTable.startBucket
-    self.endBucket = unsafe base.hashTable.endBucket
+    unsafe self.bridgedKeys = deferred.bridgeKeys()
+    unsafe self.nextBucket = base.hashTable.startBucket
+    unsafe self.endBucket = base.hashTable.endBucket
     super.init()
   }
 
   private func bridgedKey(at bucket: _HashTable.Bucket) -> AnyObject {
     unsafe _internalInvariant(base.hashTable.isOccupied(bucket))
-    if let bridgedKeys = self.bridgedKeys {
+    if let bridgedKeys = unsafe self.bridgedKeys {
       return unsafe bridgedKeys[bucket]
     }
-    return _bridgeAnythingToObjectiveC(base.uncheckedKey(at: bucket))
+    return unsafe _bridgeAnythingToObjectiveC(base.uncheckedKey(at: bucket))
   }
 
   @objc
   internal func nextObject() -> AnyObject? {
     if unsafe nextBucket == endBucket {
       return nil
     }
-    let bucket = nextBucket
-    nextBucket = unsafe base.hashTable.occupiedBucket(after: nextBucket)
-    return self.bridgedKey(at: bucket)
+    let bucket = unsafe nextBucket
+    unsafe nextBucket = base.hashTable.occupiedBucket(after: nextBucket)
+    return unsafe self.bridgedKey(at: bucket)
   }
 
   @objc(countByEnumeratingWithState:objects:count:)
@@ -128,7 +128,7 @@ final internal class _SwiftDictionaryNSEnumerator<Key: Hashable, Value>
     // enumeration, terminate it, and continue via NSEnumerator.
     let unmanagedObjects = unsafe _UnmanagedAnyObjectArray(objects)
     unsafe unmanagedObjects[0] = self.bridgedKey(at: nextBucket)
-    nextBucket = unsafe base.hashTable.occupiedBucket(after: nextBucket)
+    unsafe nextBucket = base.hashTable.occupiedBucket(after: nextBucket)
     unsafe state.pointee = theState
     return 1
   }
@@ -230,7 +230,8 @@ final internal class _SwiftDeferredNSDictionary<Key: Hashable, Value>
       owner: native._storage,
       hashTable: native.hashTable)
     for unsafe bucket in unsafe native.hashTable {
-      let object = _bridgeAnythingToObjectiveC(native.uncheckedKey(at: bucket))
+      let object = unsafe _bridgeAnythingToObjectiveC(
+        native.uncheckedKey(at: bucket))
       unsafe bridged.initialize(at: bucket, to: object)
     }
 
@@ -249,7 +250,7 @@ final internal class _SwiftDeferredNSDictionary<Key: Hashable, Value>
       owner: native._storage,
       hashTable: native.hashTable)
     for unsafe bucket in unsafe native.hashTable {
-      let value = native.uncheckedValue(at: bucket)
+      let value = unsafe native.uncheckedValue(at: bucket)
       let cocoaValue = _bridgeAnythingToObjectiveC(value)
       unsafe bridged.initialize(at: bucket, to: cocoaValue)
     }
@@ -274,7 +275,7 @@ final internal class _SwiftDeferredNSDictionary<Key: Hashable, Value>
     if let bridgedKeys = unsafe bridgedKeys {
       return unsafe bridgedKeys[bucket]
     }
-    return _bridgeAnythingToObjectiveC(native.uncheckedKey(at: bucket))
+    return unsafe _bridgeAnythingToObjectiveC(native.uncheckedKey(at: bucket))
   }
 
   @inline(__always)
@@ -285,7 +286,7 @@ final internal class _SwiftDeferredNSDictionary<Key: Hashable, Value>
     if let bridgedValues = unsafe bridgedValues {
       return unsafe bridgedValues[bucket]
     }
-    return _bridgeAnythingToObjectiveC(native.uncheckedValue(at: bucket))
+    return unsafe _bridgeAnythingToObjectiveC(native.uncheckedValue(at: bucket))
   }
 
   @objc(objectForKey:)
@@ -383,7 +384,7 @@ final internal class _SwiftDeferredNSDictionary<Key: Hashable, Value>
     count: Int
   ) -> Int {
     defer { _fixLifetime(self) }
-    let hashTable = native.hashTable
+    let hashTable = unsafe native.hashTable
 
     var theState = unsafe state.pointee
     if unsafe theState.state == 0 {
@@ -809,7 +810,7 @@ extension Dictionary {
     }
 
     if let nativeStorage = unsafe s as? _DictionaryStorage<Key, Value> {
-      return Dictionary(_native: _NativeDictionary(nativeStorage))
+      return Dictionary(_native: unsafe _NativeDictionary(nativeStorage))
     }
 
     if unsafe s === __RawDictionaryStorage.empty {

stdlib/public/core/DictionaryBuilder.swift

@@ -84,7 +84,7 @@ extension Dictionary {
       _ values: UnsafeMutableBufferPointer<Value>
     ) -> Int
   ) {
-    self.init(_native: _NativeDictionary(
+    self.init(_native: unsafe _NativeDictionary(
         _unsafeUninitializedCapacity: capacity,
         allowingDuplicates: allowingDuplicates,
         initializingWith: initializer))
@@ -151,7 +151,7 @@ extension _NativeDictionary {
           unsafe _internalInvariant(b != bucket)
           _precondition(allowingDuplicates, "Duplicate keys found")
           // Discard duplicate entry.
-          uncheckedDestroy(at: bucket)
+          unsafe uncheckedDestroy(at: bucket)
           unsafe _storage._count -= 1
           unsafe bucket.offset -= 1
           continue
@@ -166,7 +166,7 @@ extension _NativeDictionary {
       if unsafe target > bucket {
         // The target is outside the unprocessed region.  We can simply move the
         // entry, leaving behind an uninitialized bucket.
-        moveEntry(from: bucket, to: target)
+        unsafe moveEntry(from: bucket, to: target)
         // Restore invariants by lowering the region boundary.
         unsafe bucket.offset -= 1
       } else if unsafe target == bucket {
@@ -176,7 +176,7 @@ extension _NativeDictionary {
         // The target bucket is also in the unprocessed region. Swap the current
         // item into place, then try again with the swapped-in value, so that we
         // don't lose it.
-        swapEntry(target, with: bucket)
+        unsafe swapEntry(target, with: bucket)
       }
     }
     // When there are no more unprocessed entries, we're left with a valid

stdlib/public/core/DictionaryStorage.swift

@@ -232,12 +232,14 @@ extension __RawDictionaryStorage {
     return unsafe keys[bucket.offset]
   }
 
+  @safe
   @_alwaysEmitIntoClient
   @inline(never)
   internal final func find<Key: Hashable>(_ key: Key) -> (bucket: _HashTable.Bucket, found: Bool) {
     return unsafe find(key, hashValue: key._rawHashValue(seed: _seed))
   }
 
+  @safe
   @_alwaysEmitIntoClient
   @inline(never)
   internal final func find<Key: Hashable>(_ key: Key, hashValue: Int) -> (bucket: _HashTable.Bucket, found: Bool) {
@@ -298,7 +300,7 @@ final internal class _DictionaryStorage<Key: Hashable, Value>
   }
 
   internal var asNative: _NativeDictionary<Key, Value> {
-    return _NativeDictionary(self)
+    return unsafe _NativeDictionary(self)
   }
 
 #if _runtime(_ObjC)

stdlib/public/core/DictionaryVariant.swift

@@ -41,14 +41,14 @@ extension Dictionary {
     @inlinable
     @inline(__always)
     init(native: __owned _NativeDictionary<Key, Value>) {
-      self.object = unsafe _BridgeStorage(native: native._storage)
+      unsafe self.object = _BridgeStorage(native: native._storage)
     }
 
     @inlinable
     @inline(__always)
     init(dummy: Void) {
 #if _pointerBitWidth(_64) && !$Embedded
-      self.object = unsafe _BridgeStorage(taggedPayload: 0)
+      unsafe self.object = _BridgeStorage(taggedPayload: 0)
 #elseif _pointerBitWidth(_32) || $Embedded
       self.init(native: _NativeDictionary())
 #else
@@ -60,7 +60,7 @@ extension Dictionary {
     @inlinable
     @inline(__always)
     init(cocoa: __owned __CocoaDictionary) {
-      self.object = unsafe _BridgeStorage(objC: cocoa.object)
+      unsafe self.object = _BridgeStorage(objC: cocoa.object)
     }
 #endif
   }
@@ -83,7 +83,7 @@ extension Dictionary._Variant {
   @usableFromInline @_transparent
   internal var isNative: Bool {
     if guaranteedNative { return true }
-    return object.isUnflaggedNative
+    return unsafe object.isUnflaggedNative
   }
 #endif
 
@@ -98,7 +98,7 @@ extension Dictionary._Variant {
     _modify {
       var native = unsafe _NativeDictionary<Key, Value>(object.unflaggedNativeInstance)
       self = .init(dummy: ())
-      defer { object = unsafe .init(native: native._storage) }
+      defer { unsafe object = .init(native: native._storage) }
       yield &native
     }
   }
@@ -390,8 +390,8 @@ extension Dictionary._Variant {
     // FIXME(performance): fuse data migration and element deletion into one
     // operation.
     let native = ensureUniqueNative()
-    let bucket = native.validatedBucket(for: index)
-    return asNative.uncheckedRemove(at: bucket, isUnique: true)
+    let bucket = unsafe native.validatedBucket(for: index)
+    return unsafe asNative.uncheckedRemove(at: bucket, isUnique: true)
   }
 
   @inlinable
@@ -404,15 +404,15 @@ extension Dictionary._Variant {
       var native = _NativeDictionary<Key, Value>(cocoa)
       let (bucket, found) = native.find(key)
       _precondition(found, "Bridging did not preserve equality")
-      let old = native.uncheckedRemove(at: bucket, isUnique: true).value
+      let old = unsafe native.uncheckedRemove(at: bucket, isUnique: true).value
       self = .init(native: native)
       return old
     }
 #endif
     let (bucket, found) = asNative.find(key)
     guard found else { return nil }
     let isUnique = isUniquelyReferenced()
-    return asNative.uncheckedRemove(at: bucket, isUnique: isUnique).value
+    return unsafe asNative.uncheckedRemove(at: bucket, isUnique: isUnique).value
   }
 
   @inlinable

stdlib/public/core/HashTable.swift

@@ -186,6 +186,7 @@ extension _HashTable.Bucket: Comparable {
 }
 
 extension _HashTable {
+  @unsafe
   @usableFromInline
   @frozen
   internal struct Index {
@@ -231,6 +232,7 @@ extension _HashTable.Index: Comparable {
 }
 
 extension _HashTable: @unsafe Sequence {
+  @unsafe
   @usableFromInline
   @frozen
   internal struct Iterator: @unsafe IteratorProtocol {
@@ -280,6 +282,7 @@ extension _HashTable: @unsafe Sequence {
 extension _HashTable.Iterator: Sendable {}
 
 extension _HashTable {
+  @safe
   @inlinable
   @inline(__always)
   internal func isValid(_ bucket: Bucket) -> Bool {
@@ -289,7 +292,7 @@ extension _HashTable {
   @inlinable
   @inline(__always)
   internal func _isOccupied(_ bucket: Bucket) -> Bool {
-    unsafe _internalInvariant(isValid(bucket))
+    _internalInvariant(isValid(bucket))
     return unsafe words[bucket.word].uncheckedContains(bucket.bit)
   }
 
@@ -322,7 +325,7 @@ extension _HashTable {
 
   @inlinable
   internal func occupiedBucket(after bucket: Bucket) -> Bucket {
-    unsafe _internalInvariant(isValid(bucket))
+    _internalInvariant(isValid(bucket))
     let word = unsafe bucket.word
     if let bit = unsafe words[word].intersecting(elementsAbove: bucket.bit).minimum {
       return unsafe Bucket(word: word, bit: bit)
@@ -364,7 +367,7 @@ extension _HashTable {
 extension _HashTable {
   @inlinable
   internal func previousHole(before bucket: Bucket) -> Bucket {
-    unsafe _internalInvariant(isValid(bucket))
+    _internalInvariant(isValid(bucket))
     // Note that if we have only a single partial word, its out-of-bounds bits
     // are guaranteed to be all set, so the formula below gives correct results.
     var word = unsafe bucket.word
@@ -392,7 +395,7 @@ extension _HashTable {
 
   @inlinable
   internal func nextHole(atOrAfter bucket: Bucket) -> Bucket {
-    unsafe _internalInvariant(isValid(bucket))
+    _internalInvariant(isValid(bucket))
     // Note that if we have only a single partial word, its out-of-bounds bits
     // are guaranteed to be all set, so the formula below gives correct results.
     var word = unsafe bucket.word