Make standard types conform BitwiseCopyable

stdlib/public/core/ClosedRange.swift

@@ -571,6 +571,9 @@ extension ClosedRange {
   }
 }
 
+extension ClosedRange: BitwiseCopyable where Bound: BitwiseCopyable {}
+extension ClosedRange.Index: BitwiseCopyable where Bound: BitwiseCopyable {}
+
 // Note: this is not for compatibility only, it is considered a useful
 // shorthand. TODO: Add documentation
 public typealias CountableClosedRange<Bound: Strideable> = ClosedRange<Bound>

stdlib/public/core/Collection.swift

@@ -130,6 +130,9 @@ extension IndexingIterator: IteratorProtocol, Sequence {
   }
 }
 
+extension IndexingIterator: BitwiseCopyable
+  where Elements: BitwiseCopyable, Elements.Index: BitwiseCopyable {}
+
 extension IndexingIterator: Sendable
   where Elements: Sendable, Elements.Index: Sendable { }
 

stdlib/public/core/CollectionOfOne.swift

@@ -194,6 +194,11 @@ extension CollectionOfOne: CustomDebugStringConvertible {
   }
 }
 
+extension CollectionOfOne: BitwiseCopyable
+where Element: BitwiseCopyable { }
+extension CollectionOfOne.Iterator: BitwiseCopyable
+where Element: BitwiseCopyable { }
+
 #if SWIFT_ENABLE_REFLECTION
 extension CollectionOfOne: CustomReflectable {
   public var customMirror: Mirror {

stdlib/public/core/EnumeratedSequence.swift

@@ -38,6 +38,8 @@ public struct EnumeratedSequence<Base: Sequence> {
   }
 }
 
+extension EnumeratedSequence: BitwiseCopyable where Base: BitwiseCopyable {}
+
 extension EnumeratedSequence: Sendable where Base: Sendable {}
 
 extension EnumeratedSequence {
@@ -71,6 +73,9 @@ extension EnumeratedSequence {
   }
 }
 
+extension EnumeratedSequence.Iterator: BitwiseCopyable
+where Base.Iterator: BitwiseCopyable {}
+
 extension EnumeratedSequence.Iterator: Sendable where Base.Iterator: Sendable {}
 
 extension EnumeratedSequence.Iterator: IteratorProtocol, Sequence {

stdlib/public/core/Flatten.swift

@@ -38,6 +38,8 @@ public struct FlattenSequence<Base: Sequence> where Base.Element: Sequence {
   }
 }
 
+extension FlattenSequence: BitwiseCopyable where Base: BitwiseCopyable {}
+
 extension FlattenSequence: Sendable where Base: Sendable {}
 
 extension FlattenSequence {
@@ -56,6 +58,10 @@ extension FlattenSequence {
   }
 }
 
+extension FlattenSequence.Iterator: BitwiseCopyable
+  where Base.Iterator: BitwiseCopyable,
+        Base.Element.Iterator: BitwiseCopyable {}
+
 extension FlattenSequence.Iterator: Sendable
   where Base.Iterator: Sendable, Base.Element.Iterator: Sendable {}
 
@@ -167,6 +173,9 @@ extension FlattenSequence where Base: Collection, Base.Element: Collection {
   }
 }
 
+extension FlattenSequence.Index: BitwiseCopyable
+  where Base.Index: BitwiseCopyable, Base.Element.Index: BitwiseCopyable {}
+
 extension FlattenSequence.Index: Sendable
   where Base.Index: Sendable, Base.Element.Index: Sendable {}
 

stdlib/public/core/Indices.swift

@@ -145,5 +145,8 @@ extension Collection where Indices == DefaultIndices<Self> {
   }
 }
 
+extension DefaultIndices: BitwiseCopyable
+  where Elements: BitwiseCopyable, Elements.Index: BitwiseCopyable { }
+
 extension DefaultIndices: Sendable
   where Elements: Sendable, Elements.Index: Sendable { }

stdlib/public/core/LazySequence.swift

@@ -188,6 +188,8 @@ public struct LazySequence<Base: Sequence> {
   }
 }
 
+extension LazySequence: BitwiseCopyable where Base: BitwiseCopyable {}
+
 extension LazySequence: Sendable where Base: Sendable {}
 
 extension LazySequence: Sequence {

stdlib/public/core/Range.swift

@@ -501,6 +501,8 @@ public struct PartialRangeUpTo<Bound: Comparable> {
   public init(_ upperBound: Bound) { self.upperBound = upperBound }
 }
 
+extension PartialRangeUpTo: BitwiseCopyable where Bound: BitwiseCopyable {}
+
 extension PartialRangeUpTo: RangeExpression {
   @_transparent
   public func relative<C: Collection>(to collection: C) -> Range<Bound>
@@ -559,6 +561,8 @@ public struct PartialRangeThrough<Bound: Comparable> {
   public init(_ upperBound: Bound) { self.upperBound = upperBound }
 }
 
+extension PartialRangeThrough: BitwiseCopyable where Bound: BitwiseCopyable {}
+
 extension PartialRangeThrough: RangeExpression {
   @_transparent
   public func relative<C: Collection>(to collection: C) -> Range<Bound>
@@ -676,6 +680,8 @@ public struct PartialRangeFrom<Bound: Comparable> {
   public init(_ lowerBound: Bound) { self.lowerBound = lowerBound }
 }
 
+extension PartialRangeFrom: BitwiseCopyable where Bound: BitwiseCopyable {}
+
 extension PartialRangeFrom: RangeExpression {
   @_transparent
   public func relative<C: Collection>(
@@ -723,6 +729,9 @@ extension PartialRangeFrom: Sequence
   }
 }
 
+extension PartialRangeFrom.Iterator: BitwiseCopyable
+  where Bound: BitwiseCopyable {}
+
 @_unavailableInEmbedded
 extension PartialRangeFrom: Decodable where Bound: Decodable {
   public init(from decoder: Decoder) throws {
@@ -1109,6 +1118,8 @@ extension Range {
   }
 }
 
+extension Range: BitwiseCopyable where Bound: BitwiseCopyable {}
+
 // Note: this is not for compatibility only, it is considered a useful
 // shorthand. TODO: Add documentation
 public typealias CountableRange<Bound: Strideable> = Range<Bound>

stdlib/public/core/Repeat.swift

@@ -108,4 +108,6 @@ public func repeatElement<T>(_ element: T, count n: Int) -> Repeated<T> {
   return Repeated(_repeating: element, count: n)
 }
 
+extension Repeated: BitwiseCopyable where Element: BitwiseCopyable {}
+
 extension Repeated: Sendable where Element: Sendable { }

stdlib/public/core/Reverse.swift

@@ -63,6 +63,8 @@ public struct ReversedCollection<Base: BidirectionalCollection> {
   }
 }
 
+extension ReversedCollection: BitwiseCopyable where Base: BitwiseCopyable {}
+
 extension ReversedCollection: Sendable where Base: Sendable {}
 
 extension ReversedCollection {
@@ -85,6 +87,9 @@ extension ReversedCollection {
   }
 }
 
+extension ReversedCollection.Iterator: BitwiseCopyable
+  where Base: BitwiseCopyable, Base.Index: BitwiseCopyable {}
+
 extension ReversedCollection.Iterator: Sendable
   where Base: Sendable, Base.Index: Sendable {}
 
@@ -175,6 +180,9 @@ extension ReversedCollection {
   }
 }
 
+extension ReversedCollection.Index: BitwiseCopyable
+  where Base.Index: BitwiseCopyable {}
+
 extension ReversedCollection.Index: Sendable where Base.Index: Sendable {}
 
 extension ReversedCollection.Index: Comparable {

stdlib/public/core/SIMDVector.swift

@@ -728,6 +728,8 @@ public struct SIMDMask<Storage>: SIMD
   }
 }
 
+extension SIMDMask: BitwiseCopyable where Storage: BitwiseCopyable {}
+
 extension SIMDMask: Sendable where Storage: Sendable {}
 
 extension SIMDMask {

stdlib/public/core/Sequence.swift

@@ -488,6 +488,8 @@ public struct DropFirstSequence<Base: Sequence> {
   }
 }
 
+extension DropFirstSequence: BitwiseCopyable where Base: BitwiseCopyable {}
+
 extension DropFirstSequence: Sendable where Base: Sendable {}
 
 extension DropFirstSequence: Sequence {
@@ -534,6 +536,8 @@ public struct PrefixSequence<Base: Sequence> {
   }
 }
 
+extension PrefixSequence: BitwiseCopyable where Base: BitwiseCopyable {}
+
 extension PrefixSequence: Sendable where Base: Sendable {}
 
 extension PrefixSequence {
@@ -552,6 +556,9 @@ extension PrefixSequence {
   }  
 }
 
+extension PrefixSequence.Iterator: BitwiseCopyable
+  where Base.Iterator: BitwiseCopyable {}
+
 extension PrefixSequence.Iterator: Sendable where Base.Iterator: Sendable {}
 
 extension PrefixSequence.Iterator: IteratorProtocol {
@@ -611,6 +618,9 @@ public struct DropWhileSequence<Base: Sequence> {
   }
 }
 
+extension DropWhileSequence: BitwiseCopyable
+  where Base.Iterator: BitwiseCopyable, Element: BitwiseCopyable {}
+
 extension DropWhileSequence: Sendable
   where Base.Iterator: Sendable, Element: Sendable {}
 
@@ -630,6 +640,9 @@ extension DropWhileSequence {
   }
 }
 
+extension DropWhileSequence.Iterator: BitwiseCopyable
+  where Base.Iterator: BitwiseCopyable, Element: BitwiseCopyable {}
+
 extension DropWhileSequence.Iterator: Sendable
   where Base.Iterator: Sendable, Element: Sendable {}
 
@@ -1291,6 +1304,8 @@ extension IteratorSequence: IteratorProtocol, Sequence {
   }
 }
 
+extension IteratorSequence: BitwiseCopyable where Base: BitwiseCopyable {}
+
 extension IteratorSequence: Sendable where Base: Sendable { }
 
 /* FIXME: ideally for compatibility we would declare

stdlib/public/core/Slice.swift

@@ -529,5 +529,8 @@ extension Slice
   }
 }
 
+extension Slice: BitwiseCopyable
+where Base: BitwiseCopyable, Base.Index: BitwiseCopyable {}
+
 extension Slice: Sendable
 where Base: Sendable, Base.Index: Sendable { }

stdlib/public/core/Stride.swift

@@ -742,6 +742,15 @@ public func stride<T>(
   return StrideThrough(_start: start, end: end, stride: stride)
 }
 
+extension StrideToIterator: BitwiseCopyable
+  where Element: BitwiseCopyable, Element.Stride: BitwiseCopyable { }
+extension StrideTo: BitwiseCopyable
+  where Element: BitwiseCopyable, Element.Stride: BitwiseCopyable { }
+extension StrideThroughIterator: BitwiseCopyable
+  where Element: BitwiseCopyable, Element.Stride: BitwiseCopyable { }
+extension StrideThrough: BitwiseCopyable
+  where Element: BitwiseCopyable, Element.Stride: BitwiseCopyable { }
+
 extension StrideToIterator: Sendable
   where Element: Sendable, Element.Stride: Sendable { }
 extension StrideTo: Sendable

stdlib/public/core/UnicodeParser.swift

@@ -60,4 +60,6 @@ extension Unicode {
   public typealias Parser = _UnicodeParser
 }
 
+extension Unicode.ParseResult: BitwiseCopyable where T: BitwiseCopyable {}
+
 extension Unicode.ParseResult: Sendable where T: Sendable { }

stdlib/public/core/Zip.swift

@@ -154,6 +154,12 @@ extension Zip2Sequence: Sequence {
   }
 }
 
+extension Zip2Sequence: BitwiseCopyable where Sequence1: BitwiseCopyable,
+                                              Sequence2: BitwiseCopyable { }
+extension Zip2Sequence.Iterator: BitwiseCopyable
+  where Sequence1.Iterator: BitwiseCopyable,
+        Sequence2.Iterator: BitwiseCopyable { }
+
 extension Zip2Sequence: Sendable where Sequence1: Sendable,
                                        Sequence2: Sendable { }
 extension Zip2Sequence.Iterator: Sendable where Sequence1.Iterator: Sendable,