[cxx-interop] Explicit conversions between Swift and C++ spans

A first step towards creating safe overloads for C++ APIs using span
(rdar://139074571).

Note that we need to mark span as owned because it the libc++
implementation was mistakenly recognized as owned and might now rely on
span methods like `data` being renamed as `__dataUnsafe`. We will change
it under a new interop version. But for the time being, we want
consistent behavior across stdlib versions.

Author: Gabor Horvath

stdlib/public/Cxx/CMakeLists.txt

@@ -21,6 +21,8 @@ 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
     # 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).
     -Xcc -nostdinc++

stdlib/public/Cxx/CxxSpan.swift

@@ -9,6 +9,14 @@
 // See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
 //
 //===----------------------------------------------------------------------===//
+import Builtin
+
+@usableFromInline
+internal func unsafeBitCast<T: ~Escapable, U>(
+   _ x: T, to type: U.Type
+) -> U {
+  Builtin.reinterpretCast(x)
+}
 
 /// A C++ type that is an object that can refer to a contiguous sequence of objects.
 ///
@@ -19,6 +27,9 @@ public protocol CxxSpan<Element> {
 
   init()
   init(_ unsafePointer : UnsafePointer<Element>, _ count: Size)
+
+  func size() -> Size
+  func __dataUnsafe() -> UnsafePointer<Element>?
 }
 
 extension CxxSpan {
@@ -36,6 +47,28 @@ extension CxxSpan {
                   "UnsafeMutableBufferPointer should not point to nil")
     self.init(unsafeMutableBufferPointer.baseAddress!, Size(unsafeMutableBufferPointer.count))
   }
+
+  @available(SwiftStdlib 6.1, *)
+  @inlinable
+  @unsafe
+  public init(_ span: Span<Element>) {
+    let (p, c) = unsafeBitCast(span, to: (UnsafeRawPointer?, Int).self)
+    precondition(p != nil, "Span should not point to nil")
+    let binding = p!.bindMemory(to: Element.self, capacity: c)
+    self.init(binding, Size(c))
+  }
+}
+
+@available(SwiftStdlib 6.1, *)
+extension Span {
+  @_alwaysEmitIntoClient
+  @lifetime(immortal)
+  @unsafe
+  public init<T: CxxSpan<Element>>(
+    _unsafeCxxSpan span: T,
+  ) {
+    self.init(_unsafeElements: .init(start: span.__dataUnsafe(), count: Int(span.size())))
+  }
 }
 
 public protocol CxxMutableSpan<Element> {

stdlib/public/Cxx/std/std.apinotes

@@ -13,3 +13,7 @@ Namespaces:
     SwiftImportAs: owned
   - Name: vector
     SwiftImportAs: owned
+  - Name: span
+    Methods:
+    - Name: data
+      SwiftName: __dataUnsafe()

test/Interop/Cxx/stdlib/Inputs/std-span.h

@@ -5,53 +5,51 @@
 #include <string>
 #include <span>
 
-using ConstSpan = std::span<const int>;
-using Span = std::span<int>;
+using ConstSpanOfInt = std::span<const int>;
+using SpanOfInt = std::span<int>;
 using ConstSpanOfString = std::span<const std::string>;
 using SpanOfString = std::span<std::string>;
 
 static int iarray[]{1, 2, 3};
 static std::string sarray[]{"", "ab", "abc"};
-static ConstSpan icspan = {iarray};
-static Span ispan = {iarray};
+static ConstSpanOfInt icspan = {iarray};
+static SpanOfInt ispan = {iarray};
 static ConstSpanOfString scspan = {sarray};
 static SpanOfString sspan = {sarray};
 
 struct SpanBox {
-  ConstSpan icspan;
-  Span ispan;
+  ConstSpanOfInt icspan;
+  SpanOfInt ispan;
   ConstSpanOfString scspan;
   SpanOfString sspan;
 };
 
 class CppApi {
 public:
-  ConstSpan getConstSpan();
-  Span getSpan();
+  ConstSpanOfInt getConstSpan();
+  SpanOfInt getSpan();
 };
 
-ConstSpan CppApi::getConstSpan() {
-  ConstSpan sp{new int[2], 2};
+ConstSpanOfInt CppApi::getConstSpan() {
+  ConstSpanOfInt sp{new int[2], 2};
   return sp;
 }
 
-Span CppApi::getSpan() {
-  Span sp{new int[2], 2};
+SpanOfInt CppApi::getSpan() {
+  SpanOfInt sp{new int[2], 2};
   return sp;
 }
 
-inline ConstSpan initConstSpan() {
-  const int a[]{1, 2, 3};
-  return ConstSpan(a);
+inline ConstSpanOfInt initConstSpan() {
+  return ConstSpanOfInt(iarray);
 }
 
-inline Span initSpan() {
-  int a[]{1, 2, 3};
-  return Span(a);
+inline SpanOfInt initSpan() {
+  return SpanOfInt(iarray);
 }
 
-inline Span initSpan(int arr[], size_t size) {
-  return Span(arr, size);
+inline SpanOfInt initSpan(int arr[], size_t size) {
+  return SpanOfInt(arr, size);
 }
 
 inline struct SpanBox getStructSpanBox() { return {iarray, iarray, sarray, sarray}; }

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

@@ -7,7 +7,7 @@ import StdSpan
 
 let arr: [Int32] = [1, 2, 3]
 arr.withUnsafeBufferPointer { ubpointer in
-    let _ = ConstSpan(ubpointer) // okay
-    let _ = ConstSpan(ubpointer.baseAddress!, ubpointer.count) 
+    let _ = ConstSpanOfInt(ubpointer) // okay
+    let _ = ConstSpanOfInt(ubpointer.baseAddress!, ubpointer.count) 
     // expected-warning@-1 {{'init(_:_:)' is deprecated: use 'init(_:)' instead.}}
 }