Sendablize the standard library

oops dont add this flag

no more nonisolated

Author: Azoy

stdlib/public/core/Algorithm.swift

@@ -103,6 +103,8 @@ public struct EnumeratedSequence<Base: Sequence> {
   }
 }
 
+extension EnumeratedSequence: Sendable where Base: Sendable {}
+
 extension EnumeratedSequence {
   /// The iterator for `EnumeratedSequence`.
   ///
@@ -134,6 +136,8 @@ extension EnumeratedSequence {
   }
 }
 
+extension EnumeratedSequence.Iterator: Sendable where Base.Iterator: Sendable {}
+
 extension EnumeratedSequence.Iterator: IteratorProtocol, Sequence {
   /// The type of element returned by `next()`.
   public typealias Element = (offset: Int, element: Base.Element)

stdlib/public/core/AnyHashable.swift

@@ -212,6 +212,9 @@ public struct AnyHashable {
   }
 }
 
+@available(*, unavailable)
+extension AnyHashable: Sendable {}
+
 @_unavailableInEmbedded
 extension AnyHashable: Equatable {
   /// Returns a Boolean value indicating whether two type-erased hashable

stdlib/public/core/AtomicInt.swift.gyb

@@ -60,6 +60,9 @@ public final class _stdlib_AtomicInt {
   }
 }
 
+@available(*, unavailable)
+extension _stdlib_AtomicInt: Sendable {}
+
 @usableFromInline // used by SwiftPrivate._stdlib_AtomicInt
 internal func _swift_stdlib_atomicCompareExchangeStrongInt(
   object target: UnsafeMutablePointer<Int>,

stdlib/public/core/Bitset.swift

@@ -33,6 +33,9 @@ internal struct _UnsafeBitset {
   }
 }
 
+@available(*, unavailable)
+extension _UnsafeBitset: Sendable {}
+
 extension _UnsafeBitset {
   @inlinable
   @inline(__always)
@@ -179,6 +182,9 @@ extension _UnsafeBitset: Sequence {
   }
 }
 
+@available(*, unavailable)
+extension _UnsafeBitset.Iterator: Sendable {}
+
 ////////////////////////////////////////////////////////////////////////////////
 
 extension _UnsafeBitset {

stdlib/public/core/BridgeObjectiveC.swift

@@ -182,6 +182,7 @@ public struct _BridgeableMetatype: _ObjectiveCBridgeable {
   }
 }
 
+extension _BridgeableMetatype: Sendable {}
 
 //===--- Bridging facilities written in Objective-C -----------------------===//
 // Functions that must discover and possibly use an arbitrary type's

stdlib/public/core/CocoaArray.swift

@@ -160,4 +160,8 @@ internal struct _CocoaArrayWrapper: RandomAccessCollection {
     return (IndexingIterator(_elements: self, _position: c), c)
   }
 }
+
+@available(*, unavailable)
+extension _CocoaArrayWrapper: Sendable {}
+
 #endif

stdlib/public/core/Codable.swift

@@ -933,6 +933,9 @@ public struct KeyedEncodingContainer<K: CodingKey> :
   }
 }
 
+@available(*, unavailable)
+extension KeyedEncodingContainer: Sendable {}
+
 /// A type that provides a view into a decoder's storage and is used to hold
 /// the encoded properties of a decodable type in a keyed manner.
 ///
@@ -2115,6 +2118,9 @@ public struct KeyedDecodingContainer<K: CodingKey> :
   }
 }
 
+@available(*, unavailable)
+extension KeyedDecodingContainer: Sendable {}
+
 //===----------------------------------------------------------------------===//
 // Unkeyed Encoding Containers
 //===----------------------------------------------------------------------===//

stdlib/public/core/ContiguousArrayBuffer.swift

@@ -63,6 +63,9 @@ internal final class __EmptyArrayStorage
   }
 }
 
+@available(*, unavailable)
+extension __EmptyArrayStorage: Sendable {}
+
 #if $Embedded
 // In embedded Swift, the stdlib is a .swiftmodule only without any .o/.a files,
 // to allow consuming it by clients with different LLVM codegen setting (-mcpu
@@ -117,6 +120,9 @@ internal final class __StaticArrayStorage
   }
 }
 
+@available(*, unavailable)
+extension __StaticArrayStorage: Sendable {}
+
 /// The empty array prototype.  We use the same object for all empty
 /// `[Native]Array<Element>`s.
 @inlinable
@@ -306,6 +312,9 @@ internal final class _ContiguousArrayStorage<
   }
 }
 
+@available(*, unavailable)
+extension _ContiguousArrayStorage: Sendable {}
+
 @_alwaysEmitIntoClient
 @inline(__always)
 internal func _uncheckedUnsafeBitCast<T, U>(_ x: T, to type: U.Type) -> U {
@@ -968,6 +977,9 @@ internal struct _ContiguousArrayBuffer<Element>: _ArrayBufferProtocol {
   }
 }
 
+@available(*, unavailable)
+extension _ContiguousArrayBuffer: Sendable {}
+
 /// Append the elements of `rhs` to `lhs`.
 @inlinable
 internal func += <Element, C: Collection>(
@@ -1218,3 +1230,6 @@ internal struct _UnsafePartiallyInitializedContiguousArrayBuffer<Element> {
     return ContiguousArray(_buffer: finalResult)
   }
 }
+
+@available(*, unavailable)
+extension _UnsafePartiallyInitializedContiguousArrayBuffer: Sendable {}

stdlib/public/core/Dictionary.swift

@@ -1789,6 +1789,8 @@ extension Dictionary {
   }
 }
 
+extension Dictionary.Index._Variant: @unchecked Sendable {}
+
 extension Dictionary.Index {
 #if _runtime(_ObjC)
   @usableFromInline @_transparent
@@ -1967,6 +1969,9 @@ extension Dictionary {
   }
 }
 
+extension Dictionary.Iterator._Variant: @unchecked Sendable
+  where Key: Sendable, Value: Sendable {}
+
 extension Dictionary.Iterator {
 #if _runtime(_ObjC)
   @usableFromInline @_transparent
@@ -2119,16 +2124,16 @@ public typealias DictionaryIterator<Key: Hashable, Value> =
   Dictionary<Key, Value>.Iterator
 
 extension Dictionary: @unchecked Sendable
-  where Key: Sendable, Value: Sendable { }
+  where Key: Sendable, Value: Sendable {}
 extension Dictionary.Keys: @unchecked Sendable
-  where Key: Sendable, Value: Sendable { }
+  where Key: Sendable, Value: Sendable {}
 extension Dictionary.Values: @unchecked Sendable
-  where Key: Sendable, Value: Sendable { }
+  where Key: Sendable, Value: Sendable {}
 extension Dictionary.Keys.Iterator: @unchecked Sendable
-  where Key: Sendable, Value: Sendable { }
+  where Key: Sendable, Value: Sendable {}
 extension Dictionary.Values.Iterator: @unchecked Sendable
-  where Key: Sendable, Value: Sendable { }
+  where Key: Sendable, Value: Sendable {}
 extension Dictionary.Index: @unchecked Sendable
-  where Key: Sendable, Value: Sendable { }
+  where Key: Sendable, Value: Sendable {}
 extension Dictionary.Iterator: @unchecked Sendable
-  where Key: Sendable, Value: Sendable { }
+  where Key: Sendable, Value: Sendable {}

stdlib/public/core/DictionaryBridging.swift

@@ -421,6 +421,9 @@ final internal class _SwiftDeferredNSDictionary<Key: Hashable, Value>
   }
 }
 
+@available(*, unavailable)
+extension _SwiftDeferredNSDictionary: Sendable {}
+
 // NOTE: older runtimes called this struct _CocoaDictionary. The two
 // must coexist without conflicting ObjC class names from the nested
 // classes, so it was renamed. The old names must not be used in the new
@@ -437,6 +440,9 @@ internal struct __CocoaDictionary {
   }
 }
 
+@available(*, unavailable)
+extension __CocoaDictionary: Sendable {}
+
 extension __CocoaDictionary {
   @usableFromInline
   internal func isEqual(to other: __CocoaDictionary) -> Bool {
@@ -733,6 +739,9 @@ extension __CocoaDictionary: Sequence {
   }
 }
 
+@available(*, unavailable)
+extension __CocoaDictionary.Iterator: Sendable {}
+
 extension __CocoaDictionary.Iterator: IteratorProtocol {
   @usableFromInline
   internal typealias Element = (key: AnyObject, value: AnyObject)