embind: Support generating custom TS for val types. (#19999)

This allows better definitions of C++ interfaces for TypesScript users when
a C++ function takes `val` (JS values) arguments.

Author: brendandahl

src/embind/embind.js

@@ -680,6 +680,11 @@ var LibraryEmbind = {
     });
   },
 
+  _embind_register_user_type__deps: ['_embind_register_emval'],
+  _embind_register_user_type: (rawType, name) => {
+    __embind_register_emval(rawType, name);
+  },
+
   _embind_register_memory_view__deps: ['$readLatin1String', '$registerType'],
   _embind_register_memory_view: (rawType, dataTypeIndex, name) => {
     var typeMapping = [

src/embind/embind_ts.js

@@ -25,6 +25,12 @@ var LibraryEmbind = {
       this.type = type;
     }
   },
+  $UserType: class UserType {
+    constructor(typeId, name) {
+      this.typeId = typeId;
+      this.name = name;
+    }
+  },
   $FunctionDefinition: class FunctionDefinition {
     constructor(name, returnType, argumentTypes, thisType = null) {
       this.name = name;
@@ -316,6 +322,11 @@ var LibraryEmbind = {
   _embind_register_emval: (rawType, name) => {
     registerPrimitiveType(rawType, name);
   },
+  _embind_register_user_type__deps: ['$registerType', '$readLatin1String', '$UserType'],
+  _embind_register_user_type: (rawType, name) => {
+    name = readLatin1String(name);
+    registerType(rawType, new UserType(rawType, name));
+  },
   _embind_register_memory_view: (rawType, dataTypeIndex, name) => {
     // TODO
   },

src/library_sigs.js

@@ -307,6 +307,7 @@ sigs = {
   _embind_register_smart_ptr__sig: 'vpppipppppppp',
   _embind_register_std_string__sig: 'vpp',
   _embind_register_std_wstring__sig: 'vppp',
+  _embind_register_user_type__sig: 'vpp',
   _embind_register_value_array__sig: 'vpppppp',
   _embind_register_value_array_element__sig: 'vppppppppp',
   _embind_register_value_object__sig: 'vpppppp',

system/include/emscripten/bind.h

@@ -249,6 +249,10 @@ void _embind_register_constant(
     TYPEID constantType,
     double value);
 
+void _embind_register_user_type(
+    TYPEID type,
+    const char* typeName);
+
 // Register an InitFunc in the global linked list of init functions.
 void _embind_register_bindings(struct InitFunc* f);
 
@@ -2021,6 +2025,12 @@ void constant(const char* name, const ConstantType& v) {
         static_cast<double>(asGenericValue(BT::toWireType(v))));
 }
 
+template <typename T>
+inline void register_type(const char* name) {
+  using namespace internal;
+  _embind_register_user_type(TypeID<T>::get(), name);
+}
+
 // EMSCRIPTEN_BINDINGS creates a static struct to initialize the binding which
 // will get included in the program if the translation unit in which it is
 // defined gets linked into the program. Using a C++ constructor here ensures it

system/include/emscripten/val.h

@@ -17,6 +17,7 @@
 #include <emscripten/wire.h>
 #include <cstdint> // uintptr_t
 #include <vector>
+#include <type_traits>
 
 
 namespace emscripten {
@@ -625,10 +626,18 @@ class val {
   friend struct internal::BindingType<val>;
 };
 
+// Declare a custom type that can be used in conjuction with
+// emscripten::register_type to emit custom TypeScript defintions for val types.
+#define EMSCRIPTEN_DECLARE_VAL_TYPE(name)                                          \
+struct name : public val {                                                     \
+  name(val const &other) : val(other) {}                                       \
+};
+
 namespace internal {
 
-template<>
-struct BindingType<val> {
+template<typename T>
+struct BindingType<T, typename std::enable_if<std::is_base_of<val, T>::value &&
+                                              !std::is_const<T>::value>::type> {
   typedef EM_VAL WireType;
   static WireType toWireType(const val& v) {
     _emval_incref(v.handle);

test/other/embind_tsgen.cpp

@@ -70,6 +70,13 @@ int smart_ptr_function(std::shared_ptr<ClassWithSmartPtrConstructor>) {
   return 0;
 }
 
+EMSCRIPTEN_DECLARE_VAL_TYPE(CallbackType);
+
+int function_with_callback_param(CallbackType ct) {
+  ct(val("hello"));
+  return 0;
+}
+
 int global_fn(int, int) { return 0; }
 
 class BaseClass {
@@ -150,6 +157,11 @@ EMSCRIPTEN_BINDINGS(Test) {
   function("smart_ptr_function", &smart_ptr_function);
   function("smart_ptr_function_with_params(foo)", &smart_ptr_function);
 
+  function("function_with_callback_param",
+           &function_with_callback_param);
+
+  register_type<CallbackType>("(message: string) => void");
+
   class_<BaseClass>("BaseClass").function("fn", &BaseClass::fn);
 
   class_<DerivedClass, base<BaseClass>>("DerivedClass")

test/other/embind_tsgen.d.ts

@@ -78,4 +78,5 @@ export interface MainModule {
   global_fn(_0: number, _1: number): number;
   smart_ptr_function(_0: ClassWithSmartPtrConstructor): number;
   smart_ptr_function_with_params(foo: ClassWithSmartPtrConstructor): number;
+  function_with_callback_param(_0: (message: string) => void): number;
 }