[cxx-interop] Provide overlay for std::wstring

This adds CxxStdlib overlay features to `std::wstring` similarly to `std::string`, `std::u16string`, etc.

This lets clients e.g. convert between Swift String and C++ wide string simply by calling an initializer.

rdar://159272493

Author: egorzhdan

stdlib/public/Cxx/cxxshim/libcxxstdlibshim.h

@@ -20,6 +20,12 @@ inline std::size_t __swift_interopComputeHashOfU32String(const std::u32string &s
   return __swift_interopHashOfU32String()(str);
 }
 
+/// Used for std::wstring conformance to Swift.Hashable
+typedef std::hash<std::wstring> __swift_interopHashOfWString;
+inline std::size_t __swift_interopComputeHashOfWString(const std::wstring &str) {
+  return __swift_interopHashOfWString()(str);
+}
+
 inline std::chrono::seconds __swift_interopMakeChronoSeconds(int64_t seconds) {
   return std::chrono::seconds(seconds);
 }

stdlib/public/Cxx/std/String.swift

@@ -95,6 +95,30 @@ extension std.u32string {
   }
 }
 
+extension std.wstring {
+  /// Creates a C++ wide character string having the same content as the given 
+  /// Swift string.
+  ///
+  /// Note that the definition of a wide character differs across platforms:
+  /// it is UTF-16 on Windows but UTF-32 on other platforms.
+  ///
+  /// - Complexity: O(*n*), where *n* is the number of wide characters in the
+  ///   Swift string.
+  @_alwaysEmitIntoClient
+  public init(_ string: String) {
+    self.init()
+#if os(Windows)
+    for char in string.utf16 {
+      self.push_back(char)
+    }
+#else
+    for char in string.unicodeScalars {
+      self.push_back(char)
+    }
+#endif
+  }
+}
+
 // MARK: Initializing C++ string from a Swift String literal
 
 extension std.string: ExpressibleByStringLiteral,
@@ -124,6 +148,15 @@ extension std.u32string: ExpressibleByStringLiteral,
   }
 }
 
+extension std.wstring: ExpressibleByStringLiteral,
+  ExpressibleByStringInterpolation {
+
+  @_alwaysEmitIntoClient
+  public init(stringLiteral value: String) {
+    self.init(value)
+  }
+}
+
 // MARK: Concatenating and comparing C++ strings
 
 extension std.string: Equatable, Comparable {
@@ -213,6 +246,35 @@ extension std.u32string: Equatable, Comparable {
   }
 }
 
+extension std.wstring: Equatable, Comparable {
+  @_alwaysEmitIntoClient
+  public static func ==(lhs: std.wstring, rhs: std.wstring) -> Bool {
+    return lhs.compare(rhs) == 0
+  }
+
+  @_alwaysEmitIntoClient
+  public static func <(lhs: std.wstring, rhs: std.wstring) -> Bool {
+    return lhs.compare(rhs) < 0
+  }
+
+  @_alwaysEmitIntoClient
+  public static func +=(lhs: inout std.wstring, rhs: std.wstring) {
+    lhs.append(rhs)
+  }
+
+  @_alwaysEmitIntoClient
+  public mutating func append(_ other: std.wstring) {
+    unsafe __appendUnsafe(other) // ignore the returned pointer
+  }
+
+  @_alwaysEmitIntoClient
+  public static func +(lhs: std.wstring, rhs: std.wstring) -> std.wstring {
+    var copy = lhs
+    copy += rhs
+    return copy
+  }
+}
+
 // MARK: Hashing C++ strings
 
 extension std.string: Hashable {
@@ -242,6 +304,15 @@ extension std.u32string: Hashable {
   }
 }
 
+extension std.wstring: Hashable {
+  @_alwaysEmitIntoClient
+  public func hash(into hasher: inout Hasher) {
+    // Call std::hash<std::wstring>::operator()
+    let cxxHash = __swift_interopComputeHashOfWString(self)
+    hasher.combine(cxxHash)
+  }
+}
+
 // MARK: Getting a Swift description of a C++ string
 
 extension std.string: CustomDebugStringConvertible {
@@ -265,6 +336,13 @@ extension std.u32string: CustomDebugStringConvertible {
   }
 }
 
+extension std.wstring: CustomDebugStringConvertible {
+  @_alwaysEmitIntoClient
+  public var debugDescription: String {
+    return "std.wstring(\(String(self)))"
+  }
+}
+
 extension std.string: CustomStringConvertible {
   @_alwaysEmitIntoClient
   public var description: String {
@@ -286,6 +364,13 @@ extension std.u32string: CustomStringConvertible {
   }
 }
 
+extension std.wstring: CustomStringConvertible {
+  @_alwaysEmitIntoClient
+  public var description: String {
+    return String(self)
+  }
+}
+
 // MARK: Initializing Swift String from a C++ string
 
 extension String {
@@ -342,6 +427,36 @@ extension String {
     }
     withExtendedLifetime(cxxU32String) {}
   }
+
+  /// Creates a String having the same content as the given C++ wide character 
+  /// string.
+  ///
+  /// Note that the definition of a wide character differs across platforms:
+  /// it is UTF-16 on Windows but UTF-32 on other platforms.
+  ///
+  /// If `cxxString` contains ill-formed UTF code unit sequences, this
+  /// initializer replaces them with the Unicode replacement character
+  /// (`"\u{FFFD}"`).
+  ///
+  /// - Complexity: O(*n*), where *n* is the number of wide characters in the
+  ///   C++ string.
+  @_alwaysEmitIntoClient
+  public init(_ cxxWString: std.wstring) {
+#if os(Windows)
+    let buffer = unsafe UnsafeBufferPointer<UInt16>(
+      start: cxxWString.__dataUnsafe(),
+      count: cxxWString.size())
+    self = unsafe String(decoding: buffer, as: UTF16.self)
+#else
+    let buffer = unsafe UnsafeBufferPointer<Unicode.Scalar>(
+      start: cxxWString.__dataUnsafe(),
+      count: cxxWString.size())
+    self = unsafe buffer.withMemoryRebound(to: UInt32.self) {
+      unsafe String(decoding: $0, as: UTF32.self)
+    }
+#endif
+    withExtendedLifetime(cxxWString) {}
+  }
 }
 
 // MARK: Initializing Swift String from a C++ string_view
@@ -403,6 +518,24 @@ extension String {
     }
     unsafe withExtendedLifetime(cxxU32StringView) {}
   }
+
+  @_alwaysEmitIntoClient
+  public init(_ cxxWStringView: std.wstring_view) {
+#if os(Windows)
+    let buffer = unsafe UnsafeBufferPointer<UInt16>(
+      start: cxxWStringView.__dataUnsafe(),
+      count: cxxWStringView.size())
+    self = unsafe String(decoding: buffer, as: UTF16.self)
+#else
+    let buffer = unsafe UnsafeBufferPointer<Unicode.Scalar>(
+      start: cxxWStringView.__dataUnsafe(),
+      count: cxxWStringView.size())
+    self = unsafe buffer.withMemoryRebound(to: UInt32.self) {
+      unsafe String(decoding: $0, as: UTF32.self)
+    }
+#endif
+    withExtendedLifetime(cxxWStringView) {}
+  }
 }
 
 @available(SwiftCompatibilitySpan 5.0, *)
@@ -463,3 +596,18 @@ extension std.u32string {
     }
   }
 }
+
+@available(SwiftCompatibilitySpan 5.0, *)
+extension std.wstring {
+  public var span: Span<CWideChar> {
+    @_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: CWideChar.self)
+      let span = unsafe Span(_unsafeElements: bufferWithFixedType)
+      return unsafe _cxxOverrideLifetime(span, borrowing: self)
+    }
+  }
+}

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

@@ -150,6 +150,26 @@ StdStringTestSuite.test("std::u32string operators") {
     expectTrue(s1 == "something123literal")
 }
 
+StdStringTestSuite.test("std::wstring operators") {
+    var s1 = std.wstring("something")
+    let s2 = std.wstring("123")
+    let sum = s1 + s2
+    expectEqual(sum, std.wstring("something123"))
+
+    expectFalse(s1 == s2)
+    let s3 = std.wstring("something123")
+    expectFalse(s1 == s3)
+    expectFalse(s2 == s3)
+
+    s1 += s2
+    expectTrue(s1 == std.wstring("something123"))
+    expectTrue(s1 == s3)
+
+    // Make sure the operators work together with ExpressibleByStringLiteral conformance.
+    s1 += "literal"
+    expectTrue(s1 == "something123literal")
+}
+
 StdStringTestSuite.test("std::string::append") {
     var s1 = std.string("0123")
     let s2 = std.string("abc")
@@ -171,6 +191,13 @@ StdStringTestSuite.test("std::u32string::append") {
     expectEqual(s1, std.u32string("0123abc"))
 }
 
+StdStringTestSuite.test("std::wstring::append") {
+    var s1 = std.wstring("0123")
+    let s2 = std.wstring("abc")
+    s1.append(s2)
+    expectEqual(s1, std.wstring("0123abc"))
+}
+
 StdStringTestSuite.test("std::string comparison") {
     let s1 = std.string("abc")
     let s2 = std.string("def")
@@ -219,6 +246,22 @@ StdStringTestSuite.test("std::u32string comparison") {
     expectTrue(s1 == s3)
 }
 
+StdStringTestSuite.test("std::wstring comparison") {
+    let s1 = std.wstring("abc")
+    let s2 = std.wstring("def")
+    let s3 = std.wstring("abc")
+
+    expectTrue(s1 < s2)
+    expectFalse(s2 < s1)
+    expectTrue(s1 <= s2)
+    expectFalse(s2 <= s1)
+    expectTrue(s2 > s1)
+    expectFalse(s1 > s2)
+    expectTrue(s2 >= s1)
+    expectFalse(s1 >= s2)
+    expectTrue(s1 == s3)
+}
+
 StdStringTestSuite.test("std::string as Hashable") {
     let s0 = std.string()
     let h0 = s0.hashValue
@@ -282,6 +325,27 @@ StdStringTestSuite.test("std::u32string as Hashable") {
     expectNotEqual(h2, h3)
 }
 
+StdStringTestSuite.test("std::wstring as Hashable") {
+    let s0 = std.wstring()
+    let h0 = s0.hashValue
+
+    let s1 = std.wstring("something")
+    let h1 = s1.hashValue
+
+    let s2 = std.wstring("something123")
+    let h2 = s2.hashValue
+
+    let s3 = std.wstring("something")
+    let h3 = s3.hashValue
+
+    expectEqual(h1, h3)
+    expectNotEqual(h0, h1)
+    expectNotEqual(h0, h2)
+    expectNotEqual(h0, h3)
+    expectNotEqual(h1, h2)
+    expectNotEqual(h2, h3)
+}
+
 StdStringTestSuite.test("std::u16string <=> Swift.String") {
     let cxx1 = std.u16string()
     let swift1 = String(cxx1)
@@ -401,6 +465,14 @@ StdStringTestSuite.test("std::u32string as Swift.CustomDebugStringConvertible")
     expectEqual(cxx3.debugDescription, "std.u32string(a�c)")
 }
 
+StdStringTestSuite.test("std::wstring as Swift.CustomDebugStringConvertible") {
+    let cxx1 = std.wstring()
+    expectEqual(cxx1.debugDescription, "std.wstring()")
+
+    let cxx2 = std.wstring("something123")
+    expectEqual(cxx2.debugDescription, "std.wstring(something123)")
+}
+
 StdStringTestSuite.test("std::string as Swift.Sequence") {
     let cxx1 = std.string()
     var iterated = false
@@ -476,6 +548,14 @@ StdStringTestSuite.test("std::u32string as Swift.CustomStringConvertible") {
     expectEqual(cxx4.description, "Hello, 世界")
 }
 
+StdStringTestSuite.test("std::wstring as Swift.CustomStringConvertible") {
+    let cxx1 = std.wstring()
+    expectEqual(cxx1.description, "")
+
+    let cxx2 = std.wstring("something123")
+    expectEqual(cxx2.description, "something123")
+}
+
 StdStringTestSuite.test("std::string from C string") {
     let str = "abc".withCString { ptr in
         std.string(ptr)