Merge pull request #80424 from tshortli/fix-unsafe-warnings

stdlib: Fix StrictMemorySafety warnings

Author: tshortli

stdlib/public/Concurrency/AsyncStreamBuffer.swift

@@ -252,7 +252,7 @@ extension AsyncStream {
     func next() async -> Element? {
       await withTaskCancellationHandler {
         unsafe await withUnsafeContinuation {
-          next($0)
+          unsafe next($0)
         }
       } onCancel: { [cancel] in
         cancel()
@@ -512,7 +512,7 @@ extension AsyncThrowingStream {
     func next() async throws -> Element? {
       try await withTaskCancellationHandler {
         try unsafe await withUnsafeThrowingContinuation {
-          next($0)
+          unsafe next($0)
         }
       } onCancel: { [cancel] in
         cancel()

stdlib/public/Concurrency/Deque/Deque+Collection.swift

@@ -93,7 +93,7 @@ extension _Deque: Sequence {
   }
 
   __consuming func _copyToContiguousArray() -> ContiguousArray<Element> {
-    ContiguousArray(unsafeUninitializedCapacity: _storage.count) { target, count in
+    unsafe ContiguousArray(unsafeUninitializedCapacity: _storage.count) { target, count in
       unsafe _storage.read { source in
         let segments = unsafe source.segments()
         let c = unsafe segments.first.count

stdlib/public/Concurrency/Deque/Deque+Testing.swift

@@ -62,7 +62,7 @@ extension _Deque {
     }
     let storage = unsafe _Deque<Element>._Storage(unsafeDowncast(buffer, to: _DequeBuffer.self))
     if contents.count > 0 {
-      contents.withUnsafeBufferPointer { source in
+      unsafe contents.withUnsafeBufferPointer { source in
         unsafe storage.update { target in
           let segments = unsafe target.mutableSegments()
           let c = unsafe segments.first.count

stdlib/public/Concurrency/Task+startSynchronously.swift.gyb

@@ -76,7 +76,7 @@ extension Task where Failure == ${FAILURE_TYPE} {
     #if $BuiltinCreateAsyncTaskName
     if let name {
       task =
-        name.utf8CString.withUnsafeBufferPointer { nameBytes in
+        unsafe name.utf8CString.withUnsafeBufferPointer { nameBytes in
           Builtin.createTask(
             flags: flags,
             taskName: nameBytes.baseAddress!._rawValue,

stdlib/public/Concurrency/Task.swift

@@ -731,7 +731,7 @@ extension Task where Failure == Never {
     #if $BuiltinCreateAsyncTaskName
     if let name {
       task =
-        name.utf8CString.withUnsafeBufferPointer { nameBytes in
+        unsafe name.utf8CString.withUnsafeBufferPointer { nameBytes in
           Builtin.createTask(
             flags: flags,
             initialSerialExecutor: builtinSerialExecutor,
@@ -900,7 +900,7 @@ self._task = task
   #if $BuiltinCreateAsyncTaskName
   if let name {
     task =
-      name.utf8CString.withUnsafeBufferPointer { nameBytes in
+      unsafe name.utf8CString.withUnsafeBufferPointer { nameBytes in
         Builtin.createTask(
           flags: flags,
           initialSerialExecutor: builtinSerialExecutor,
@@ -1041,7 +1041,7 @@ extension Task where Failure == Never {
     #if $BuiltinCreateAsyncTaskName
     if let name {
       task =
-        name.utf8CString.withUnsafeBufferPointer { nameBytes in
+        unsafe name.utf8CString.withUnsafeBufferPointer { nameBytes in
           Builtin.createTask(
             flags: flags,
             initialSerialExecutor: builtinSerialExecutor,
@@ -1183,7 +1183,7 @@ extension Task where Failure == Error {
     #if $BuiltinCreateAsyncTaskName
     if let name {
       task =
-        name.utf8CString.withUnsafeBufferPointer { nameBytes in
+        unsafe name.utf8CString.withUnsafeBufferPointer { nameBytes in
           Builtin.createTask(
             flags: flags,
             initialSerialExecutor: builtinSerialExecutor,

stdlib/public/Concurrency/TaskGroup+addTask.swift.gyb

@@ -262,7 +262,7 @@ extension ${TYPE} {
     #if $BuiltinCreateAsyncTaskName
     if let name {
       task =
-        name.utf8CString.withUnsafeBufferPointer { nameBytes in
+        unsafe name.utf8CString.withUnsafeBufferPointer { nameBytes in
           ${TASK_CREATE_FN}(
             flags: flags,
             initialSerialExecutor: builtinSerialExecutor,

stdlib/public/Cxx/std/String.swift

@@ -45,7 +45,7 @@ extension std.string {
       unsafe self.init(str, UTF8._nullCodeUnitOffset(in: str), .init())
 #endif
     } else {
-      unsafe self.init()
+      self.init()
     }
   }
 }
@@ -58,9 +58,9 @@ extension std.u16string {
   ///   Swift string.
   @_alwaysEmitIntoClient
   public init(_ string: String) {
-    unsafe self.init()
+    self.init()
     for char in string.utf16 {
-      unsafe self.push_back(char)
+      self.push_back(char)
     }
   }
 }
@@ -73,9 +73,9 @@ extension std.u32string {
   ///   Swift string.
   @_alwaysEmitIntoClient
   public init(_ string: String) {
-    unsafe self.init()
+    self.init()
     for char in string.unicodeScalars {
-      unsafe self.push_back(char)
+      self.push_back(char)
     }
   }
 }
@@ -87,7 +87,7 @@ extension std.string: ExpressibleByStringLiteral,
 
   @_alwaysEmitIntoClient
   public init(stringLiteral value: String) {
-    unsafe self.init(value)
+    self.init(value)
   }
 }
 
@@ -96,7 +96,7 @@ extension std.u16string: ExpressibleByStringLiteral,
 
   @_alwaysEmitIntoClient
   public init(stringLiteral value: String) {
-    unsafe self.init(value)
+    self.init(value)
   }
 }
 
@@ -105,7 +105,7 @@ extension std.u32string: ExpressibleByStringLiteral,
 
   @_alwaysEmitIntoClient
   public init(stringLiteral value: String) {
-    unsafe self.init(value)
+    self.init(value)
   }
 }
 
@@ -114,17 +114,17 @@ extension std.u32string: ExpressibleByStringLiteral,
 extension std.string: Equatable, Comparable {
   @_alwaysEmitIntoClient
   public static func ==(lhs: std.string, rhs: std.string) -> Bool {
-    return unsafe lhs.compare(rhs) == 0
+    return lhs.compare(rhs) == 0
   }
 
   @_alwaysEmitIntoClient
   public static func <(lhs: std.string, rhs: std.string) -> Bool {
-    return unsafe lhs.compare(rhs) < 0
+    return lhs.compare(rhs) < 0
   }
 
   @_alwaysEmitIntoClient
   public static func +=(lhs: inout std.string, rhs: std.string) {
-    unsafe lhs.append(rhs)
+    lhs.append(rhs)
   }
 
   @_alwaysEmitIntoClient
@@ -134,26 +134,26 @@ extension std.string: Equatable, Comparable {
 
   @_alwaysEmitIntoClient
   public static func +(lhs: std.string, rhs: std.string) -> std.string {
-    var copy = unsafe lhs
-    unsafe copy += rhs
-    return unsafe copy
+    var copy = lhs
+    copy += rhs
+    return copy
   }
 }
 
 extension std.u16string: Equatable, Comparable {
   @_alwaysEmitIntoClient
   public static func ==(lhs: std.u16string, rhs: std.u16string) -> Bool {
-    return unsafe lhs.compare(rhs) == 0
+    return lhs.compare(rhs) == 0
   }
 
   @_alwaysEmitIntoClient
   public static func <(lhs: std.u16string, rhs: std.u16string) -> Bool {
-    return unsafe lhs.compare(rhs) < 0
+    return lhs.compare(rhs) < 0
   }
 
   @_alwaysEmitIntoClient
   public static func +=(lhs: inout std.u16string, rhs: std.u16string) {
-    unsafe lhs.append(rhs)
+    lhs.append(rhs)
   }
 
   @_alwaysEmitIntoClient
@@ -163,26 +163,26 @@ extension std.u16string: Equatable, Comparable {
 
   @_alwaysEmitIntoClient
   public static func +(lhs: std.u16string, rhs: std.u16string) -> std.u16string {
-    var copy = unsafe lhs
-    unsafe copy += rhs
-    return unsafe copy
+    var copy = lhs
+    copy += rhs
+    return copy
   }
 }
 
 extension std.u32string: Equatable, Comparable {
   @_alwaysEmitIntoClient
   public static func ==(lhs: std.u32string, rhs: std.u32string) -> Bool {
-    return unsafe lhs.compare(rhs) == 0
+    return lhs.compare(rhs) == 0
   }
 
   @_alwaysEmitIntoClient
   public static func <(lhs: std.u32string, rhs: std.u32string) -> Bool {
-    return unsafe lhs.compare(rhs) < 0
+    return lhs.compare(rhs) < 0
   }
 
   @_alwaysEmitIntoClient
   public static func +=(lhs: inout std.u32string, rhs: std.u32string) {
-    unsafe lhs.append(rhs)
+    lhs.append(rhs)
   }
 
   @_alwaysEmitIntoClient
@@ -192,9 +192,9 @@ extension std.u32string: Equatable, Comparable {
 
   @_alwaysEmitIntoClient
   public static func +(lhs: std.u32string, rhs: std.u32string) -> std.u32string {
-    var copy = unsafe lhs
-    unsafe copy += rhs
-    return unsafe copy
+    var copy = lhs
+    copy += rhs
+    return copy
   }
 }
 
@@ -204,7 +204,7 @@ extension std.string: Hashable {
   @_alwaysEmitIntoClient
   public func hash(into hasher: inout Hasher) {
     // Call std::hash<std::string>::operator()
-    let cxxHash = unsafe __swift_interopComputeHashOfString(self)
+    let cxxHash = __swift_interopComputeHashOfString(self)
     hasher.combine(cxxHash)
   }
 }
@@ -213,7 +213,7 @@ extension std.u16string: Hashable {
   @_alwaysEmitIntoClient
   public func hash(into hasher: inout Hasher) {
     // Call std::hash<std::u16string>::operator()
-    let cxxHash = unsafe __swift_interopComputeHashOfU16String(self)
+    let cxxHash = __swift_interopComputeHashOfU16String(self)
     hasher.combine(cxxHash)
   }
 }
@@ -222,7 +222,7 @@ extension std.u32string: Hashable {
   @_alwaysEmitIntoClient
   public func hash(into hasher: inout Hasher) {
     // Call std::hash<std::u32string>::operator()
-    let cxxHash = unsafe __swift_interopComputeHashOfU32String(self)
+    let cxxHash = __swift_interopComputeHashOfU32String(self)
     hasher.combine(cxxHash)
   }
 }
@@ -232,42 +232,42 @@ extension std.u32string: Hashable {
 extension std.string: CustomDebugStringConvertible {
   @_alwaysEmitIntoClient
   public var debugDescription: String {
-    return "std.string(\(unsafe String(self)))"
+    return "std.string(\(String(self)))"
   }
 }
 
 extension std.u16string: CustomDebugStringConvertible {
   @_alwaysEmitIntoClient
   public var debugDescription: String {
-    return "std.u16string(\(unsafe String(self)))"
+    return "std.u16string(\(String(self)))"
   }
 }
 
 extension std.u32string: CustomDebugStringConvertible {
   @_alwaysEmitIntoClient
   public var debugDescription: String {
-    return "std.u32string(\(unsafe String(self)))"
+    return "std.u32string(\(String(self)))"
   }
 }
 
 extension std.string: CustomStringConvertible {
   @_alwaysEmitIntoClient
   public var description: String {
-    return unsafe String(self)
+    return String(self)
   }
 }
 
 extension std.u16string: CustomStringConvertible {
   @_alwaysEmitIntoClient
   public var description: String {
-    return unsafe String(self)
+    return String(self)
   }
 }
 
 extension std.u32string: CustomStringConvertible {
   @_alwaysEmitIntoClient
   public var description: String {
-    return unsafe String(self)
+    return String(self)
   }
 }
 
@@ -289,7 +289,7 @@ extension String {
     self = unsafe buffer.withMemoryRebound(to: UInt8.self) {
       unsafe String(decoding: $0, as: UTF8.self)
     }
-    unsafe withExtendedLifetime(cxxString) {}
+    withExtendedLifetime(cxxString) {}
   }
 
   /// Creates a String having the same content as the given C++ UTF-16 string.
@@ -306,7 +306,7 @@ extension String {
       start: cxxU16String.__dataUnsafe(),
       count: cxxU16String.size())
     self = unsafe String(decoding: buffer, as: UTF16.self)
-    unsafe withExtendedLifetime(cxxU16String) {}
+    withExtendedLifetime(cxxU16String) {}
   }
 
   /// Creates a String having the same content as the given C++ UTF-32 string.
@@ -325,7 +325,7 @@ extension String {
     self = unsafe buffer.withMemoryRebound(to: UInt32.self) {
       unsafe String(decoding: $0, as: UTF32.self)
     }
-    unsafe withExtendedLifetime(cxxU32String) {}
+    withExtendedLifetime(cxxU32String) {}
   }
 }
 

stdlib/public/Distributed/LocalTestingDistributedActorSystem.swift

@@ -252,7 +252,7 @@ fileprivate class _Lock {
 
   init() {
     #if os(iOS) || os(macOS) || os(tvOS) || os(watchOS) || os(visionOS)
-    self.underlying = UnsafeMutablePointer.allocate(capacity: 1)
+    unsafe self.underlying = UnsafeMutablePointer.allocate(capacity: 1)
     unsafe self.underlying.initialize(to: os_unfair_lock())
     #elseif os(Windows)
     self.underlying = UnsafeMutablePointer.allocate(capacity: 1)

stdlib/public/Synchronization/Atomics/AtomicLazyReference.swift

@@ -25,7 +25,7 @@ public struct AtomicLazyReference<Instance: AnyObject>: ~Copyable {
   @available(SwiftStdlib 6.0, *)
   @inlinable
   public init() {
-    storage = unsafe Atomic<Unmanaged<Instance>?>(nil)
+    unsafe storage = Atomic<Unmanaged<Instance>?>(nil)
   }
 
   @inlinable

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