Merge pull request #80116 from glessard/rdar137710901-utf8view-span-notsmol

[SE-0456] Span properties over utf8 views

Author: glessard

stdlib/public/core/StringGuts.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
@@ -417,6 +417,93 @@ extension _StringGuts {
   }
 }
 
+#if _runtime(_ObjC)
+extension _StringGuts {
+
+  private static var _associationKey: UnsafeRawPointer {
+    struct AssociationKey {}
+    // We never dereference this, we only use this address as a unique key
+    return unsafe unsafeBitCast(
+      ObjectIdentifier(AssociationKey.self),
+      to: UnsafeRawPointer.self
+    )
+  }
+
+  private func _getAssociatedStorage() -> __StringStorage? {
+    _internalInvariant(_object.hasObjCBridgeableObject)
+    let getter = unsafe unsafeBitCast(
+      getGetAssociatedObjectPtr(),
+      to: (@convention(c)(
+        AnyObject,
+        UnsafeRawPointer
+      ) -> UnsafeRawPointer?).self
+    )
+
+    if let assocPtr = unsafe getter(
+      _object.objCBridgeableObject,
+      Self._associationKey
+    ) {
+      let storage: __StringStorage
+      storage = unsafe Unmanaged.fromOpaque(assocPtr).takeUnretainedValue()
+      return storage
+    }
+    return nil
+  }
+
+  private func _setAssociatedStorage(_ storage: __StringStorage) {
+    _internalInvariant(_object.hasObjCBridgeableObject)
+    let setter = unsafe unsafeBitCast(
+      getSetAssociatedObjectPtr(),
+      to: (@convention(c)(
+        AnyObject,
+        UnsafeRawPointer,
+        AnyObject?,
+        UInt
+      ) -> Void).self
+    )
+
+    unsafe setter(
+      _object.objCBridgeableObject,
+      Self._associationKey,
+      storage,
+      1 //OBJC_ASSOCIATION_RETAIN_NONATOMIC
+    )
+  }
+
+  internal func _getOrAllocateAssociatedStorage() -> __StringStorage {
+    _internalInvariant(_object.hasObjCBridgeableObject)
+    let unwrapped: __StringStorage
+    // libobjc already provides the necessary memory barriers for
+    // double checked locking to be safe, per comments on
+    // https://github.com/swiftlang/swift/pull/75148
+    if let storage = _getAssociatedStorage() {
+      unwrapped = storage
+    } else {
+      let lock = _object.objCBridgeableObject
+      objc_sync_enter(lock)
+      if let storage  = _getAssociatedStorage() {
+        unwrapped = storage
+      } else {
+        var contents = String.UnicodeScalarView()
+        // always reserve a capacity larger than a small string
+        contents.reserveCapacity(
+          Swift.max(_SmallString.capacity + 1, count + count >> 1)
+        )
+        for c in String.UnicodeScalarView(self) {
+          contents.append(c)
+        }
+        _precondition(contents._guts._object.hasNativeStorage)
+        unwrapped = (consume contents)._guts._object.nativeStorage
+        _setAssociatedStorage(unwrapped)
+      }
+      defer { _fixLifetime(unwrapped) }
+      objc_sync_exit(lock)
+    }
+    return unwrapped
+  }
+}
+#endif
+
 // Old SPI(corelibs-foundation)
 extension _StringGuts {
   public // SPI(corelibs-foundation)

stdlib/public/core/StringUTF8View.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
@@ -317,6 +317,49 @@ extension String.UTF8View {
   }
 }
 
+extension String.UTF8View {
+
+  /// A span over the UTF8 code units that make up this string.
+  ///
+  /// - Note: In the case of bridged UTF16 String instances (on Apple
+  /// platforms,) this property transcodes the code units the first time
+  /// it is called. The transcoded buffer is cached, and subsequent calls
+  /// to `span` can reuse the buffer.
+  ///
+  ///  Returns: a `Span` over the UTF8 code units of this String.
+  ///
+  ///  Complexity: O(1) for native UTF8 Strings,
+  ///  amortized O(1) for bridged UTF16 Strings.
+  @available(SwiftStdlib 6.2, *)
+  public var span: Span<UTF8.CodeUnit> {
+    @lifetime(borrow self)
+    borrowing get {
+#if _runtime(_ObjC)
+      // handle non-UTF8 Objective-C bridging cases here
+      if !_guts.isFastUTF8 && _guts._object.hasObjCBridgeableObject {
+        let storage = _guts._getOrAllocateAssociatedStorage()
+        let (start, count) = unsafe (storage.start, storage.count)
+        let span = unsafe Span(_unsafeStart: start, count: count)
+        return unsafe _overrideLifetime(span, borrowing: self)
+      }
+#endif
+      let count = _guts.count
+      if _guts.isSmall {
+        let a = Builtin.addressOfBorrow(self)
+        let address = unsafe UnsafePointer<UTF8.CodeUnit>(a)
+        let span = unsafe Span(_unsafeStart: address, count: count)
+        fatalError("Span over the small string form is not supported yet.")
+        return unsafe _overrideLifetime(span, borrowing: self)
+      }
+      _precondition(_guts.isFastUTF8)
+      let buffer = unsafe _guts._object.fastUTF8
+      _internalInvariant(count == buffer.count)
+      let span = unsafe Span(_unsafeElements: buffer)
+      return unsafe _overrideLifetime(span, borrowing: self)
+    }
+  }
+}
+
 // Index conversions
 extension String.UTF8View.Index {
   /// Creates an index in the given UTF-8 view that corresponds exactly to the

stdlib/public/core/Substring.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
@@ -749,6 +749,61 @@ extension Substring.UTF8View: BidirectionalCollection {
   }
 }
 
+extension Substring.UTF8View {
+
+  /// A span over the UTF8 code units that make up this substring.
+  ///
+  /// - Note: In the case of bridged UTF16 String instances (on Apple
+  /// platforms,) this property needs to transcode the code units every time
+  /// it is called.
+  /// For example, if `string` has the bridged UTF16 representation,
+  ///     for word in string.split(separator: " ") {
+  ///         useSpan(word.span)
+  ///     }
+  ///  is accidentally quadratic because of this issue. A workaround is to
+  ///  explicitly convert the string into its native UTF8 representation:
+  ///      var nativeString = consume string
+  ///      nativeString.makeContiguousUTF8()
+  ///      for word in nativeString.split(separator: " ") {
+  ///          useSpan(word.span)
+  ///      }
+  ///  This second option has linear time complexity, as expected.
+  ///
+  ///  Returns: a `Span` over the UTF8 code units of this Substring.
+  ///
+  ///  Complexity: O(1) for native UTF8 Strings, O(n) for bridged UTF16 Strings.
+  @available(SwiftStdlib 6.2, *)
+  public var span: Span<UTF8.CodeUnit> {
+    @lifetime(borrow self)
+    borrowing get {
+#if _runtime(_ObjC)
+      // handle non-UTF8 Objective-C bridging cases here
+      if !_wholeGuts.isFastUTF8 && _wholeGuts._object.hasObjCBridgeableObject {
+        let base: String.UTF8View = self._base
+        let first = base._foreignDistance(from: base.startIndex, to: startIndex)
+        let count = base._foreignDistance(from: startIndex, to: endIndex)
+        let span = unsafe base.span._extracting(first..<(first &+ count))
+        return unsafe _overrideLifetime(span, borrowing: self)
+      }
+#endif
+      let first = _slice._startIndex._encodedOffset
+      let end = _slice._endIndex._encodedOffset
+      if _wholeGuts.isSmall {
+        let a = Builtin.addressOfBorrow(self)
+        let offset = first &+ (2 &* MemoryLayout<String.Index>.stride)
+        let start = unsafe UnsafePointer<UTF8.CodeUnit>(a).advanced(by: offset)
+        let span = unsafe Span(_unsafeStart: start, count: end &- first)
+        fatalError("Span over the small string form is not supported yet.")
+        return unsafe _overrideLifetime(span, borrowing: self)
+      }
+      _internalInvariant(_wholeGuts.isFastUTF8)
+      var span = unsafe Span(_unsafeElements: _wholeGuts._object.fastUTF8)
+      span = span._extracting(first..<end)
+      return unsafe _overrideLifetime(span, borrowing: self)
+    }
+  }
+}
+
 extension Substring {
   @inlinable
   public var utf8: UTF8View {

test/abi/macOS/arm64/stdlib.swift

@@ -837,6 +837,10 @@ Added: _$ss13KeyValuePairsV4spans4SpanVyx3key_q_5valuetGvpMV
 Added: _$ss15CollectionOfOneV4spans4SpanVyxGvpMV
 Added: _$ss15ContiguousArrayV4spans4SpanVyxGvpMV
 Added: _$ss4SpanVss15BitwiseCopyableRzlE5bytess03RawA0VvpMV
+Added: _$sSS8UTF8ViewV4spans4SpanVys5UInt8VGvg
+Added: _$sSS8UTF8ViewV4spans4SpanVys5UInt8VGvpMV
+Added: _$sSs8UTF8ViewV4spans4SpanVys5UInt8VGvg
+Added: _$sSs8UTF8ViewV4spans4SpanVys5UInt8VGvpMV
 
 // SE-0467 mutableSpan properties
 Added: _$sSa11mutableSpans07MutableB0VyxGvr

test/abi/macOS/x86_64/stdlib.swift

@@ -838,6 +838,10 @@ Added: _$ss13KeyValuePairsV4spans4SpanVyx3key_q_5valuetGvpMV
 Added: _$ss15CollectionOfOneV4spans4SpanVyxGvpMV
 Added: _$ss15ContiguousArrayV4spans4SpanVyxGvpMV
 Added: _$ss4SpanVss15BitwiseCopyableRzlE5bytess03RawA0VvpMV
+Added: _$sSS8UTF8ViewV4spans4SpanVys5UInt8VGvg
+Added: _$sSS8UTF8ViewV4spans4SpanVys5UInt8VGvpMV
+Added: _$sSs8UTF8ViewV4spans4SpanVys5UInt8VGvg
+Added: _$sSs8UTF8ViewV4spans4SpanVys5UInt8VGvpMV
 
 // SE-0467 mutableSpan properties
 Added: _$sSa11mutableSpans07MutableB0VyxGvr

test/stdlib/Span/BridgedStringUTF8ViewSpanTests.swift

@@ -0,0 +1,97 @@
+//===--- BridgedStringSpanTests.swift -------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 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
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+// RUN: %target-run-stdlib-swift -enable-experimental-feature LifetimeDependence
+
+// REQUIRES: executable_test
+// REQUIRES: objc_interop
+// REQUIRES: swift_feature_LifetimeDependence
+
+import StdlibUnittest
+
+import Foundation
+
+var suite = TestSuite("EagerLazyBridging String Tests")
+defer { runAllTests() }
+
+let strings = [
+  "Hello, World!",
+  "A long ASCII string exceeding 16 code units.",
+  "🇯🇵",
+  "🏂☃❅❆❄︎⛄️❄️",
+// Enable the following once the small native string form is supported
+//  "z",
+//  "",
+]
+
+strings.forEach { expected in
+  suite.test("Span from Bridged String Stability: \(expected)")
+  .require(.stdlib_6_2).code {
+    guard #available(SwiftStdlib 6.2, *) else { return }
+
+    let string = NSString(utf8String: expected)
+    guard let string else { expectNotNil(string); return }
+
+    let bridged = String(string).utf8
+    var p: ObjectIdentifier? = nil
+    for (i, j) in zip(0..<3, bridged.indices) {
+      let span = bridged.span
+      let c = span.withUnsafeBufferPointer {
+        let o = unsafeBitCast($0.baseAddress, to: ObjectIdentifier.self)
+        if p == nil {
+          p = o
+        } else {
+          expectEqual(p, o)
+        }
+        return $0[i]
+      }
+      expectEqual(c, bridged[j])
+    }
+  }
+}
+
+strings.forEach { expected in
+  suite.test("Span from Bridged String: \(expected)")
+  .require(.stdlib_6_2).code {
+    guard #available(SwiftStdlib 6.2, *) else { return }
+
+    let string = NSString(utf8String: expected)
+    guard let string else { expectNotNil(string); return }
+
+    let bridged = String(string)
+    let utf8 = bridged.utf8
+    let span = utf8.span
+    expectEqual(span.count, expected.utf8.count)
+    for (i,j) in zip(span.indices, expected.utf8.indices) {
+      expectEqual(span[i], expected.utf8[j])
+    }
+  }
+}
+
+strings.forEach { expected in
+  suite.test("Span from Bridged String Substring: \(expected)")
+  .require(.stdlib_6_2).code {
+    guard #available(SwiftStdlib 6.2, *) else { return }
+
+    let string = NSString(utf8String: expected)
+    guard let string else { expectNotNil(string); return }
+
+    let bridged = String(string).dropFirst()
+    let utf8 = bridged.utf8
+    let span = utf8.span
+    let expected = expected.dropFirst()
+    expectEqual(span.count, expected.utf8.count)
+    for (i,j) in zip(span.indices, expected.utf8.indices) {
+      expectEqual(span[i], expected.utf8[j])
+    }
+  }
+}