[cxx-interop] Add span accessors to std.string variants

rdar://146944876

Author: Gabor Horvath

Runtimes/Overlay/Cxx/CMakeLists.txt

@@ -34,7 +34,7 @@ target_compile_options(swiftCxx PRIVATE
   "$<$<COMPILE_LANGUAGE:Swift>:SHELL:-Xcc -nostdinc++>"
   "$<$<COMPILE_LANGUAGE:Swift>:SHELL:-enable-experimental-feature AllowUnsafeAttribute>"
   "$<$<COMPILE_LANGUAGE:Swift>:SHELL:-enable-experimental-feature BuiltinModule>"
-  "$<$<COMPILE_LANGUAGE:Swift>:SHELL:-enable-experimental-feature Span>")
+  "$<$<COMPILE_LANGUAGE:Swift>:SHELL:-enable-experimental-feature Lifetimes>")
 target_link_libraries(swiftCxx PRIVATE
   swiftCore)
 

Runtimes/Overlay/Cxx/std/CMakeLists.txt

@@ -9,6 +9,7 @@ target_compile_options(swiftCxxStdlib PRIVATE
   "-strict-memory-safety"
   "-cxx-interoperability-mode=default"
   "SHELL:-enable-experimental-feature AllowUnsafeAttribute"
+  "SHELL:-enable-experimental-feature Lifetimes"
   # This flag is unnecessary when building with newer compilers that allow using
   # C++ symbols in resilient overlays (see f4204568).
   "SHELL:-enable-experimental-feature AssumeResilientCxxTypes"

stdlib/public/Cxx/CMakeLists.txt

@@ -21,9 +21,9 @@ add_swift_target_library(swiftCxx STATIC NO_LINK_NAME IS_STDLIB IS_SWIFT_ONLY
 
     SWIFT_COMPILE_FLAGS ${SWIFT_RUNTIME_SWIFT_COMPILE_FLAGS} ${SWIFT_STANDARD_LIBRARY_SWIFT_FLAGS}
     -cxx-interoperability-mode=default
-    -enable-experimental-feature Span
     -enable-experimental-feature BuiltinModule
     -enable-experimental-feature AllowUnsafeAttribute
+    -enable-experimental-feature Lifetimes
     -strict-memory-safety
     # This module should not pull in the C++ standard library, so we disable it explicitly.
     # For functionality that depends on the C++ stdlib, use C++ stdlib overlay (`swiftstd` module).

stdlib/public/Cxx/std/CMakeLists.txt

@@ -44,7 +44,7 @@ add_swift_target_library(swiftCxxStdlib STATIC NO_LINK_NAME IS_STDLIB IS_SWIFT_O
     # This flag is unnecessary when building with newer compilers that allow
     # using C++ symbols in resilient overlays (see f4204568).
     -enable-experimental-feature AssumeResilientCxxTypes
-
+    -enable-experimental-feature Lifetimes
     -enable-experimental-feature AllowUnsafeAttribute
     -strict-memory-safety
 

stdlib/public/Cxx/std/String.swift

@@ -60,7 +60,7 @@ extension std.string {
       self.init()
       return
     }
-    self.init(str)
+    unsafe self.init(str)
   }
 }
 
@@ -403,3 +403,62 @@ extension String {
     unsafe withExtendedLifetime(cxxU32StringView) {}
   }
 }
+
+@available(SwiftCompatibilitySpan 5.0, *)
+extension std.string {
+  public var span: Span<CChar> {
+    @_lifetime(borrow self)
+    @_alwaysEmitIntoClient
+    borrowing get {
+      let buffer = unsafe UnsafeBufferPointer(start: self.__dataUnsafe(), count: Int(self.size()))
+      let span = unsafe Span(_unsafeElements: buffer)
+      return unsafe _cxxOverrideLifetime(span, borrowing: self)
+    }
+  }
+}
+
+@available(SwiftStdlib 6.2, *)
+extension std.string {
+  public var utf8Span: UTF8Span? {
+    @_lifetime(borrow self)
+    @_alwaysEmitIntoClient
+    borrowing get {
+      let buffer = unsafe UnsafeBufferPointer(start: self.__dataUnsafe(), count: Int(self.size()))
+      let rawBuffer = UnsafeRawBufferPointer(buffer)
+      let bufferWithFixedType = unsafe rawBuffer.assumingMemoryBound(to: UInt8.self)
+      let span = unsafe Span(_unsafeElements: bufferWithFixedType)
+      let spanWithFixedLifetime = unsafe _cxxOverrideLifetime(span, borrowing: self)
+      return try? UTF8Span(validating: spanWithFixedLifetime)
+    }
+  }
+}
+
+@available(SwiftCompatibilitySpan 5.0, *)
+extension std.u16string {
+  public var span: Span<UInt16> {
+    @_lifetime(borrow self)
+    @_alwaysEmitIntoClient
+    borrowing get {
+      let buffer = unsafe UnsafeBufferPointer(start: self.__dataUnsafe(), count: Int(self.size()))
+      let rawBuffer = UnsafeRawBufferPointer(buffer)
+      let bufferWithFixedType = unsafe rawBuffer.assumingMemoryBound(to: UInt16.self)
+      let span = unsafe Span(_unsafeElements: bufferWithFixedType)
+      return unsafe _cxxOverrideLifetime(span, borrowing: self)
+    }
+  }
+}
+
+@available(SwiftCompatibilitySpan 5.0, *)
+extension std.u32string {
+  public var span: Span<UInt32> {
+    @_lifetime(borrow self)
+    @_alwaysEmitIntoClient
+    borrowing get {
+      let buffer = unsafe UnsafeBufferPointer(start: self.__dataUnsafe(), count: Int(self.size()))
+      let rawBuffer = UnsafeRawBufferPointer(buffer)
+      let bufferWithFixedType = unsafe rawBuffer.assumingMemoryBound(to: UInt32.self)
+      let span = unsafe Span(_unsafeElements: bufferWithFixedType)
+      return unsafe _cxxOverrideLifetime(span, borrowing: self)
+    }
+  }
+}

test/Interop/Cxx/stdlib/use-std-string.swift

@@ -507,4 +507,47 @@ StdStringTestSuite.test("pass as a default argument") {
 }
 #endif
 
+StdStringTestSuite.test("std.string to span").require(.stdlib_6_2).code {
+    guard #available(SwiftStdlib 6.2, *) else { return }
+
+    let s = std.string("abc")
+    // FIXME: remove once borrow checking is fixed.
+    withExtendedLifetime(s) {
+        let span = s.span
+        expectEqual(span.count, 3)
+        expectFalse(span.isEmpty)
+        expectEqual(span[0], 97)
+        expectEqual(span[1], 98)
+        expectEqual(span[2], 99)
+
+        let utfspan = s.utf8Span!
+        let str = String(copying: utfspan)
+        expectEqual(str, "abc")
+    }
+
+    let scalars: [UInt16] = [97, 55296, 99]
+    var s_16 = std.u16string()
+    for scalar: UInt16 in scalars {
+        s_16.push_back(scalar)
+    }
+    // FIXME: remove once borrow checking is fixed.
+    withExtendedLifetime(s_16) {
+        let span_16 = s_16.span
+        expectEqual(span_16.count, 3)
+        expectFalse(span_16.isEmpty)
+        for (n, c) in scalars.enumerated() {
+            expectEqual(span_16[n], c)
+        }
+    }
+
+    let s_32 = std.u32string("abc")
+    // FIXME: remove once borrow checking is fixed.
+    withExtendedLifetime(s_32) {
+        let span_32 = s_32.span
+        for (n, c) in "abc".enumerated() {
+            expectEqual(span_32[n], UInt32(c.asciiValue!))
+        }
+    }
+}
+
 runAllTests()