stdlib: Address StrictMemorySafety warnings in Set related code.

Author: tshortli

stdlib/public/core/NativeSet.swift

@@ -25,22 +25,22 @@ internal struct _NativeSet<Element: Hashable> {
   @inlinable
   @inline(__always)
   internal init() {
-    self._storage = unsafe __RawSetStorage.empty
+    unsafe self._storage = __RawSetStorage.empty
   }
 
   /// Constructs a native set adopting the given storage.
   @inlinable
   @inline(__always)
   internal init(_ storage: __owned __RawSetStorage) {
-    self._storage = unsafe storage
+    unsafe self._storage = storage
   }
 
   @inlinable
   internal init(capacity: Int) {
     if capacity == 0 {
-      self._storage = unsafe __RawSetStorage.empty
+      unsafe self._storage = __RawSetStorage.empty
     } else {
-      self._storage = unsafe _SetStorage<Element>.allocate(capacity: capacity)
+      unsafe self._storage = _SetStorage<Element>.allocate(capacity: capacity)
     }
   }
 
@@ -53,10 +53,10 @@ internal struct _NativeSet<Element: Hashable> {
   @inlinable
   internal init(_ cocoa: __owned __CocoaSet, capacity: Int) {
     if capacity == 0 {
-      self._storage = unsafe __RawSetStorage.empty
+      unsafe self._storage = __RawSetStorage.empty
     } else {
       _internalInvariant(cocoa.count <= capacity)
-      self._storage = unsafe _SetStorage<Element>.convert(cocoa, capacity: capacity)
+      unsafe self._storage = _SetStorage<Element>.convert(cocoa, capacity: capacity)
       for element in cocoa {
         let nativeElement = _forceBridgeFromObjectiveC(element, Element.self)
         insertNew(nativeElement, isUnique: true)
@@ -151,10 +151,11 @@ extension _NativeSet { // Low-level lookup operations
     return unsafe element._rawHashValue(seed: _storage._seed)
   }
 
+  @safe
   @inlinable
   @inline(__always)
   internal func find(_ element: Element) -> (bucket: Bucket, found: Bool) {
-    return find(element, hashValue: self.hashValue(for: element))
+    return unsafe find(element, hashValue: self.hashValue(for: element))
   }
 
   /// Search for a given element, assuming it has the specified hash value.
@@ -167,10 +168,10 @@ extension _NativeSet { // Low-level lookup operations
     _ element: Element,
     hashValue: Int
   ) -> (bucket: Bucket, found: Bool) {
-    let hashTable = self.hashTable
+    let hashTable = unsafe self.hashTable
     var bucket = unsafe hashTable.idealBucket(forHashValue: hashValue)
     while unsafe hashTable._isOccupied(bucket) {
-      if uncheckedElement(at: bucket) == element {
+      if unsafe uncheckedElement(at: bucket) == element {
         return unsafe (bucket, true)
       }
       unsafe bucket = unsafe hashTable.bucket(wrappedAfter: bucket)
@@ -197,7 +198,7 @@ extension _NativeSet { // ensureUnique
       unsafe _storage._hashTable.clear()
       unsafe _storage._count = 0
     }
-    _storage = result._storage
+    unsafe _storage = result._storage
   }
 
   @inlinable
@@ -209,10 +210,10 @@ extension _NativeSet { // ensureUnique
         move: false))
     if count > 0 {
       for unsafe bucket in unsafe hashTable {
-        result._unsafeInsertNew(self.uncheckedElement(at: bucket))
+        unsafe result._unsafeInsertNew(self.uncheckedElement(at: bucket))
       }
     }
-    _storage = result._storage
+    unsafe _storage = result._storage
   }
 
   @inlinable
@@ -221,16 +222,16 @@ extension _NativeSet { // ensureUnique
     unsafe _internalInvariant(newStorage._scale == _storage._scale)
     unsafe _internalInvariant(newStorage._age == _storage._age)
     unsafe _internalInvariant(newStorage._seed == _storage._seed)
-    let result = _NativeSet(newStorage)
+    let result = unsafe _NativeSet(newStorage)
     if count > 0 {
       unsafe result.hashTable.copyContents(of: hashTable)
       unsafe result._storage._count = self.count
       for unsafe bucket in unsafe hashTable {
-        let element = uncheckedElement(at: bucket)
-        result.uncheckedInitialize(at: bucket, to: element)
+        let element = unsafe uncheckedElement(at: bucket)
+        unsafe result.uncheckedInitialize(at: bucket, to: element)
       }
     }
-    _storage = result._storage
+    unsafe _storage = result._storage
   }
 
   /// Ensure storage of self is uniquely held and can hold at least `capacity`
@@ -347,8 +348,8 @@ extension _NativeSet: _SetBuffer {
   @inlinable
   @inline(__always)
   internal func element(at index: Index) -> Element {
-    let bucket = validatedBucket(for: index)
-    return uncheckedElement(at: bucket)
+    let bucket = unsafe validatedBucket(for: index)
+    return unsafe uncheckedElement(at: bucket)
   }
 }
 
@@ -382,7 +383,7 @@ extension _NativeSet { // Insertions
       // elements -- these imply that the Element type violates Hashable
       // requirements. This is generally more costly than a direct insertion,
       // because we'll need to compare elements in case of hash collisions.
-      let (bucket, found) = find(element, hashValue: hashValue)
+      let (bucket, found) = unsafe find(element, hashValue: hashValue)
       guard !found else {
         #if !$Embedded
         ELEMENT_TYPE_OF_SET_VIOLATES_HASHABLE_REQUIREMENTS(Element.self)
@@ -391,10 +392,10 @@ extension _NativeSet { // Insertions
         #endif
       }
       unsafe hashTable.insert(bucket)
-      uncheckedInitialize(at: bucket, to: element)
+      unsafe uncheckedInitialize(at: bucket, to: element)
     } else {
       let bucket = unsafe hashTable.insertNew(hashValue: hashValue)
-      uncheckedInitialize(at: bucket, to: element)
+      unsafe uncheckedInitialize(at: bucket, to: element)
     }
     unsafe _storage._count &+= 1
   }
@@ -411,7 +412,7 @@ extension _NativeSet { // Insertions
   @inlinable
   internal func _unsafeInsertNew(_ element: __owned Element, at bucket: Bucket) {
     unsafe hashTable.insert(bucket)
-    uncheckedInitialize(at: bucket, to: element)
+    unsafe uncheckedInitialize(at: bucket, to: element)
     unsafe _storage._count += 1
   }
 
@@ -435,7 +436,7 @@ extension _NativeSet { // Insertions
       }
       unsafe bucket = unsafe b
     }
-    _unsafeInsertNew(element, at: bucket)
+    unsafe _unsafeInsertNew(element, at: bucket)
   }
 
   @inlinable
@@ -460,10 +461,10 @@ extension _NativeSet { // Insertions
     }
     if found {
       let old = unsafe (_elements + bucket.offset).move()
-      uncheckedInitialize(at: bucket, to: element)
+      unsafe uncheckedInitialize(at: bucket, to: element)
       return old
     }
-    _unsafeInsertNew(element, at: bucket)
+    unsafe _unsafeInsertNew(element, at: bucket)
     return nil
   }
 
@@ -475,10 +476,10 @@ extension _NativeSet { // Insertions
   ) {
     let (bucket, found) = find(element)
     if found {
-      uncheckedAssign(at: bucket, to: element)
+      unsafe uncheckedAssign(at: bucket, to: element)
     } else {
       _precondition(count < capacity)
-      _unsafeInsertNew(element, at: bucket)
+      unsafe _unsafeInsertNew(element, at: bucket)
     }
   }
 }
@@ -487,7 +488,7 @@ extension _NativeSet {
   @inlinable
   @inline(__always)
   func isEqual(to other: _NativeSet) -> Bool {
-    if self._storage === other._storage { return true }
+    if unsafe (self._storage === other._storage) { return true }
     if self.count != other.count { return false }
 
     for member in self {
@@ -503,7 +504,7 @@ extension _NativeSet {
 
     defer { _fixLifetime(self) }
     for unsafe bucket in unsafe self.hashTable {
-      let key = self.uncheckedElement(at: bucket)
+      let key = unsafe self.uncheckedElement(at: bucket)
       let bridgedKey = _bridgeAnythingToObjectiveC(key)
       guard other.contains(bridgedKey) else { return false }
     }
@@ -516,7 +517,7 @@ extension _NativeSet: _HashTableDelegate {
   @inlinable
   @inline(__always)
   internal func hashValue(at bucket: Bucket) -> Int {
-    return hashValue(for: uncheckedElement(at: bucket))
+    return hashValue(for: unsafe uncheckedElement(at: bucket))
   }
 
   @inlinable
@@ -546,15 +547,15 @@ extension _NativeSet { // Deletion
     let rehashed = ensureUnique(isUnique: isUnique, capacity: capacity)
     _internalInvariant(!rehashed)
     let old = unsafe (_elements + bucket.offset).move()
-    _delete(at: bucket)
+    unsafe _delete(at: bucket)
     return old
   }
 
   @usableFromInline
   internal mutating func removeAll(isUnique: Bool) {
     guard isUnique else {
       let scale = unsafe self._storage._scale
-      _storage = unsafe _SetStorage<Element>.allocate(
+      unsafe _storage = _SetStorage<Element>.allocate(
         scale: scale,
         age: nil,
         seed: nil)
@@ -585,7 +586,7 @@ extension _NativeSet: Sequence {
     @inline(__always)
     init(_ base: __owned _NativeSet) {
       self.base = base
-      self.iterator = unsafe base.hashTable.makeIterator()
+      unsafe self.iterator = base.hashTable.makeIterator()
     }
   }
 
@@ -604,7 +605,7 @@ extension _NativeSet.Iterator: IteratorProtocol {
   @inline(__always)
   internal mutating func next() -> Element? {
     guard let index = unsafe iterator.next() else { return nil }
-    return base.uncheckedElement(at: index)
+    return unsafe base.uncheckedElement(at: index)
   }
 }
 
@@ -736,7 +737,7 @@ extension _NativeSet {
         }
       }
       unsafe _internalInvariant(difference.count > 0)
-      return extractSubset(using: difference, count: remainingCount)
+      return unsafe extractSubset(using: difference, count: remainingCount)
     }
   }
 
@@ -747,12 +748,12 @@ extension _NativeSet {
     try unsafe _UnsafeBitset.withTemporaryBitset(capacity: bucketCount) { bitset in
       var count = 0
       for unsafe bucket in unsafe hashTable {
-        if try isIncluded(uncheckedElement(at: bucket)) {
+        if try isIncluded(unsafe uncheckedElement(at: bucket)) {
           unsafe bitset.uncheckedInsert(bucket.offset)
           count += 1
         }
       }
-      return extractSubset(using: bitset, count: count)
+      return unsafe extractSubset(using: bitset, count: count)
     }
   }
 
@@ -779,13 +780,13 @@ extension _NativeSet {
         }
       } else {
         for unsafe bucket in unsafe hashTable {
-          if other.find(uncheckedElement(at: bucket)).found {
+          if other.find(unsafe uncheckedElement(at: bucket)).found {
             unsafe bitset.uncheckedInsert(bucket.offset)
             count += 1
           }
         }
       }
-      return extractSubset(using: bitset, count: count)
+      return unsafe extractSubset(using: bitset, count: count)
     }
   }
 
@@ -807,7 +808,7 @@ extension _NativeSet {
           count += 1
         }
       }
-      return extractSubset(using: bitset, count: count)
+      return unsafe extractSubset(using: bitset, count: count)
     }
   }
 }

stdlib/public/core/Set.swift

@@ -231,7 +231,7 @@ extension Set: ExpressibleByArrayLiteral {
         // FIXME: Shouldn't this trap?
         continue
       }
-      native._unsafeInsertNew(element, at: bucket)
+      unsafe native._unsafeInsertNew(element, at: bucket)
     }
     self.init(_native: native)
   }
@@ -1309,7 +1309,7 @@ extension Set {
     @inlinable
     @inline(__always)
     internal init(_native index: _HashTable.Index) {
-      self.init(_variant: .native(index))
+      self.init(_variant: unsafe .native(index))
     }
 
 #if _runtime(_ObjC)
@@ -1393,7 +1393,7 @@ extension Set.Index {
           "Attempting to access Set 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
     }