embind: Run test_embind with TS generation enabled. (#20102)

To get this running:
 - Map all integers to a JS number.
 - Add missing c++ string to JS string mappings.
 - Stub out embind_tsgen_test_embind which is not needed.
 - Add missing function dependency.
 - Skip tests for unbound types.
 - Remove invalid constructor with unique_ptr argument.

Author: brendandahl

src/embind/embind_ts.js

@@ -14,6 +14,11 @@ var LibraryEmbind = {
       this.name = name;
     }
   },
+  $IntegerType: class IntegerType {
+    constructor(typeId) {
+      this.typeId = typeId;
+    }
+  },
   $Argument: class Argument {
     constructor(name, type) {
       this.name = name;
@@ -193,21 +198,22 @@ var LibraryEmbind = {
       const jsString = 'ArrayBuffer|Uint8Array|Uint8ClampedArray|Int8Array|string';
       this.builtInToJsName = new Map([
         ['bool', 'boolean'],
-        ['char', 'number'],
-        ['unsigned char', 'number'],
-        ['int', 'number'],
-        ['unsigned int', 'number'],
-        ['unsigned long', 'number'],
         ['float', 'number'],
         ['double', 'number'],
         ['void', 'void'],
         ['std::string', jsString],
         ['std::basic_string<unsigned char>', jsString],
+        ['std::wstring', jsString],
+        ['std::u16string', jsString],
+        ['std::u32string', jsString],
         ['emscripten::val', 'any'],
       ]);
     }
 
     typeToJsName(type) {
+      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}'`);
@@ -247,6 +253,10 @@ var LibraryEmbind = {
     name = readLatin1String(name);
     registerType(id, new PrimitiveType(id, name));
   },
+  $registerIntegerType__deps: ['$registerType', '$IntegerType'],
+  $registerIntegerType: (id) => {
+    registerType(id, new IntegerType(id));
+  },
   $createFunctionDefinition__deps: ['$FunctionDefinition', '$heap32VectorToArray', '$readLatin1String', '$Argument', '$whenDependentTypesAreResolved'],
   $createFunctionDefinition: (name, argCount, rawArgTypesAddr, hasThis, cb) => {
     const argTypes = heap32VectorToArray(argCount, rawArgTypesAddr);
@@ -277,9 +287,9 @@ var LibraryEmbind = {
   _embind_register_bool: (rawType, name, trueValue, falseValue) => {
     registerPrimitiveType(rawType, name);
   },
-  _embind_register_integer__deps: ['$registerPrimitiveType'],
+  _embind_register_integer__deps: ['$registerIntegerType'],
   _embind_register_integer: (primitiveType, name, size, minRange, maxRange) => {
-    registerPrimitiveType(primitiveType, name);
+    registerIntegerType(primitiveType, name);
   },
   _embind_register_bigint: (primitiveType, name, size, minRange, maxRange) => {
     registerPrimitiveType(primitiveType, name);
@@ -333,7 +343,7 @@ var LibraryEmbind = {
     );
 
   },
-  _embind_register_class_constructor__deps: ['$whenDependentTypesAreResolved'],
+  _embind_register_class_constructor__deps: ['$whenDependentTypesAreResolved', '$createFunctionDefinition'],
   _embind_register_class_constructor: function(
     rawClassType,
     argCount,
@@ -428,6 +438,8 @@ var LibraryEmbind = {
       return [];
     });
   },
+  // Stub function. This is called a when extending an object and not needed for TS generation.
+  _embind_create_inheriting_constructor: (constructorName, wrapperType, properties) => {},
   _embind_register_enum__deps: ['$readLatin1String', '$EnumDefinition', '$moduleDefinitions'],
   _embind_register_enum: function(rawType, name, size, isSigned) {
     name = readLatin1String(name);
@@ -559,7 +571,7 @@ var LibraryEmbind = {
   $embindEmitTypes__postset: 'addOnInit(embindEmitTypes);',
   $embindEmitTypes: () => {
     for (const typeId in awaitingDependencies) {
-      throwBindingError(`Missing type definition for '${getTypeName(typeId)}'`);
+      throwBindingError(`Missing binding for type: '${getTypeName(typeId)}' typeId: ${typeId}`);
     }
     const printer = new TsPrinter(moduleDefinitions);
     printer.print();

test/embind/embind_test.cpp

@@ -2173,7 +2173,6 @@ EMSCRIPTEN_BINDINGS(tests) {
     function("embind_test_accept_big_class_instance", &embind_test_accept_big_class_instance);
 
     class_<UniquePtrToConstructor>("UniquePtrToConstructor")
-        .constructor<std::unique_ptr<int>>()
         .function("getValue", &UniquePtrToConstructor::getValue)
         ;
 
@@ -2669,6 +2668,7 @@ struct BoundClass {
     UnboundClass property;
 };
 
+#ifndef SKIP_UNBOUND_TYPES
 EMSCRIPTEN_BINDINGS(incomplete) {
     constant("hasUnboundTypeNames", emscripten::has_unbound_type_names);
 
@@ -2694,6 +2694,7 @@ EMSCRIPTEN_BINDINGS(incomplete) {
         .property("property", &BoundClass::property)
         ;
 }
+#endif
 
 class Noncopyable {
     Noncopyable(const Noncopyable&) = delete;

test/test_other.py

@@ -2915,6 +2915,12 @@ def test_embind_tsgen(self):
     self.assertNotExists('out.js')
     self.assertFileContents(test_file('other/embind_tsgen.d.ts'), actual)
 
+  def test_embind_tsgen_test_embind(self):
+    self.run_process([EMCC, test_file('embind/embind_test.cpp'),
+                      '-lembind', '--embind-emit-tsd', 'embind_tsgen_test_embind.d.ts',
+                      '-DSKIP_UNBOUND_TYPES']) # TypeScript generation requires all type to be bound.
+    self.assertExists('embind_tsgen_test_embind.d.ts')
+
   def test_embind_tsgen_val(self):
     # Check that any dependencies from val still works with TS generation enabled.
     self.run_process([EMCC, test_file('other/embind_tsgen_val.cpp'),