[C++ Interop] Deprecate Optional argument overloads of std.string initializer in Swift’s C++ Stdlib Overlay (#83223)

This patch addresses potential ambiguity and unsafe behavior by
deprecating initializer overloads for `std.string` that accept optional
arguments (`string?`). These overloads previously allowed implicit
initialization from optional pointers (`UnsafePointer<CChar>?`), causing
unclear or unintended behavior.

- Deprecated: `init(_ string: UnsafePointer<CChar>?)`, guiding users
toward the explicit, non-optional initializer.
- Unavailable: `init(_ string: String?)`, explicitly preventing misuse
from optional Swift strings.

rdar://148041893

Author: fahadnayyar

stdlib/public/Cxx/std/String.swift

@@ -33,20 +33,34 @@ extension std.string {
     }
   }
 
+
   @_alwaysEmitIntoClient
-  public init(_ string: UnsafePointer<CChar>?) {
-    if let str = unsafe string {
-#if os(Windows)
+  @available(*, unavailable, message: "initializing std::string with an optional String is not supported; unwrap the optional value before passing it to std.string()")
+  public init(_ string: String?) {
+      fatalError("This initializer is unavailable and should never be called.")
+  }
+
+  @_alwaysEmitIntoClient
+  public init(_ string: UnsafePointer<CChar>) {
+  #if os(Windows)
       // Use the 2 parameter constructor.
       // The MSVC standard library has a enable_if template guard
       // on the 3 parameter constructor, and thus it's not imported into Swift.
-      unsafe self.init(str, UTF8._nullCodeUnitOffset(in: str))
-#else
-      unsafe self.init(str, UTF8._nullCodeUnitOffset(in: str), .init())
-#endif
-    } else {
+    unsafe self.init(string, UTF8._nullCodeUnitOffset(in: string))
+  #else
+    unsafe self.init(string, UTF8._nullCodeUnitOffset(in: string), .init())
+  #endif
+  }
+
+  @_alwaysEmitIntoClient
+  @_disfavoredOverload
+  @available(*, deprecated, message: "unwrap the optional value and use init(_ string: UnsafePointer<CChar>) instead")
+  public init(_ string: UnsafePointer<CChar>?) {
+    guard let str = unsafe string else {
       self.init()
+      return
     }
+    self.init(str)
   }
 }
 

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

@@ -0,0 +1,8 @@
+// RUN: %target-typecheck-verify-swift -I %S/Inputs -cxx-interoperability-mode=default
+import CxxStdlib
+
+let tmpOpt: String? = "üüüüüüü"
+let cppString1 = std.string(tmpOpt) // expected-warning {{'init(_:)' is deprecated: unwrap the optional value and use init(_ string: UnsafePointer<CChar>) instead}}
+
+let tmpNonOpt: String = "üüüüüüü"
+let cppString2 = std.string(tmpNonOpt)

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

@@ -73,6 +73,23 @@ StdStringTestSuite.test("std::string <=> Swift.String") {
     expectEqual(swift8, "Hello, World!")
 }
 
+StdStringTestSuite.test("std::string <=> Optional<String>") {
+    let ascii: String? = "aaaaaaa"
+    let nonAscii: String? = "üüüüüüü"
+    let nilString: String? = nil
+    let emptyString: String? = ""
+
+    let s1 = std.string(ascii!)
+    let s2 = std.string(nonAscii!)
+    let s3 = std.string(nilString ?? "")
+    let s4 = std.string(emptyString!)
+
+    expectEqual(String(s1), "aaaaaaa")
+    expectEqual(String(s2), "üüüüüüü")
+    expectEqual(String(s3), "")
+    expectEqual(String(s4), "")
+}
+
 StdStringTestSuite.test("std::string operators") {
     var s1 = std.string("something")
     let s2 = std.string("123")