Enable strict memory safety in the Concurrency module

Author: DougGregor

stdlib/public/Concurrency/AsyncStreamBuffer.swift

@@ -65,6 +65,8 @@ list(APPEND SWIFT_RUNTIME_CONCURRENCY_SWIFT_FLAGS
   "IsolatedAny"
   )
 
+list(APPEND SWIFT_RUNTIME_CONCURRENCY_SWIFT_FLAGS "-strict-memory-safety")
+
 list(APPEND SWIFT_RUNTIME_CONCURRENCY_C_FLAGS
   "-D__STDC_WANT_LIB_EXT1__=1")
 

stdlib/public/Concurrency/CMakeLists.txt

@@ -27,59 +27,59 @@ internal final class CheckedContinuationCanary: @unchecked Sendable {
 
   private static func _create(continuation: UnsafeRawPointer, function: String)
       -> CheckedContinuationCanary {
-    let instance = Builtin.allocWithTailElems_1(CheckedContinuationCanary.self,
+    let instance = unsafe Builtin.allocWithTailElems_1(CheckedContinuationCanary.self,
       1._builtinWordValue,
       (UnsafeRawPointer?, String).self)
 
-    instance._continuationPtr.initialize(to: continuation)
-    instance._functionPtr.initialize(to: function)
+    unsafe instance._continuationPtr.initialize(to: continuation)
+    unsafe instance._functionPtr.initialize(to: function)
     return instance
   }
 
   private var _continuationPtr: UnsafeMutablePointer<UnsafeRawPointer?> {
-    return UnsafeMutablePointer<UnsafeRawPointer?>(
+    return unsafe UnsafeMutablePointer<UnsafeRawPointer?>(
       Builtin.projectTailElems(self, (UnsafeRawPointer?, String).self))
   }
   private var _functionPtr: UnsafeMutablePointer<String> {
-    let tailPtr = UnsafeMutableRawPointer(
+    let tailPtr = unsafe UnsafeMutableRawPointer(
       Builtin.projectTailElems(self, (UnsafeRawPointer?, String).self))
 
-    let functionPtr = tailPtr 
+    let functionPtr = unsafe tailPtr 
         + MemoryLayout<(UnsafeRawPointer?, String)>.offset(of: \(UnsafeRawPointer?, String).1)!
 
-    return functionPtr.assumingMemoryBound(to: String.self)
+    return unsafe functionPtr.assumingMemoryBound(to: String.self)
   }
 
   internal static func create<T, E>(continuation: UnsafeContinuation<T, E>,
                                  function: String) -> CheckedContinuationCanary {
-    return _create(
+    return unsafe _create(
         continuation: unsafeBitCast(continuation, to: UnsafeRawPointer.self),
         function: function)
   }
 
   internal var function: String {
-    return _functionPtr.pointee
+    return unsafe _functionPtr.pointee
   }
 
   // Take the continuation away from the container, or return nil if it's
   // already been taken.
   internal func takeContinuation<T, E>() -> UnsafeContinuation<T, E>? {
     // Atomically exchange the current continuation value with a null pointer.
-    let rawContinuationPtr = unsafeBitCast(_continuationPtr,
+    let rawContinuationPtr = unsafe unsafeBitCast(_continuationPtr,
       to: Builtin.RawPointer.self)
     let rawOld = Builtin.atomicrmw_xchg_seqcst_Word(rawContinuationPtr,
       0._builtinWordValue)
 
-    return unsafeBitCast(rawOld, to: UnsafeContinuation<T, E>?.self)
+    return unsafe unsafeBitCast(rawOld, to: UnsafeContinuation<T, E>?.self)
   }
 
   deinit {
-    _functionPtr.deinitialize(count: 1)
+    unsafe _functionPtr.deinitialize(count: 1)
     // Log if the continuation was never consumed before the instance was
     // destructed.
-    if _continuationPtr.pointee != nil {
+    if unsafe _continuationPtr.pointee != nil {
       #if !$Embedded
-      logFailedCheck("SWIFT TASK CONTINUATION MISUSE: \(function) leaked its continuation without resuming it. This may cause tasks waiting on it to remain suspended forever.\n")
+      unsafe logFailedCheck("SWIFT TASK CONTINUATION MISUSE: \(function) leaked its continuation without resuming it. This may cause tasks waiting on it to remain suspended forever.\n")
       #else
       fatalError("SWIFT TASK CONTINUATION MISUSE")
       #endif
@@ -144,7 +144,7 @@ public struct CheckedContinuation<T, E: Error>: Sendable {
   ///     source for the continuation, used to identify the continuation in
   ///     runtime diagnostics related to misuse of this continuation.
   public init(continuation: UnsafeContinuation<T, E>, function: String = #function) {
-    canary = CheckedContinuationCanary.create(
+    canary = unsafe CheckedContinuationCanary.create(
       continuation: continuation,
       function: function)
   }
@@ -162,8 +162,8 @@ public struct CheckedContinuation<T, E: Error>: Sendable {
   /// the caller. The task continues executing when its executor is
   /// able to reschedule it.
   public func resume(returning value: sending T) {
-    if let c: UnsafeContinuation<T, E> = canary.takeContinuation() {
-      c.resume(returning: value)
+    if let c: UnsafeContinuation<T, E> = unsafe canary.takeContinuation() {
+      unsafe c.resume(returning: value)
     } else {
       #if !$Embedded
       fatalError("SWIFT TASK CONTINUATION MISUSE: \(canary.function) tried to resume its continuation more than once, returning \(value)!\n")
@@ -186,8 +186,8 @@ public struct CheckedContinuation<T, E: Error>: Sendable {
   /// the caller. The task continues executing when its executor is
   /// able to reschedule it.
   public func resume(throwing error: __owned E) {
-    if let c: UnsafeContinuation<T, E> = canary.takeContinuation() {
-      c.resume(throwing: error)
+    if let c: UnsafeContinuation<T, E> = unsafe canary.takeContinuation() {
+      unsafe c.resume(throwing: error)
     } else {
       #if !$Embedded
       fatalError("SWIFT TASK CONTINUATION MISUSE: \(canary.function) tried to resume its continuation more than once, throwing \(error)!\n")
@@ -301,9 +301,9 @@ public func withCheckedContinuation<T>(
   _ body: (CheckedContinuation<T, Never>) -> Void
 ) async -> sending T {
   return await Builtin.withUnsafeContinuation {
-    let unsafeContinuation = UnsafeContinuation<T, Never>($0)
-    return body(CheckedContinuation(continuation: unsafeContinuation,
-                                    function: function))
+    let unsafeContinuation = unsafe UnsafeContinuation<T, Never>($0)
+    return body(unsafe CheckedContinuation(continuation: unsafeContinuation,
+                                           function: function))
   }
 }
 
@@ -320,8 +320,8 @@ public func _unsafeInheritExecutor_withCheckedContinuation<T>(
   function: String = #function,
   _ body: (CheckedContinuation<T, Never>) -> Void
 ) async -> T {
-  return await withUnsafeContinuation {
-    body(CheckedContinuation(continuation: $0, function: function))
+  return await unsafe withUnsafeContinuation {
+    body(unsafe CheckedContinuation(continuation: $0, function: function))
   }
 }
 
@@ -365,9 +365,9 @@ public func withCheckedThrowingContinuation<T>(
   _ body: (CheckedContinuation<T, Error>) -> Void
 ) async throws -> sending T {
   return try await Builtin.withUnsafeThrowingContinuation {
-    let unsafeContinuation = UnsafeContinuation<T, Error>($0)
-    return body(CheckedContinuation(continuation: unsafeContinuation,
-                                    function: function))
+    let unsafeContinuation = unsafe UnsafeContinuation<T, Error>($0)
+    return body(unsafe CheckedContinuation(continuation: unsafeContinuation,
+                                           function: function))
   }
 }
 
@@ -384,8 +384,8 @@ public func _unsafeInheritExecutor_withCheckedThrowingContinuation<T>(
   function: String = #function,
   _ body: (CheckedContinuation<T, Error>) -> Void
 ) async throws -> T {
-  return try await withUnsafeThrowingContinuation {
-    body(CheckedContinuation(continuation: $0, function: function))
+  return try await unsafe withUnsafeThrowingContinuation {
+    body(unsafe CheckedContinuation(continuation: $0, function: function))
   }
 }
 
@@ -397,15 +397,15 @@ public func _unsafeInheritExecutor_withCheckedThrowingContinuation<T>(
 internal func _createCheckedContinuation<T>(
   _ continuation: __owned UnsafeContinuation<T, Never>
 ) -> CheckedContinuation<T, Never> {
-  return CheckedContinuation(continuation: continuation)
+  return unsafe CheckedContinuation(continuation: continuation)
 }
 
 @available(SwiftStdlib 5.1, *)
 @_alwaysEmitIntoClient
 internal func _createCheckedThrowingContinuation<T>(
   _ continuation: __owned UnsafeContinuation<T, Error>
 ) -> CheckedContinuation<T, Error> {
-  return CheckedContinuation(continuation: continuation)
+  return unsafe CheckedContinuation(continuation: continuation)
 }
 
 @available(SwiftStdlib 5.1, *)

stdlib/public/Concurrency/CheckedContinuation.swift

@@ -75,7 +75,7 @@ extension ContinuousClock: Clock {
   public var minimumResolution: Swift.Duration {
     var seconds = Int64(0)
     var nanoseconds = Int64(0)
-    _getClockRes(
+    unsafe _getClockRes(
       seconds: &seconds,
       nanoseconds: &nanoseconds,
       clock: _ClockID.continuous.rawValue)
@@ -86,7 +86,7 @@ extension ContinuousClock: Clock {
   public static var now: ContinuousClock.Instant {
     var seconds = Int64(0)
     var nanoseconds = Int64(0)
-    _getTime(
+    unsafe _getTime(
       seconds: &seconds,
       nanoseconds: &nanoseconds,
       clock: _ClockID.continuous.rawValue)