stdlib: Address StrictMemorySafety warnings in Array related code.

Author: tshortli

stdlib/public/core/ArrayBuffer.swift

@@ -659,7 +659,7 @@ extension _ArrayBuffer {
       return try unsafe body(
         UnsafeBufferPointer(start: firstElementAddress, count: count))
     }
-    return try ContiguousArray(self).withUnsafeBufferPointer(body)
+    return try unsafe ContiguousArray(self).withUnsafeBufferPointer(body)
   }
 
   /// Call `body(p)`, where `p` is an `UnsafeBufferPointer` over the

stdlib/public/core/ArraySlice.swift

@@ -277,12 +277,12 @@ extension ArraySlice: _ArrayProtocol {
   @inlinable
   public var _baseAddressIfContiguous: UnsafeMutablePointer<Element>? {
     @inline(__always) // FIXME(TODO: JIRA): Hack around test failure
-    get { return _buffer.firstElementAddressIfContiguous }
+    get { return unsafe _buffer.firstElementAddressIfContiguous }
   }
 
   @inlinable
   internal var _baseAddress: UnsafeMutablePointer<Element> {
-    return _buffer.firstElementAddress
+    return unsafe _buffer.firstElementAddress
   }
 }
 
@@ -703,7 +703,7 @@ extension ArraySlice: RangeReplaceableCollection {
     if count > 0 {
       _buffer = ArraySlice._allocateBufferUninitialized(minimumCapacity: count)
       _buffer.count = count
-      var p = _buffer.firstElementAddress
+      var p = unsafe _buffer.firstElementAddress
       for _ in 0..<count {
         unsafe p.initialize(to: repeatedValue)
         unsafe p += 1
@@ -752,7 +752,7 @@ extension ArraySlice: RangeReplaceableCollection {
     _ count: Int
   ) -> (ArraySlice, UnsafeMutablePointer<Element>) {
     let result = ArraySlice(_uninitializedCount: count)
-    return (result, result._buffer.firstElementAddress)
+    return (result, unsafe result._buffer.firstElementAddress)
   }
 
   //===--- basic mutations ------------------------------------------------===//
@@ -1171,7 +1171,7 @@ extension ArraySlice {
   func withUnsafeBufferPointer<R>(
     _ body: (UnsafeBufferPointer<Element>) throws -> R
   ) rethrows -> R {
-    return try _buffer.withUnsafeBufferPointer(body)
+    return try unsafe _buffer.withUnsafeBufferPointer(body)
   }
 
   /// Calls a closure with a pointer to the array's contiguous storage.
@@ -1207,7 +1207,7 @@ extension ArraySlice {
   public func withUnsafeBufferPointer<R, E>(
     _ body: (UnsafeBufferPointer<Element>) throws(E) -> R
   ) throws(E) -> R {
-    return try _buffer.withUnsafeBufferPointer(body)
+    return try unsafe _buffer.withUnsafeBufferPointer(body)
   }
 
   @available(SwiftStdlib 6.2, *)
@@ -1283,7 +1283,7 @@ extension ArraySlice {
     _makeMutableAndUnique()
 
     // Create an UnsafeBufferPointer that we can pass to body
-    let pointer = _buffer.firstElementAddress
+    let pointer = unsafe _buffer.firstElementAddress
     var inoutBufferPointer = unsafe UnsafeMutableBufferPointer(
       start: pointer, count: count)
 
@@ -1573,7 +1573,7 @@ extension ArraySlice {
   @_alwaysEmitIntoClient
   public func _copyToNewArray() -> [Element] {
     unsafe Array(unsafeUninitializedCapacity: self.count) { buffer, count in
-      var (it, c) = self._buffer._copyContents(initializing: buffer)
+      var (it, c) = unsafe self._buffer._copyContents(initializing: buffer)
       _precondition(it.next() == nil)
       count = c
     }

stdlib/public/core/CocoaArray.swift

@@ -76,7 +76,7 @@ internal struct _CocoaArrayWrapper: RandomAccessCollection {
     let cocoaStorageBaseAddress = unsafe self.contiguousStorage(self.indices)
 
     if let cocoaStorageBaseAddress = unsafe cocoaStorageBaseAddress {
-      return _SliceBuffer(
+      return unsafe _SliceBuffer(
         owner: self.buffer,
         subscriptBaseAddress: cocoaStorageBaseAddress,
         indices: bounds,

stdlib/public/core/ContiguousArray.swift

@@ -995,7 +995,7 @@ extension ContiguousArray: RangeReplaceableCollection {
   public mutating func _withUnsafeMutableBufferPointerIfSupported<R>(
     _ body: (inout UnsafeMutableBufferPointer<Element>) throws -> R
   ) rethrows -> R? {
-    return try withUnsafeMutableBufferPointer {
+    return try unsafe withUnsafeMutableBufferPointer {
       (bufferPointer) -> R in
       return try unsafe body(&bufferPointer)
     }
@@ -1005,7 +1005,7 @@ extension ContiguousArray: RangeReplaceableCollection {
   public mutating func withContiguousMutableStorageIfAvailable<R>(
     _ body: (inout UnsafeMutableBufferPointer<Element>) throws -> R
   ) rethrows -> R? {
-    return try withUnsafeMutableBufferPointer {
+    return try unsafe withUnsafeMutableBufferPointer {
       (bufferPointer) -> R in
       return try unsafe body(&bufferPointer)
     }
@@ -1015,7 +1015,7 @@ extension ContiguousArray: RangeReplaceableCollection {
   public func withContiguousStorageIfAvailable<R>(
     _ body: (UnsafeBufferPointer<Element>) throws -> R
   ) rethrows -> R? {
-    return try withUnsafeBufferPointer {
+    return try unsafe withUnsafeBufferPointer {
       (bufferPointer) -> R in
       return try unsafe body(bufferPointer)
     }
@@ -1059,7 +1059,7 @@ extension ContiguousArray: CustomStringConvertible, CustomDebugStringConvertible
 extension ContiguousArray {
   @usableFromInline @_transparent
   internal func _cPointerArgs() -> (AnyObject?, UnsafeRawPointer?) {
-    let p = _baseAddressIfContiguous
+    let p = unsafe _baseAddressIfContiguous
     if unsafe _fastPath(p != nil || isEmpty) {
       return (_owner, UnsafeRawPointer(p))
     }
@@ -1173,7 +1173,7 @@ extension ContiguousArray {
   mutating func __abi_withUnsafeMutableBufferPointer<R>(
     _ body: (inout UnsafeMutableBufferPointer<Element>) throws -> R
   ) rethrows -> R {
-    return try withUnsafeMutableBufferPointer(body)
+    return try unsafe withUnsafeMutableBufferPointer(body)
   }
 
   /// Calls the given closure with a pointer to the array's mutable contiguous
@@ -1272,7 +1272,7 @@ extension ContiguousArray {
     _precondition(self.count <= buffer.count, 
       "Insufficient space allocated to copy array contents")
 
-    if let s = _baseAddressIfContiguous {
+    if let s = unsafe _baseAddressIfContiguous {
       unsafe p.initialize(from: s, count: self.count)
       // Need a _fixLifetime bracketing the _baseAddressIfContiguous getter
       // and all uses of the pointer it returns:
@@ -1446,7 +1446,7 @@ extension ContiguousArray {
   public mutating func withUnsafeMutableBytes<R>(
     _ body: (UnsafeMutableRawBufferPointer) throws -> R
   ) rethrows -> R {
-    return try self.withUnsafeMutableBufferPointer {
+    return try unsafe self.withUnsafeMutableBufferPointer {
       return try unsafe body(UnsafeMutableRawBufferPointer($0))
     }
   }
@@ -1482,7 +1482,7 @@ extension ContiguousArray {
   public func withUnsafeBytes<R>(
     _ body: (UnsafeRawBufferPointer) throws -> R
   ) rethrows -> R {
-    return try self.withUnsafeBufferPointer {
+    return try unsafe self.withUnsafeBufferPointer {
       try unsafe body(UnsafeRawBufferPointer($0))
     }
   }

stdlib/public/core/Diffing.swift

@@ -355,7 +355,7 @@ private func _myers<C,D>(
   ) rethrows -> R {
     if let result = try values.withContiguousStorageIfAvailable(body) { return result }
     let array = ContiguousArray(values)
-    return try array.withUnsafeBufferPointer(body)
+    return try unsafe array.withUnsafeBufferPointer(body)
   }
 
   return unsafe _withContiguousStorage(for: old) { a in

stdlib/public/core/InlineArray.swift

@@ -147,7 +147,7 @@ extension InlineArray where Element: ~Copyable {
   public init<E: Error>(_ body: (Index) throws(E) -> Element) throws(E) {
 #if $BuiltinEmplaceTypedThrows
     self = try Builtin.emplace { (rawPtr) throws(E) -> () in
-      let buffer = Self._initializationBuffer(start: rawPtr)
+      let buffer = unsafe Self._initializationBuffer(start: rawPtr)
 
       for i in 0 ..< count {
         do throws(E) {
@@ -204,7 +204,7 @@ extension InlineArray where Element: ~Copyable {
     var o: Element? = first
 
     self = try Builtin.emplace { (rawPtr) throws(E) -> () in
-      let buffer = Self._initializationBuffer(start: rawPtr)
+      let buffer = unsafe Self._initializationBuffer(start: rawPtr)
 
       guard Self.count > 0 else {
         return
@@ -247,7 +247,7 @@ extension InlineArray where Element: Copyable {
   @_alwaysEmitIntoClient
   public init(repeating value: Element) {
     self = Builtin.emplace {
-      let buffer = Self._initializationBuffer(start: $0)
+      let buffer = unsafe Self._initializationBuffer(start: $0)
 
       unsafe buffer.initialize(repeating: value)
     }

stdlib/public/core/SliceBuffer.swift

@@ -52,7 +52,7 @@ internal struct _SliceBuffer<Element>
     endIndexAndFlags: UInt
   ) {
     self.owner = owner
-    self.subscriptBaseAddress = unsafe subscriptBaseAddress
+    unsafe self.subscriptBaseAddress = subscriptBaseAddress
     self.startIndex = startIndex
     self.endIndexAndFlags = endIndexAndFlags
   }
@@ -63,7 +63,7 @@ internal struct _SliceBuffer<Element>
     indices: Range<Int>, hasNativeBuffer: Bool
   ) {
     self.owner = owner
-    self.subscriptBaseAddress = unsafe subscriptBaseAddress
+    unsafe self.subscriptBaseAddress = subscriptBaseAddress
     self.startIndex = indices.lowerBound
     let bufferFlag = UInt(hasNativeBuffer ? 1 : 0)
     self.endIndexAndFlags = (UInt(indices.upperBound) << 1) | bufferFlag
@@ -78,7 +78,7 @@ internal struct _SliceBuffer<Element>
     #else
     self.owner = _emptyArrayStorage
     #endif
-    self.subscriptBaseAddress = unsafe empty.firstElementAddress
+    unsafe self.subscriptBaseAddress = empty.firstElementAddress
     self.startIndex = empty.startIndex
     self.endIndexAndFlags = 1
     _invariantCheck()
@@ -176,7 +176,7 @@ internal struct _SliceBuffer<Element>
   /// identity and count.
   @inlinable
   internal var identity: UnsafeRawPointer {
-    return UnsafeRawPointer(firstElementAddress)
+    return unsafe UnsafeRawPointer(firstElementAddress)
   }
 
   @inlinable
@@ -186,7 +186,7 @@ internal struct _SliceBuffer<Element>
 
   @inlinable
   internal var firstElementAddressIfContiguous: UnsafeMutablePointer<Element>? {
-    return firstElementAddress
+    return unsafe firstElementAddress
   }
 
   //===--- Non-essential bits ---------------------------------------------===//
@@ -399,7 +399,7 @@ internal struct _SliceBuffer<Element>
       _internalInvariant(bounds.lowerBound >= startIndex)
       _internalInvariant(bounds.upperBound >= bounds.lowerBound)
       _internalInvariant(bounds.upperBound <= endIndex)
-      return _SliceBuffer(
+      return unsafe _SliceBuffer(
         owner: owner,
         subscriptBaseAddress: subscriptBaseAddress,
         indices: bounds,
@@ -482,7 +482,7 @@ internal struct _SliceBuffer<Element>
     _internalInvariant(_isClassOrObjCExistential(T.self))
     let baseAddress = unsafe UnsafeMutableRawPointer(self.subscriptBaseAddress)
       .assumingMemoryBound(to: T.self)
-    return _SliceBuffer<T>(
+    return unsafe _SliceBuffer<T>(
       owner: self.owner,
       subscriptBaseAddress: baseAddress,
       startIndex: self.startIndex,