[6.0][stdlib] Start adopting noncopyable generics in the stdlib

stdlib/public/Cxx/UnsafeCxxIterators.swift

@@ -2,7 +2,7 @@
 //
 // This source file is part of the Swift.org open source project
 //
-// Copyright (c) 2014 - 2023 Apple Inc. and the Swift project authors
+// Copyright (c) 2014 - 2024 Apple Inc. and the Swift project authors
 // Licensed under Apache License v2.0 with Runtime Library Exception
 //
 // See https://swift.org/LICENSE.txt for license information
@@ -18,12 +18,13 @@
 ///
 /// - SeeAlso: https://en.cppreference.com/w/cpp/named_req/InputIterator
 public protocol UnsafeCxxInputIterator: Equatable {
-  associatedtype Pointee
+  associatedtype Pointee: ~Copyable
 
   /// Returns the unwrapped result of C++ `operator*()`.
   ///
   /// Generally, Swift creates this property automatically for C++ types that
   /// define `operator*()`.
+  @_borrowed
   var pointee: Pointee { get }
 
   /// Returns an iterator pointing to the next item in the sequence.
@@ -33,19 +34,23 @@ public protocol UnsafeCxxInputIterator: Equatable {
   func successor() -> Self
 }
 
-extension UnsafePointer: UnsafeCxxInputIterator {}
+extension UnsafePointer: UnsafeCxxInputIterator
+where Pointee: ~Copyable {}
 
-extension UnsafeMutablePointer: UnsafeCxxInputIterator {}
+extension UnsafeMutablePointer: UnsafeCxxInputIterator
+where Pointee: ~Copyable {}
 
 extension Optional: UnsafeCxxInputIterator where Wrapped: UnsafeCxxInputIterator {
   public typealias Pointee = Wrapped.Pointee
 
   @inlinable
   public var pointee: Pointee {
-    if let value = self {
-      return value.pointee
+    _read {
+      guard let value = self else {
+        fatalError("Could not dereference nullptr")
+      }
+      yield value.pointee
     }
-    fatalError("Could not dereference nullptr")
   }
 
   @inlinable
@@ -58,10 +63,12 @@ extension Optional: UnsafeCxxInputIterator where Wrapped: UnsafeCxxInputIterator
 }
 
 public protocol UnsafeCxxMutableInputIterator: UnsafeCxxInputIterator {
+  @_borrowed
   override var pointee: Pointee { get set }
 }
 
-extension UnsafeMutablePointer: UnsafeCxxMutableInputIterator {}
+extension UnsafeMutablePointer: UnsafeCxxMutableInputIterator
+where Pointee: ~Copyable {}
 
 /// Bridged C++ iterator that allows computing the distance between two of its
 /// instances, and advancing an instance by a given number of elements.
@@ -77,10 +84,14 @@ public protocol UnsafeCxxRandomAccessIterator: UnsafeCxxInputIterator {
   static func +=(lhs: inout Self, rhs: Distance)
 }
 
-extension UnsafePointer: UnsafeCxxRandomAccessIterator {}
+extension UnsafePointer: UnsafeCxxRandomAccessIterator
+where Pointee: ~Copyable {}
 
-extension UnsafeMutablePointer: UnsafeCxxRandomAccessIterator {}
+extension UnsafeMutablePointer: UnsafeCxxRandomAccessIterator
+where Pointee: ~Copyable {}
 
-public protocol UnsafeCxxMutableRandomAccessIterator: UnsafeCxxRandomAccessIterator, UnsafeCxxMutableInputIterator {}
+public protocol UnsafeCxxMutableRandomAccessIterator:
+UnsafeCxxRandomAccessIterator, UnsafeCxxMutableInputIterator {}
 
-extension UnsafeMutablePointer: UnsafeCxxMutableRandomAccessIterator {}
+extension UnsafeMutablePointer: UnsafeCxxMutableRandomAccessIterator
+where Pointee: ~Copyable {}

stdlib/public/Synchronization/AtomicPointers.swift

@@ -2,7 +2,7 @@
 //
 // This source file is part of the Swift.org open source project
 //
-// Copyright (c) 2023 Apple Inc. and the Swift project authors
+// Copyright (c) 2023 - 2024 Apple Inc. and the Swift project authors
 // Licensed under Apache License v2.0 with Runtime Library Exception
 //
 // See https://swift.org/LICENSE.txt for license information
@@ -15,7 +15,7 @@
 //===----------------------------------------------------------------------===//
 
 @available(SwiftStdlib 6.0, *)
-extension UnsafePointer: AtomicRepresentable {
+extension UnsafePointer: AtomicRepresentable where Pointee: ~Copyable {
   /// The storage representation type that `Self` encodes to and decodes from
   /// which is a suitable type when used in atomic operations.
   @available(SwiftStdlib 6.0, *)
@@ -65,7 +65,7 @@ extension UnsafePointer: AtomicRepresentable {
 }
 
 @available(SwiftStdlib 6.0, *)
-extension UnsafePointer: AtomicOptionalRepresentable {
+extension UnsafePointer: AtomicOptionalRepresentable where Pointee: ~Copyable {
   /// The storage representation type that encodes to and decodes from
   /// `Optional<Self>` which is a suitable type when used in atomic operations
   /// on `Optional`.
@@ -121,7 +121,7 @@ extension UnsafePointer: AtomicOptionalRepresentable {
 //===----------------------------------------------------------------------===//
 
 @available(SwiftStdlib 6.0, *)
-extension UnsafeMutablePointer: AtomicRepresentable {
+extension UnsafeMutablePointer: AtomicRepresentable where Pointee: ~Copyable {
   /// The storage representation type that `Self` encodes to and decodes from
   /// which is a suitable type when used in atomic operations.
   @available(SwiftStdlib 6.0, *)
@@ -171,7 +171,8 @@ extension UnsafeMutablePointer: AtomicRepresentable {
 }
 
 @available(SwiftStdlib 6.0, *)
-extension UnsafeMutablePointer: AtomicOptionalRepresentable {
+extension UnsafeMutablePointer: AtomicOptionalRepresentable
+where Pointee: ~Copyable {
   /// The storage representation type that encodes to and decodes from
   /// `Optional<Self>` which is a suitable type when used in atomic operations
   /// on `Optional`.
@@ -773,7 +774,7 @@ extension ObjectIdentifier: AtomicOptionalRepresentable {
 #if (_pointerBitWidth(_32) && _hasAtomicBitWidth(_64)) || (_pointerBitWidth(_64) && _hasAtomicBitWidth(_128))
 
 @available(SwiftStdlib 6.0, *)
-extension UnsafeBufferPointer: AtomicRepresentable {
+extension UnsafeBufferPointer: AtomicRepresentable where Element: ~Copyable {
   /// The storage representation type that `Self` encodes to and decodes from
   /// which is a suitable type when used in atomic operations.
   @available(SwiftStdlib 6.0, *)
@@ -839,7 +840,9 @@ extension UnsafeBufferPointer: AtomicRepresentable {
 #if (_pointerBitWidth(_32) && _hasAtomicBitWidth(_64)) || (_pointerBitWidth(_64) && _hasAtomicBitWidth(_128))
 
 @available(SwiftStdlib 6.0, *)
-extension UnsafeMutableBufferPointer: AtomicRepresentable {
+extension UnsafeMutableBufferPointer: AtomicRepresentable
+where Element: ~Copyable
+{
   /// The storage representation type that `Self` encodes to and decodes from
   /// which is a suitable type when used in atomic operations.
   @available(SwiftStdlib 6.0, *)

stdlib/public/core/CMakeLists.txt

@@ -314,6 +314,7 @@ list(APPEND swift_stdlib_compile_flags "-enable-experimental-feature" "Macros")
 list(APPEND swift_stdlib_compile_flags "-enable-experimental-feature" "FreestandingMacros")
 list(APPEND swift_stdlib_compile_flags "-enable-experimental-feature" "Extern")
 list(APPEND swift_stdlib_compile_flags "-enable-experimental-feature" "BitwiseCopyable")
+list(APPEND swift_stdlib_compile_flags "-enable-experimental-feature" "BorrowingSwitch")
 
 if("${SWIFT_NATIVE_SWIFT_TOOLS_PATH}" STREQUAL "")
   set(swift_bin_dir "${CMAKE_BINARY_DIR}/bin")

stdlib/public/core/CTypes.swift

@@ -2,7 +2,7 @@
 //
 // This source file is part of the Swift.org open source project
 //
-// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
+// Copyright (c) 2014 - 2024 Apple Inc. and the Swift project authors
 // Licensed under Apache License v2.0 with Runtime Library Exception
 //
 // See https://swift.org/LICENSE.txt for license information
@@ -150,38 +150,58 @@ public struct OpaquePointer {
   internal init(_ v: Builtin.RawPointer) {
     self._rawValue = v
   }
+}
+
+@available(*, unavailable)
+extension OpaquePointer: Sendable {}
 
-  /// Creates an `OpaquePointer` from a given address in memory.
+extension OpaquePointer {
+  /// Creates a new `OpaquePointer` from the given address, specified as a bit
+  /// pattern.
+  ///
+  /// - Parameter bitPattern: A bit pattern to use for the address of the new
+  ///   pointer. If `bitPattern` is zero, the result is `nil`.
   @_transparent
   public init?(bitPattern: Int) {
     if bitPattern == 0 { return nil }
     self._rawValue = Builtin.inttoptr_Word(bitPattern._builtinWordValue)
   }
 
-  /// Creates an `OpaquePointer` from a given address in memory.
+  /// Creates a new `OpaquePointer` from the given address, specified as a bit
+  /// pattern.
+  ///
+  /// - Parameter bitPattern: A bit pattern to use for the address of the new
+  ///   pointer. If `bitPattern` is zero, the result is `nil`.
   @_transparent
   public init?(bitPattern: UInt) {
     if bitPattern == 0 { return nil }
     self._rawValue = Builtin.inttoptr_Word(bitPattern._builtinWordValue)
   }
+}
 
+extension OpaquePointer {
   /// Converts a typed `UnsafePointer` to an opaque C pointer.
   @_transparent
-  public init<T>(@_nonEphemeral _ from: UnsafePointer<T>) {
+  @_preInverseGenerics
+  public init<T: ~Copyable>(@_nonEphemeral _ from: UnsafePointer<T>) {
     self._rawValue = from._rawValue
   }
 
   /// Converts a typed `UnsafePointer` to an opaque C pointer.
   ///
   /// The result is `nil` if `from` is `nil`.
   @_transparent
-  public init?<T>(@_nonEphemeral _ from: UnsafePointer<T>?) {
+  @_preInverseGenerics
+  public init?<T: ~Copyable>(@_nonEphemeral _ from: UnsafePointer<T>?) {
     guard let unwrapped = from else { return nil }
     self.init(unwrapped)
   }
+}
 
+extension OpaquePointer {
   /// Converts a typed `UnsafeMutablePointer` to an opaque C pointer.
   @_transparent
+  @_preInverseGenerics
   public init<T>(@_nonEphemeral _ from: UnsafeMutablePointer<T>) {
     self._rawValue = from._rawValue
   }
@@ -190,6 +210,7 @@ public struct OpaquePointer {
   ///
   /// The result is `nil` if `from` is `nil`.
   @_transparent
+  @_preInverseGenerics
   public init?<T>(@_nonEphemeral _ from: UnsafeMutablePointer<T>?) {
     guard let unwrapped = from else { return nil }
     self.init(unwrapped)
@@ -215,9 +236,6 @@ extension OpaquePointer: Hashable {
   }
 }
 
-@available(*, unavailable)
-extension OpaquePointer : Sendable { }
-
 @_unavailableInEmbedded
 extension OpaquePointer: CustomDebugStringConvertible {
   /// A textual representation of the pointer, suitable for debugging.

stdlib/public/core/CompilerProtocols.swift

@@ -2,7 +2,7 @@
 //
 // This source file is part of the Swift.org open source project
 //
-// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
+// Copyright (c) 2014 - 2024 Apple Inc. and the Swift project authors
 // Licensed under Apache License v2.0 with Runtime Library Exception
 //
 // See https://swift.org/LICENSE.txt for license information
@@ -266,7 +266,7 @@ public protocol CaseIterable {
 /// `Optional` type conforms to `ExpressibleByNilLiteral`.
 /// `ExpressibleByNilLiteral` conformance for types that use `nil` for other
 /// purposes is discouraged.
-public protocol ExpressibleByNilLiteral {
+public protocol ExpressibleByNilLiteral: ~Copyable {
   /// Creates an instance initialized with `nil`.
   init(nilLiteral: ())
 }