Merge pull request #82442 from glessard/rdar147500261-utf8span-32bit

Author: glessard

stdlib/public/core/SmallString.swift

@@ -79,8 +79,11 @@ internal struct _SmallString {
 extension _SmallString {
   @inlinable @inline(__always)
   internal static var capacity: Int {
-#if _pointerBitWidth(_32) || _pointerBitWidth(_16)
+#if _pointerBitWidth(_32) && os(watchOS)
     return 10
+#elseif _pointerBitWidth(_32) || _pointerBitWidth(_16)
+    // Note: changed from 10 for contiguous storage.
+    return 8
 #elseif os(Android) && arch(arm64)
     return 14
 #elseif _pointerBitWidth(_64)
@@ -90,6 +93,15 @@ extension _SmallString {
 #endif
   }
 
+  @_alwaysEmitIntoClient @inline(__always)
+  internal static func contiguousCapacity() -> Int {
+#if _pointerBitWidth(_32) && os(watchOS)
+    return capacity &- 2
+#else
+    return capacity
+#endif
+  }
+
   // Get an integer equivalent to the _StringObject.discriminatedObjectRawBits
   // computed property.
   @inlinable @inline(__always)

stdlib/public/core/StringUTF8View.swift

@@ -317,8 +317,35 @@ extension String.UTF8View {
   }
 }
 
+@available(SwiftStdlib 6.2, *)
 extension String.UTF8View {
 
+  @lifetime(borrow self)
+  internal borrowing func _underlyingSpan() -> Span<UTF8.CodeUnit> {
+#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 // _runtime(_ObjC)
+    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)
+      return unsafe _overrideLifetime(span, borrowing: self)
+    }
+    let isFastUTF8 = _guts.isFastUTF8
+    _precondition(isFastUTF8, "String must be contiguous UTF8")
+    let buffer = unsafe _guts._object.fastUTF8
+    let span = unsafe Span(_unsafeElements: buffer)
+    return unsafe _overrideLifetime(span, borrowing: self)
+  }
+
+#if !(os(watchOS) && _pointerBitWidth(_32))
   /// A span over the UTF8 code units that make up this string.
   ///
   /// - Note: In the case of bridged UTF16 String instances (on Apple
@@ -334,29 +361,61 @@ extension String.UTF8View {
   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)
-        return unsafe _overrideLifetime(span, borrowing: self)
+      _underlyingSpan()
+    }
+  }
+
+  /// 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>? {
+    @_alwaysEmitIntoClient @inline(__always)
+    @lifetime(borrow self)
+    borrowing get {
+      span
+    }
+  }
+#else // !(os(watchOS) && _pointerBitWidth(_32))
+  @available(watchOS, unavailable)
+  public var span: Span<UTF8.CodeUnit> {
+    @lifetime(borrow self)
+    borrowing get {
+      fatalError("\(#function) unavailable on 32-bit watchOS")
+    }
+  }
+
+  /// 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, or `nil`
+  ///           if the String does not have a contiguous representation.
+  ///
+  ///  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 _guts.isSmall, _guts.count > _SmallString.contiguousCapacity() {
+        return nil
       }
-      let isFastUTF8 = _guts.isFastUTF8
-      _precondition(isFastUTF8, "String must be contiguous UTF8")
-      let buffer = unsafe _guts._object.fastUTF8
-      let span = unsafe Span(_unsafeElements: buffer)
-      return unsafe _overrideLifetime(span, borrowing: self)
+      return _underlyingSpan()
     }
   }
+#endif // !(os(watchOS) && _pointerBitWidth(_32))
 }
 
 // Index conversions

stdlib/public/core/Substring.swift

@@ -749,8 +749,38 @@ extension Substring.UTF8View: BidirectionalCollection {
   }
 }
 
+@available(SwiftStdlib 6.2, *)
 extension Substring.UTF8View {
 
+  @lifetime(borrow self)
+  private borrowing func _underlyingSpan() -> Span<UTF8.CodeUnit> {
+#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 = base._underlyingSpan()._extracting(first..<(first &+ count))
+      return unsafe _overrideLifetime(span, borrowing: self)
+    }
+#endif // _runtime(_ObjC)
+    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)
+      return unsafe _overrideLifetime(span, borrowing: self)
+    }
+    let isFastUTF8 = _wholeGuts.isFastUTF8
+    _precondition(isFastUTF8, "Substring must be contiguous UTF8")
+    var span = unsafe Span(_unsafeElements: _wholeGuts._object.fastUTF8)
+    span = span._extracting(first..<end)
+    return unsafe _overrideLifetime(span, borrowing: self)
+  }
+
+#if !(os(watchOS) && _pointerBitWidth(_32))
   /// A span over the UTF8 code units that make up this substring.
   ///
   /// - Note: In the case of bridged UTF16 String instances (on Apple
@@ -776,32 +806,80 @@ extension Substring.UTF8View {
   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 = 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)
-        return unsafe _overrideLifetime(span, borrowing: self)
+      _underlyingSpan()
+    }
+  }
+
+  /// 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>? {
+    @_alwaysEmitIntoClient @inline(__always)
+    @lifetime(borrow self)
+    borrowing get {
+      span
+    }
+  }
+#else // !(os(watchOS) && _pointerBitWidth(_32))
+  @available(watchOS, unavailable)
+  public var span: Span<UTF8.CodeUnit> {
+    fatalError("\(#function) unavailable on 32-bit watchOS")
+  }
+
+  /// 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, or `nil`
+  ///           if the Substring does not have a contiguous representation.
+  ///
+  ///  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 _wholeGuts.isSmall,
+         _wholeGuts.count > _SmallString.contiguousCapacity() {
+        // substring is spannable only when the whole string is spannable.
+        return nil
       }
-      let isFastUTF8 = _wholeGuts.isFastUTF8
-      _precondition(isFastUTF8, "Substring must be contiguous UTF8")
-      var span = unsafe Span(_unsafeElements: _wholeGuts._object.fastUTF8)
-      span = span._extracting(first..<end)
-      return unsafe _overrideLifetime(span, borrowing: self)
+      return _underlyingSpan()
     }
   }
+#endif // !(os(watchOS) && _pointerBitWidth(_32))
 }
 
 extension Substring {