[cxx-interop] Proper conversions between MutableSpan and C++ span

One of the initializers were missing and the other was crashing at
runtime due to a faulty signature in the overlay.

rdar://149846666

Author: Gabor Horvath

stdlib/public/Cxx/CxxSpan.swift

@@ -12,8 +12,8 @@
 import Builtin
 
 @usableFromInline
-internal func unsafeBitCast<T: ~Escapable, U>(
-   _ x: T, to type: U.Type
+internal func unsafeBitCast<T: ~Escapable & ~Copyable, U>(
+   _ x: consuming T, to type: U.Type
 ) -> U {
   Builtin.reinterpretCast(x)
 }
@@ -139,7 +139,7 @@ public protocol CxxMutableSpan<Element> {
   init(_ unsafeMutablePointer : UnsafeMutablePointer<Element>, _ count: Size)
 
   func size() -> Size
-  func __dataUnsafe() -> UnsafeMutablePointer<Element>
+  func __dataUnsafe() -> UnsafeMutablePointer<Element>?
 }
 
 extension CxxMutableSpan {
@@ -150,4 +150,14 @@ extension CxxMutableSpan {
                   "UnsafeMutableBufferPointer should not point to nil")
     unsafe self.init(unsafeMutableBufferPointer.baseAddress!, Size(unsafeMutableBufferPointer.count))
   }
+
+  @available(SwiftStdlib 6.2, *)
+  @inlinable
+  @unsafe
+  public init(_ span: consuming MutableSpan<Element>) {
+    let (p, c) = unsafe unsafeBitCast(span, to: (UnsafeMutableRawPointer?, Int).self)
+    unsafe precondition(p != nil, "Span should not point to nil")
+    let binding = unsafe p!.bindMemory(to: Element.self, capacity: c)
+    unsafe self.init(binding, Size(c))
+  }
 }

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

@@ -687,6 +687,30 @@ StdSpanTestSuite.test("Convert between Swift and C++ span types")
       expectEqual(cxxSpan[2], 3)
     }
   }
+  do {
+    var arr: [Int32] = [1, 2, 3]
+    arr.withUnsafeMutableBufferPointer{ ubpointer in
+      let s = SpanOfInt(ubpointer.baseAddress!, ubpointer.count)
+      let swiftSpan = MutableSpan(_unsafeCxxSpan: s)
+      expectEqual(swiftSpan.count, 3)
+      expectFalse(swiftSpan.isEmpty)
+      expectEqual(swiftSpan[0], 1)
+      expectEqual(swiftSpan[1], 2)
+      expectEqual(swiftSpan[2], 3)
+    }
+  }
+  do {
+    var arr: [Int32] = [1, 2, 3]
+    arr.withUnsafeMutableBufferPointer{ ubpointer in
+      let s = MutableSpan(_unsafeElements: ubpointer)
+      let cxxSpan = SpanOfInt(s)
+      expectEqual(cxxSpan.size(), 3)
+      expectFalse(cxxSpan.empty())
+      expectEqual(cxxSpan[0], 1)
+      expectEqual(cxxSpan[1], 2)
+      expectEqual(cxxSpan[2], 3)
+    }
+  }
 }
 
 runAllTests()