embind: Fix the TypeScript definitions for std::string and std::wstring. (#20815)

- The return type for std::string is always a JS string.
 - std::wstring always takes in a JS string and returns a JS string.

Fixes #20564

Author: brendandahl

src/embind/embind_gen.js

@@ -53,7 +53,7 @@ var LibraryEmbind = {
         argOut.push(`${arg.name}: ${nameMap(arg.type)}`);
       }
       out.push(argOut.join(', '));
-      out.push(`): ${nameMap(this.returnType)}`);
+      out.push(`): ${nameMap(this.returnType, true)}`);
     }
 
     printFunction(nameMap, out) {
@@ -298,37 +298,40 @@ var LibraryEmbind = {
     constructor(definitions) {
       this.definitions = definitions;
       const jsString = 'ArrayBuffer|Uint8Array|Uint8ClampedArray|Int8Array|string';
+      // The mapping is in the format of '<c++ name>' => ['toWireType', 'fromWireType']
+      // or if the to/from wire types are the same use a single element.
       this.builtInToJsName = new Map([
-        ['bool', 'boolean'],
-        ['float', 'number'],
-        ['double', 'number'],
+        ['bool', ['boolean']],
+        ['float', ['number']],
+        ['double', ['number']],
 #if MEMORY64
-        ['long', 'bigint'],
-        ['unsigned long', 'bigint'],
+        ['long', ['bigint']],
+        ['unsigned long', ['bigint']],
 #endif
 #if WASM_BIGINT
-        ['int64_t', 'bigint'],
-        ['uint64_t', 'bigint'],
+        ['int64_t', ['bigint']],
+        ['uint64_t', ['bigint']],
 #endif
-        ['void', 'void'],
-        ['std::string', jsString],
-        ['std::basic_string<unsigned char>', jsString],
-        ['std::wstring', jsString],
-        ['std::u16string', jsString],
-        ['std::u32string', jsString],
-        ['emscripten::val', 'any'],
+        ['void', ['void']],
+        ['std::string', [jsString, 'string']],
+        ['std::basic_string<unsigned char>', [jsString, 'string']],
+        ['std::wstring', ['string']],
+        ['std::u16string', ['string']],
+        ['std::u32string', ['string']],
+        ['emscripten::val', ['any']],
       ]);
     }
 
-    typeToJsName(type) {
+    typeToJsName(type, isFromWireType = false) {
       if (type instanceof IntegerType) {
         return 'number';
       }
       if (type instanceof PrimitiveType) {
         if (!this.builtInToJsName.has(type.name)) {
           throw new Error(`Missing primitive type to TS type for '${type.name}'`);
         }
-        return this.builtInToJsName.get(type.name)
+        const [toWireType, fromWireType = toWireType] = this.builtInToJsName.get(type.name);
+        return isFromWireType ? fromWireType : toWireType;
       }
       if (type instanceof PointerDefinition) {
         return this.typeToJsName(type.classType);

test/other/embind_tsgen.cpp

@@ -89,6 +89,14 @@ int function_with_callback_param(CallbackType ct) {
 
 int global_fn(int, int) { return 0; }
 
+std::string string_test(std::string arg) {
+  return "hi";
+}
+
+std::wstring wstring_test(std::wstring arg) {
+  return L"hi";
+}
+
 class BaseClass {
  public:
   virtual ~BaseClass() = default;
@@ -156,6 +164,9 @@ EMSCRIPTEN_BINDINGS(Test) {
 
   function("global_fn", &global_fn);
 
+  function("string_test", &string_test);
+  function("wstring_test", &wstring_test);
+
   class_<ClassWithConstructor>("ClassWithConstructor")
       .constructor<int, const ValArr&>()
       .function("fn", &ClassWithConstructor::fn);

test/other/embind_tsgen.d.ts

@@ -91,4 +91,6 @@ export interface MainModule {
   smart_ptr_function(_0: ClassWithSmartPtrConstructor): number;
   smart_ptr_function_with_params(foo: ClassWithSmartPtrConstructor): number;
   function_with_callback_param(_0: (message: string) => void): number;
+  string_test(_0: ArrayBuffer|Uint8Array|Uint8ClampedArray|Int8Array|string): string;
+  wstring_test(_0: string): string;
 }