Merge pull request #62992 from apple/egorzhdan/cxx-overlay-improvements

[cxx-interop] Various improvements to the stdlib overlay

Author: egorzhdan

benchmark/cxx-source/CxxStringConversion.swift

@@ -54,7 +54,7 @@ public func run_swiftToCxx(_ n: Int) {
 public func run_cxxToSwift(_ n: Int) {
   let str = cxxString!
   for _ in 0..<n {
-    let x = String(cxxString: str)
+    let x = String(str)
     blackHole(x)
   }
 }

lib/ClangImporter/ClangDerivedConformances.cpp

@@ -500,6 +500,7 @@ void swift::conformToCxxSequenceIfNeeded(
         },
         LookUpConformanceInModule(module));
 
+    impl.addSynthesizedTypealias(decl, ctx.getIdentifier("Element"), pointeeTy);
     impl.addSynthesizedTypealias(decl, ctx.getIdentifier("Index"), indexTy);
     impl.addSynthesizedTypealias(decl, ctx.getIdentifier("Indices"), indicesTy);
     impl.addSynthesizedTypealias(decl, ctx.getIdentifier("SubSequence"),
@@ -516,9 +517,11 @@ void swift::conformToCxxSequenceIfNeeded(
   // copy of the sequence's elements) by conforming the type to
   // CxxCollectionConvertible. This enables an overload of Array.init declared
   // in the Cxx module.
-  if (!conformedToRAC && cxxConvertibleProto)
+  if (!conformedToRAC && cxxConvertibleProto) {
+    impl.addSynthesizedTypealias(decl, ctx.getIdentifier("Element"), pointeeTy);
     impl.addSynthesizedProtocolAttrs(
         decl, {KnownProtocolKind::CxxConvertibleToCollection});
+  }
 }
 
 void swift::conformToCxxSetIfNeeded(ClangImporter::Implementation &impl,

stdlib/public/Cxx/CxxConvertibleToCollection.swift

@@ -11,8 +11,10 @@
 //===----------------------------------------------------------------------===//
 
 /// A C++ type that can be converted to a Swift collection.
-public protocol CxxConvertibleToCollection {
+public protocol CxxConvertibleToCollection<Element> {
+  associatedtype Element
   associatedtype RawIterator: UnsafeCxxInputIterator
+    where RawIterator.Pointee == Element
 
   /// Do not implement this function manually in Swift.
   mutating func __beginUnsafe() -> RawIterator
@@ -21,52 +23,51 @@ public protocol CxxConvertibleToCollection {
   mutating func __endUnsafe() -> RawIterator
 }
 
-@inlinable @inline(__always)
-internal func forEachElement<C: CxxConvertibleToCollection>(
-  of c: C,
-  body: (C.RawIterator.Pointee) -> Void
-) {
-  var mutableC = c
-  withExtendedLifetime(mutableC) {
-    var rawIterator = mutableC.__beginUnsafe()
-    let endIterator = mutableC.__endUnsafe()
+extension CxxConvertibleToCollection {
+  @inlinable
+  internal func forEach(_ body: (RawIterator.Pointee) -> Void) {
+    var mutableSelf = self
+    var rawIterator = mutableSelf.__beginUnsafe()
+    let endIterator = mutableSelf.__endUnsafe()
     while rawIterator != endIterator {
       body(rawIterator.pointee)
       rawIterator = rawIterator.successor()
     }
+    withExtendedLifetime(mutableSelf) {}
   }
 }
 
-extension Array {
-  /// Creates an array containing the elements of a C++ container.
+extension RangeReplaceableCollection {
+  /// Creates a collection containing the elements of a C++ container.
   ///
-  /// This initializes the array by copying every element of the C++ container.
+  /// This initializes the collection by copying every element of the C++
+  /// container.
   ///
   /// - Complexity: O(*n*), where *n* is the number of elements in the C++
   ///   container when each element is copied in O(1). Note that this might not
   ///   be true for certain C++ types, e.g. those with a custom copy
   ///   constructor that performs additional logic.
-  public init<C: CxxConvertibleToCollection>(_ c: C)
+  public init<C: CxxConvertibleToCollection>(_ elements: C)
     where C.RawIterator.Pointee == Element {
 
     self.init()
-    forEachElement(of: c) { self.append($0) }
+    elements.forEach { self.append($0) }
   }
 }
 
-extension Set {
-  /// Creates an set containing the elements of a C++ container.
+extension SetAlgebra {
+  /// Creates a set containing the elements of a C++ container.
   ///
   /// This initializes the set by copying every element of the C++ container.
   ///
   /// - Complexity: O(*n*), where *n* is the number of elements in the C++
   ///   container when each element is copied in O(1). Note that this might not
   ///   be true for certain C++ types, e.g. those with a custom copy
   ///   constructor that performs additional logic.
-  public init<C: CxxConvertibleToCollection>(_ c: C)
+  public init<C: CxxConvertibleToCollection>(_ elements: C)
     where C.RawIterator.Pointee == Element {
 
     self.init()
-    forEachElement(of: c) { self.insert($0) }
+    elements.forEach { self.insert($0) }
   }
 }

stdlib/public/Cxx/CxxRandomAccessCollection.swift

@@ -28,10 +28,11 @@ extension UnsafePointer: UnsafeCxxRandomAccessIterator {}
 
 extension UnsafeMutablePointer: UnsafeCxxRandomAccessIterator {}
 
-public protocol CxxRandomAccessCollection: CxxSequence, RandomAccessCollection {
+public protocol CxxRandomAccessCollection<Element>: CxxSequence, RandomAccessCollection {
+  override associatedtype Element
   override associatedtype RawIterator: UnsafeCxxRandomAccessIterator
+    where RawIterator.Pointee == Element
   override associatedtype Iterator = CxxIterator<Self>
-  override associatedtype Element = RawIterator.Pointee
   override associatedtype Index = Int
   override associatedtype Indices = Range<Int>
   override associatedtype SubSequence = Slice<Self>
@@ -67,7 +68,7 @@ extension CxxRandomAccessCollection {
       // Not using CxxIterator here to avoid making a copy of the collection.
       var rawIterator = __beginUnsafe()
       rawIterator += RawIterator.Distance(index)
-      yield rawIterator.pointee as! Element
+      yield rawIterator.pointee
     }
   }
 }

stdlib/public/Cxx/CxxSequence.swift

@@ -40,13 +40,15 @@ extension UnsafeMutablePointer: UnsafeCxxInputIterator {}
 extension Optional: UnsafeCxxInputIterator where Wrapped: UnsafeCxxInputIterator {
   public typealias Pointee = Wrapped.Pointee
 
+  @inlinable
   public var pointee: Pointee {
     if let value = self {
       return value.pointee
     }
     fatalError("Could not dereference nullptr")
   }
 
+  @inlinable
   public func successor() -> Self {
     if let value = self {
       return value.successor()
@@ -63,9 +65,10 @@ extension Optional: UnsafeCxxInputIterator where Wrapped: UnsafeCxxInputIterator
 /// This requires the C++ sequence type to define const methods `begin()` and
 /// `end()` which return input iterators into the C++ sequence. The iterator
 /// types must conform to `UnsafeCxxInputIterator`.
-public protocol CxxSequence: Sequence {
+public protocol CxxSequence<Element>: Sequence {
+  override associatedtype Element
   associatedtype RawIterator: UnsafeCxxInputIterator
-  override associatedtype Element = RawIterator.Pointee
+    where RawIterator.Pointee == Element
   override associatedtype Iterator = CxxIterator<Self>
 
   // `begin()` and `end()` have to be mutating, otherwise calling 

stdlib/public/Cxx/std/String.swift

@@ -31,13 +31,13 @@ extension std.string: ExpressibleByStringLiteral {
 
 extension std.string: CustomDebugStringConvertible {
   public var debugDescription: String {
-    return "std.string(\(String(cxxString: self)))"
+    return "std.string(\(String(self)))"
   }
 }
 
 extension std.string: CustomStringConvertible {
   public var description: String {
-    return String(cxxString: self)
+    return String(self)
   }
 }
 
@@ -49,7 +49,7 @@ extension String {
   /// (`"\u{FFFD}"`).
   ///
   /// - Complexity: O(*n*), where *n* is the number of bytes in the C++ string.
-  public init(cxxString: std.string) {
+  public init(_ cxxString: std.string) {
     let buffer = UnsafeBufferPointer<CChar>(
       start: cxxString.__c_strUnsafe(),
       count: cxxString.size())

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

@@ -10,11 +10,11 @@ var StdStringOverlayTestSuite = TestSuite("std::string overlay")
 
 StdStringOverlayTestSuite.test("std::string <=> Swift.String") {
   let cxx1 = std.string()
-  let swift1 = String(cxxString: cxx1)
+  let swift1 = String(cxx1)
   expectEqual(swift1, "")
 
   let cxx2 = std.string("something123")
-  let swift2 = String(cxxString: cxx2)
+  let swift2 = String(cxx2)
   expectEqual(swift2, "something123")
 
   let cxx3: std.string = "literal"
@@ -23,25 +23,25 @@ StdStringOverlayTestSuite.test("std::string <=> Swift.String") {
   // Non-ASCII characters are represented by more than one CChar.
   let cxx4: std.string = "тест"
   expectEqual(cxx4.size(), 8)
-  let swift4 = String(cxxString: cxx4)
+  let swift4 = String(cxx4)
   expectEqual(swift4, "тест")
 
   let cxx5: std.string = "emoji_🤖"
   expectEqual(cxx5.size(), 10)
-  let swift5 = String(cxxString: cxx5)
+  let swift5 = String(cxx5)
   expectEqual(swift5, "emoji_🤖")
 
   let cxx6 = std.string("xyz\0abc")
   expectEqual(cxx6.size(), 7)
-  let swift6 = String(cxxString: cxx6)
+  let swift6 = String(cxx6)
   expectEqual(swift6, "xyz\0abc")
 
   var cxx7 = std.string()
   let bytes: [UInt8] = [0xE1, 0xC1, 0xAC]
   for byte in bytes {
     cxx7.push_back(CChar(bitPattern: byte))
   }
-  let swift7 = String(cxxString: cxx7)
+  let swift7 = String(cxx7)
   expectEqual(swift7, "���")
 }