Merge pull request swiftlang#78561 from glessard/rdar137710901-span-properties-prototype

[SE-0456] Span properties (part 1)

Author: glessard

Runtimes/Core/cmake/modules/ExperimentalFeatures.cmake

@@ -10,5 +10,4 @@ add_compile_options(
   "$<$<COMPILE_LANGUAGE:Swift>:SHELL:-enable-experimental-feature FreestandingMacros>"
   "$<$<COMPILE_LANGUAGE:Swift>:SHELL:-enable-experimental-feature BitwiseCopyable>"
   "$<$<COMPILE_LANGUAGE:Swift>:SHELL:-enable-experimental-feature Extern>"
-  "$<$<COMPILE_LANGUAGE:Swift>:SHELL:-enable-experimental-feature ValueGenerics>"
-  "$<$<COMPILE_LANGUAGE:Swift>:SHELL:-enable-experimental-feature AddressableParameters>")
+  "$<$<COMPILE_LANGUAGE:Swift>:SHELL:-enable-experimental-feature ValueGenerics>")

Runtimes/Core/core/CMakeLists.txt

@@ -279,6 +279,8 @@ target_compile_options(swiftCore PRIVATE
   # STAGING: Temporarily avoids having to write #fileID in Swift.swiftinterface.
   # see also 327ea8bce2d1107a847d444651b19ca6a2901c9e
   "$<$<COMPILE_LANGUAGE:Swift>:SHELL:-Xfrontend -enable-experimental-concise-pound-file>"
+  "$<$<COMPILE_LANGUAGE:Swift>:SHELL:-enable-experimental-feature AddressableParameters>"
+  "$<$<COMPILE_LANGUAGE:Swift>:SHELL:-enable-experimental-feature AddressableTypes>"
   $<$<COMPILE_LANGUAGE:Swift>:-parse-stdlib>
   $<$<COMPILE_LANGUAGE:Swift>:-nostdimport>
   $<$<COMPILE_LANGUAGE:Swift>:-explicit-module-build>

stdlib/public/core/Array.swift

@@ -2,7 +2,7 @@
 //
 // This source file is part of the Swift.org open source project
 //
-// Copyright (c) 2014 - 2018 Apple Inc. and the Swift project authors
+// Copyright (c) 2014 - 2025 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
@@ -1427,6 +1427,25 @@ extension Array: RangeReplaceableCollection {
       return try unsafe body(bufferPointer)
     }
   }
+  
+  @available(SwiftStdlib 6.2, *)
+  public var span: Span<Element> {
+    @lifetime(borrow self)
+    @_alwaysEmitIntoClient
+    borrowing get {
+#if _runtime(_ObjC)
+      if _slowPath(!_buffer._isNative) {
+        let buffer = _buffer.getOrAllocateAssociatedObjectBuffer()
+        let (pointer, count) = unsafe (buffer.firstElementAddress, buffer.count)
+        let span = unsafe Span(_unsafeStart: pointer, count: count)
+        return unsafe _overrideLifetime(span, borrowing: self)
+      }
+#endif
+      let (pointer, count) = unsafe (_buffer.firstElementAddress, _buffer.count)
+      let span = unsafe Span(_unsafeStart: pointer, count: count)
+      return unsafe _overrideLifetime(span, borrowing: self)
+    }
+  }
 
   @inlinable
   public __consuming func _copyToContiguousArray() -> ContiguousArray<Element> {

stdlib/public/core/ArrayBuffer.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 - 2025 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
@@ -608,11 +608,10 @@ extension _ArrayBuffer {
       1 //OBJC_ASSOCIATION_RETAIN_NONATOMIC
     )
   }
-  
-  @_alwaysEmitIntoClient @inline(never)
-  internal func withUnsafeBufferPointer_nonNative<R, E>(
-    _ body: (UnsafeBufferPointer<Element>) throws(E) -> R
-  ) throws(E) -> R {
+
+  @_alwaysEmitIntoClient
+  internal func getOrAllocateAssociatedObjectBuffer(
+  ) -> _ContiguousArrayBuffer<Element> {
     let unwrapped: _ContiguousArrayBuffer<Element>
     // libobjc already provides the necessary memory barriers for
     // double checked locking to be safe, per comments on
@@ -633,12 +632,16 @@ extension _ArrayBuffer {
       defer { _fixLifetime(unwrapped) }
       objc_sync_exit(lock)
     }
-    return try unsafe body(
-      UnsafeBufferPointer(
-        start: unwrapped.firstElementAddress,
-        count: unwrapped.count
-      )
-    )
+    return unwrapped
+  }
+
+  @_alwaysEmitIntoClient @inline(never)
+  internal func withUnsafeBufferPointer_nonNative<R, E>(
+    _ body: (UnsafeBufferPointer<Element>) throws(E) -> R
+  ) throws(E) -> R {
+    let buffer = getOrAllocateAssociatedObjectBuffer()
+    let (pointer, count) = unsafe (buffer.firstElementAddress, buffer.count)
+    return try unsafe body(UnsafeBufferPointer(start: pointer,  count: count))
   }
 
   /// Call `body(p)`, where `p` is an `UnsafeBufferPointer` over the

stdlib/public/core/ArraySlice.swift

@@ -2,7 +2,7 @@
 //
 // This source file is part of the Swift.org open source project
 //
-// Copyright (c) 2014 - 2018 Apple Inc. and the Swift project authors
+// Copyright (c) 2014 - 2025 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
@@ -1116,6 +1116,17 @@ extension ArraySlice: RangeReplaceableCollection {
     }
   }
 
+  @available(SwiftStdlib 6.2, *)
+  public var span: Span<Element> {
+    @lifetime(borrow self)
+    @_alwaysEmitIntoClient
+    borrowing get {
+      let (pointer, count) = (_buffer.firstElementAddress, _buffer.count)
+      let span = unsafe Span(_unsafeStart: pointer, count: count)
+      return unsafe _overrideLifetime(span, borrowing: self)
+    }
+  }
+
   @inlinable
   public __consuming func _copyToContiguousArray() -> ContiguousArray<Element> {
     if let n = _buffer.requestNativeBuffer() {

stdlib/public/core/CollectionOfOne.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 - 2025 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
@@ -22,6 +22,7 @@
 ///     let b = a + CollectionOfOne(toAdd)
 ///     // b == [1, 2, 3, 4, 100]
 @frozen // trivial-implementation
+@_addressableForDependencies
 public struct CollectionOfOne<Element> {
   @usableFromInline // trivial-implementation
   internal var _element: Element
@@ -158,6 +159,21 @@ extension CollectionOfOne: RandomAccessCollection, MutableCollection {
   }
 }
 
+extension CollectionOfOne {
+
+  @available(SwiftStdlib 6.2, *)
+  public var span: Span<Element> {
+    @lifetime(borrow self)
+    @_alwaysEmitIntoClient
+    get {
+      let pointer = unsafe UnsafePointer<Element>(Builtin.addressOfBorrow(self))
+      let span = unsafe Span(_unsafeStart: pointer, count: 1)
+      fatalError("Span over CollectionOfOne is not supported yet.")
+      return unsafe _overrideLifetime(span, borrowing: self)
+    }
+  }
+}
+
 @_unavailableInEmbedded
 extension CollectionOfOne: CustomDebugStringConvertible {
   /// A textual representation of the collection, suitable for debugging.

stdlib/public/core/ContiguousArray.swift

@@ -2,7 +2,7 @@
 //
 // This source file is part of the Swift.org open source project
 //
-// Copyright (c) 2014 - 2018 Apple Inc. and the Swift project authors
+// Copyright (c) 2014 - 2025 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
@@ -1021,6 +1021,17 @@ extension ContiguousArray: RangeReplaceableCollection {
     }
   }
 
+  @available(SwiftStdlib 6.2, *)
+  public var span: Span<Element> {
+    @lifetime(borrow self)
+    @_alwaysEmitIntoClient
+    borrowing get {
+      let (pointer, count) = unsafe (_buffer.firstElementAddress, _buffer.count)
+      let span = unsafe Span(_unsafeStart: pointer, count: count)
+      return unsafe _overrideLifetime(span, borrowing: self)
+    }
+  }
+
   @inlinable
   public __consuming func _copyToContiguousArray() -> ContiguousArray<Element> {
     if let n = _buffer.requestNativeBuffer() {

stdlib/public/core/InlineArray.swift

@@ -43,6 +43,7 @@
 @available(SwiftStdlib 6.2, *)
 @frozen
 @safe
+@_addressableForDependencies
 public struct InlineArray<let count: Int, Element: ~Copyable>: ~Copyable {
   @usableFromInline
   internal let _storage: Builtin.FixedArray<count, Element>
@@ -455,6 +456,26 @@ extension InlineArray where Element: ~Copyable {
   }
 }
 
+//===----------------------------------------------------------------------===//
+// MARK: Span
+//===----------------------------------------------------------------------===//
+
+@available(SwiftStdlib 6.2, *)
+extension InlineArray where Element: ~Copyable {
+
+  @available(SwiftStdlib 6.2, *)
+  public var span: Span<Element> {
+    @lifetime(borrow self)
+    @_alwaysEmitIntoClient
+    borrowing get {
+      let pointer = _address
+      let span = unsafe Span(_unsafeStart: pointer, count: count)
+      fatalError("Span over InlineArray is not supported yet.")
+      return unsafe _overrideLifetime(span, borrowing: self)
+    }
+  }
+}
+
 //===----------------------------------------------------------------------===//
 // MARK: - Unsafe APIs
 //===----------------------------------------------------------------------===//

stdlib/public/core/KeyValuePairs.swift

@@ -2,7 +2,7 @@
 //
 // This source file is part of the Swift.org open source project
 //
-// Copyright (c) 2014 - 2018 Apple Inc. and the Swift project authors
+// Copyright (c) 2014 - 2025 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
@@ -125,6 +125,23 @@ extension KeyValuePairs: RandomAccessCollection {
   }
 }
 
+extension KeyValuePairs {
+  
+  @available(SwiftStdlib 6.2, *)
+  public var span: Span<Element> {
+    @lifetime(borrow self)
+    @_alwaysEmitIntoClient
+    get {
+      let rp = unsafe UnsafeRawPointer(_elements._buffer.firstElementAddress)
+      let span = unsafe Span(
+        _unsafeStart: unsafe rp.assumingMemoryBound(to: Element.self),
+        count: _elements.count
+      )
+      return unsafe _overrideLifetime(span, borrowing: self)
+    }
+  }
+}
+
 @_unavailableInEmbedded
 extension KeyValuePairs: CustomStringConvertible {
   /// A string that represents the contents of the dictionary.

stdlib/public/core/Span/RawSpan.swift

@@ -32,6 +32,7 @@ public struct RawSpan: ~Escapable, Copyable, BitwiseCopyable {
   @usableFromInline
   internal let _pointer: UnsafeRawPointer?
 
+  @unsafe
   @_alwaysEmitIntoClient
   internal func _start() -> UnsafeRawPointer {
     unsafe _pointer._unsafelyUnwrappedUnchecked
@@ -307,14 +308,17 @@ extension RawSpan {
   ///   - span: An existing `Span<T>`, which will define both this
   ///           `RawSpan`'s lifetime and the memory it represents.
   @_alwaysEmitIntoClient
-  @lifetime(borrow span)
+  @lifetime(copy span)
   public init<Element: BitwiseCopyable>(
-    _elements span: borrowing Span<Element>
+    _elements span: Span<Element>
   ) {
-    unsafe self.init(
-      _unchecked: span._pointer,
-      byteCount: span.count &* MemoryLayout<Element>.stride
+    let pointer = span._pointer
+    let rawSpan = unsafe RawSpan(
+      _unchecked: pointer,
+      byteCount: span.count == 1 ? MemoryLayout<Element>.size
+                 : span.count &* MemoryLayout<Element>.stride
     )
+    self = unsafe _overrideLifetime(rawSpan, copying: span)
   }
 }
 
@@ -661,7 +665,7 @@ extension RawSpan {
     guard let spanStart = other._pointer, _count > 0 else {
       return unsafe _pointer == other._pointer ? 0..<0 : nil
     }
-    let start = _start()
+    let start = unsafe _start()
     let spanEnd = unsafe spanStart + other._count
     if unsafe spanStart < start || (start + _count) < spanEnd { return nil }
     let lower = unsafe start.distance(to: spanStart)