Merge pull request #68240 from CrazyFanFan/feature/crazy_fan/std_u32string

[cxx-interop] Provide similar support for std::u32string as std::string and std::u16string.

Author: egorzhdan

stdlib/public/Cxx/cxxshim/libcxxstdlibshim.h

@@ -6,3 +6,6 @@ typedef std::hash<std::string> __swift_interopHashOfString;
 
 /// Used for std::u16string conformance to Swift.Hashable
 typedef std::hash<std::u16string> __swift_interopHashOfU16String;
+
+/// Used for std::u32string conformance to Swift.Hashable
+typedef std::hash<std::u32string> __swift_interopHashOfU32String;

stdlib/public/Cxx/std/String.swift

@@ -55,6 +55,20 @@ extension std.u16string {
   }
 }
 
+extension std.u32string {
+  /// Creates a C++ UTF-32 string having the same content as the given Swift
+  /// string.
+  ///
+  /// - Complexity: O(*n*), where *n* is the number of UTF-32 code units in the
+  ///   Swift string.
+  public init(_ string: String) {
+    self.init()
+    for char in string.unicodeScalars {
+      self.push_back(char)
+    }
+  }
+}
+
 // MARK: Initializing C++ string from a Swift String literal
 
 extension std.string: ExpressibleByStringLiteral {
@@ -69,6 +83,12 @@ extension std.u16string: ExpressibleByStringLiteral {
   }
 }
 
+extension std.u32string: ExpressibleByStringLiteral {
+  public init(stringLiteral value: String) {
+    self.init(value)
+  }
+}
+
 // MARK: Concatenating and comparing C++ strings
 
 extension std.string: Equatable {
@@ -113,6 +133,27 @@ extension std.u16string: Equatable {
   }
 }
 
+extension std.u32string: Equatable {
+  public static func ==(lhs: std.u32string, rhs: std.u32string) -> Bool {
+    return lhs.compare(rhs) == 0
+  }
+
+  public static func +=(lhs: inout std.u32string, rhs: std.u32string) {
+    lhs.append(rhs)
+  }
+
+  @inlinable
+  public mutating func append(_ other: std.u32string) {
+    __appendUnsafe(other) // ignore the returned pointer
+  }
+
+  public static func +(lhs: std.u32string, rhs: std.u32string) -> std.u32string {
+    var copy = lhs
+    copy += rhs
+    return copy
+  }
+}
+
 // MARK: Hashing C++ strings
 
 extension std.string: Hashable {
@@ -131,6 +172,14 @@ extension std.u16string: Hashable {
   }
 }
 
+extension std.u32string: Hashable {
+  public func hash(into hasher: inout Hasher) {
+    // Call std::hash<std::u32string>::operator()
+    let cxxHash = __swift_interopHashOfU32String().callAsFunction(self)
+    hasher.combine(cxxHash)
+  }
+}
+
 // MARK: Getting a Swift description of a C++ string
 
 extension std.string: CustomDebugStringConvertible {
@@ -145,6 +194,12 @@ extension std.u16string: CustomDebugStringConvertible {
   }
 }
 
+extension std.u32string: CustomDebugStringConvertible {
+  public var debugDescription: String {
+    return "std.u32string(\(String(self)))"
+  }
+}
+
 extension std.string: CustomStringConvertible {
   public var description: String {
     return String(self)
@@ -157,6 +212,12 @@ extension std.u16string: CustomStringConvertible {
   }
 }
 
+extension std.u32string: CustomStringConvertible {
+  public var description: String {
+    return String(self)
+  }
+}
+
 // MARK: Initializing Swift String from a C++ string
 
 extension String {
@@ -192,4 +253,22 @@ extension String {
     self = String(decoding: buffer, as: UTF16.self)
     withExtendedLifetime(cxxU16String) {}
   }
+
+  /// Creates a String having the same content as the given C++ UTF-32 string.
+  ///
+  /// If `cxxString` contains ill-formed UTF-32 code unit sequences, this
+  /// initializer replaces them with the Unicode replacement character
+  /// (`"\u{FFFD}"`).
+  ///
+  /// - Complexity: O(*n*), where *n* is the number of bytes in the C++ UTF-32
+  ///   string.
+  public init(_ cxxU32String: std.u32string) {
+    let buffer = UnsafeBufferPointer<Unicode.Scalar>(
+      start: cxxU32String.__dataUnsafe(),
+      count: cxxU32String.size())
+    self = buffer.withMemoryRebound(to: UInt32.self) {
+      String(decoding: $0, as: UTF32.self)
+    }
+    withExtendedLifetime(cxxU32String) {}
+  }
 }

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

@@ -84,6 +84,26 @@ StdStringOverlayTestSuite.test("std::u16string operators") {
   expectTrue(s1 == "something123literal")
 }
 
+StdStringOverlayTestSuite.test("std::u32string operators") {
+  var s1 = std.u32string("something")
+  let s2 = std.u32string("123")
+  let sum = s1 + s2
+  expectEqual(sum, std.u32string("something123"))
+
+  expectFalse(s1 == s2)
+  let s3 = std.u32string("something123")
+  expectFalse(s1 == s3)
+  expectFalse(s2 == s3)
+
+  s1 += s2
+  expectTrue(s1 == std.u32string("something123"))
+  expectTrue(s1 == s3)
+
+  // Make sure the operators work together with ExpressibleByStringLiteral conformance.
+  s1 += "literal"
+  expectTrue(s1 == "something123literal")
+}
+
 StdStringOverlayTestSuite.test("std::string::append") {
   var s1 = std.string("0123")
   let s2 = std.string("abc")
@@ -98,6 +118,13 @@ StdStringOverlayTestSuite.test("std::u16string::append") {
   expectEqual(s1, std.u16string("0123abc"))
 }
 
+StdStringOverlayTestSuite.test("std::u32string::append") {
+  var s1 = std.u32string("0123")
+  let s2 = std.u32string("abc")
+  s1.append(s2)
+  expectEqual(s1, std.u32string("0123abc"))
+}
+
 StdStringOverlayTestSuite.test("std::string as Hashable") {
   let s0 = std.string()
   let h0 = s0.hashValue
@@ -140,6 +167,27 @@ StdStringOverlayTestSuite.test("std::u16string as Hashable") {
   expectNotEqual(h2, h3)
 }
 
+StdStringOverlayTestSuite.test("std::u32string as Hashable") {
+  let s0 = std.u32string()
+  let h0 = s0.hashValue
+
+  let s1 = std.u32string("something")
+  let h1 = s1.hashValue
+
+  let s2 = std.u32string("something123")
+  let h2 = s2.hashValue
+
+  let s3 = std.u32string("something")
+  let h3 = s3.hashValue
+
+  expectEqual(h1, h3)
+  expectNotEqual(h0, h1)
+  expectNotEqual(h0, h2)
+  expectNotEqual(h0, h3)
+  expectNotEqual(h1, h2)
+  expectNotEqual(h2, h3)
+}
+
 StdStringOverlayTestSuite.test("std::u16string <=> Swift.String") {
   let cxx1 = std.u16string()
   let swift1 = String(cxx1)
@@ -170,6 +218,36 @@ StdStringOverlayTestSuite.test("std::u16string <=> Swift.String") {
   expectEqual(swift6, "xyz\0abc")
 }
 
+StdStringOverlayTestSuite.test("std::u32string <=> Swift.String") {
+  let cxx1 = std.u32string()
+  let swift1 = String(cxx1)
+  expectEqual(swift1, "")
+
+  let cxx2 = std.u32string("something123")
+  expectEqual(cxx2.size(), 12)
+  let swift2 = String(cxx2)
+  expectEqual(swift2, "something123")
+
+  let cxx3: std.u32string = "literal"
+  expectEqual(cxx3.size(), 7)
+
+  let cxx4: std.u32string = "тест"
+  expectEqual(cxx4.size(), 4)
+  let swift4 = String(cxx4)
+  expectEqual(swift4, "тест")
+
+  // Emojis are represented by more than one CWideChar.
+  let cxx5: std.u32string = "emoji_🤖"
+  expectEqual(cxx5.size(), 7)
+  let swift5 = String(cxx5)
+  expectEqual(swift5, "emoji_🤖")
+
+  let cxx6 = std.u32string("xyz\0abc")
+  expectEqual(cxx6.size(), 7)
+  let swift6 = String(cxx6)
+  expectEqual(swift6, "xyz\0abc")
+}
+
 StdStringOverlayTestSuite.test("std::string as Swift.CustomDebugStringConvertible") {
   let cxx1 = std.string()
   expectEqual(cxx1.debugDescription, "std.string()")
@@ -200,6 +278,23 @@ StdStringOverlayTestSuite.test("std::u16string as Swift.CustomDebugStringConvert
   expectEqual(cxx3.debugDescription, "std.u16string(a�c)")
 }
 
+StdStringOverlayTestSuite.test("std::u32string as Swift.CustomDebugStringConvertible") {
+  let cxx1 = std.u32string()
+  expectEqual(cxx1.debugDescription, "std.u32string()")
+
+  let cxx2 = std.u32string("something123")
+  expectEqual(cxx2.debugDescription, "std.u32string(something123)")
+
+  // Since std::u32string does not support pushing back UInt32 directly, we utilize UInt16 instead.
+  let scalars: [UInt16] = [97, 55296, 99]
+  var cxx3_16 = std.u16string()
+  for scalar: UInt16 in scalars {
+    cxx3_16.push_back(scalar)
+  }
+  let cxx3 = std.u32string(String(cxx3_16))
+  expectEqual(cxx3.debugDescription, "std.u32string(a�c)")
+}
+
 StdStringOverlayTestSuite.test("std::string as Swift.Sequence") {
   let cxx1 = std.string()
   var iterated = false
@@ -249,6 +344,32 @@ StdStringOverlayTestSuite.test("std::u16string as Swift.CustomStringConvertible"
   expectEqual(cxx3.description, "a�c")
 }
 
+StdStringOverlayTestSuite.test("std::u32string as Swift.CustomStringConvertible") {
+  let cxx1 = std.u32string()
+  expectEqual(cxx1.description, "")
+
+  let cxx2 = std.u32string("something123")
+  expectEqual(cxx2.description, "something123")
+
+  // Since std::u32string does not support pushing back UInt32 directly, we utilize UInt16 instead.
+  let scalars: [UInt16] = [97, 55296, 99]
+  var cxx3_16 = std.u16string()
+  for scalar: UInt16 in scalars {
+    cxx3_16.push_back(scalar)
+  }
+  let cxx3 = std.u32string(String(cxx3_16))
+  expectEqual(cxx3.description, "a�c")
+
+  // For `push_back`
+  let scalars2: [Unicode.Scalar] = [0x48, 0x65, 0x6C, 0x6C, 0x6F, 0x2C, 0x20, 0x4E16, 0x754C]
+    .compactMap { Unicode.Scalar($0) }
+  var cxx4 = std.u32string()
+  for scalar: Unicode.Scalar in scalars2 {
+    cxx4.push_back(scalar)
+  }
+  expectEqual(cxx4.description, "Hello, 世界")
+}
+
 StdStringOverlayTestSuite.test("std::string from C string") {
   let str = "abc".withCString { ptr in
     std.string(ptr)