[emval] Support dynamically-typed conversion to/from val

...for cases where a dynamically given user-defined type is known to be
ABI-compatible with a statically given wire type (e.g., an enum type being
compatible with its underlying type, or a struct type being compatible with
`const void*`; for the latter, a returned `const void*` needs to be transformed
somehow into the desired dynamic type before destructors are run and the
pointed-to object is destroyed).

Author: stbergmann

src/lib/libemval.js

@@ -248,23 +248,33 @@ var LibraryEmVal = {
 
   // Leave id 0 undefined.  It's not a big deal, but might be confusing
   // to have null be a valid method caller.
-  $emval_methodCallers: [undefined],
+  $emval_methodCallers: {list: [undefined], lookup: {}},
 
   $emval_addMethodCaller__deps: ['$emval_methodCallers'],
-  $emval_addMethodCaller: (caller) => {
-    var id = emval_methodCallers.length;
-    emval_methodCallers.push(caller);
+  $emval_addMethodCaller: (sig, caller) => {
+    var id = emval_methodCallers.list.length;
+    emval_methodCallers.list.push(caller);
+    emval_methodCallers.lookup[sig] = id;
     return id;
   },
 
   _emval_create_invoker__deps: [
-    '$emval_addMethodCaller', '$emval_lookupTypes',
+    '$emval_methodCallers', '$emval_addMethodCaller', '$emval_lookupTypes',
     '$createNamedFunction', '$emval_returnValue',
     '$Emval', '$getStringOrSymbol',
   ],
   _emval_create_invoker: (argCount, argTypesPtr, kind) => {
     var GenericWireTypeSize = {{{ 2 * POINTER_SIZE }}};
 
+    var sig = kind.toString();
+    for (var i = 0; i < argCount; ++i) {
+      sig += ',' + {{{ makeGetValue('argTypesPtr', `i*${POINTER_SIZE}`, '*') }}};
+    }
+    var id = emval_methodCallers.lookup[sig];
+    if (id) {
+      return id;
+    }
+
     var [retType, ...argTypes] = emval_lookupTypes(argCount, argTypesPtr);
     var toReturnWire = retType.toWireType.bind(retType);
     var argFromPtr = argTypes.map(type => type.readValueFromPointer.bind(type));
@@ -332,12 +342,12 @@ ${functionBody}
     var invokerFunction = new Function(Object.keys(captures), functionBody)(...Object.values(captures));
 #endif
     var functionName = `methodCaller<(${argTypes.map(t => t.name)}) => ${retType.name}>`;
-    return emval_addMethodCaller(createNamedFunction(functionName, invokerFunction));
+    return emval_addMethodCaller(sig, createNamedFunction(functionName, invokerFunction));
   },
 
   _emval_invoke__deps: ['$getStringOrSymbol', '$emval_methodCallers', '$Emval'],
   _emval_invoke: (caller, handle, methodName, destructorsRef, args) => {
-    return emval_methodCallers[caller](handle, methodName, destructorsRef, args);
+    return emval_methodCallers.list[caller](handle, methodName, destructorsRef, args);
   },
 
   // Same as `_emval_invoke`, just imported into Wasm under a different return type.

system/include/emscripten/val.h

@@ -15,6 +15,7 @@
 #include <array>
 #include <climits>
 #include <emscripten/wire.h>
+#include <functional>
 #include <cstdint> // uintptr_t
 #include <vector>
 #include <type_traits>
@@ -24,6 +25,9 @@
 #include <exception>
 #include <variant>
 #endif
+#if __has_feature(cxx_rtti)
+#include <typeinfo>
+#endif
 
 namespace emscripten {
 
@@ -341,6 +345,14 @@ class EMBIND_VISIBILITY_DEFAULT val {
     return val(internal::_emval_get_module_property(name));
   }
 
+#if __has_feature(cxx_rtti)
+  // Create a `val` from a user-defined dynamic `type` that is ABI-compatible with static type `T`:
+  template<typename T>
+  static val dyn(const std::type_info& type, T&& value) {
+    return internalDynCast<val>(internal::TypeID<val>::get(), &type, nullptr, std::forward<T>(value), std::identity());
+  }
+#endif
+
   template<typename T, typename... Policies>
   explicit val(T&& value, Policies...) {
     using namespace internal;
@@ -516,6 +528,14 @@ class EMBIND_VISIBILITY_DEFAULT val {
     return internalCall<EM_INVOKER_KIND::CAST, WithPolicies<Policies...>, T>(as_handle(), nullptr, *this);
   }
 
+#if __has_feature(cxx_rtti)
+  // Retrieve a user-defined dynamic `type` that is ABI-compatible with static type `T`:
+  template<typename T, typename TransformFn>
+  auto dyn_as(const std::type_info& type, TransformFn transform) const {
+    return internalDynCast<T>(&type, internal::TypeID<val>::get(), as_handle(), *this, transform);
+  }
+#endif
+
 // Prefer calling val::typeOf() over val::typeof(), since this form works in both C++11 and GNU++11 build modes. "typeof" is a reserved word in GNU++11 extensions.
   val typeOf() const {
     return val(internal::_emval_typeof(as_handle()));
@@ -573,42 +593,68 @@ class EMBIND_VISIBILITY_DEFAULT val {
   template<typename WrapperType>
   friend val internal::wrapped_extend(const std::string& , const val& );
 
-  template<internal::EM_INVOKER_KIND Kind, typename Policy, typename Ret, typename... Args>
-  static Ret internalCall(EM_VAL handle, const char *methodName, Args&&... args) {
-    static_assert(!std::is_lvalue_reference<Ret>::value,
-                  "Cannot create a lvalue reference out of a JS value.");
-
+  template<typename Ret, typename... Args>
+  static auto internalDoCall(internal::EM_INVOKER caller, EM_VAL handle, const char* methodName, internal::EM_DESTRUCTORS* destructors, Args&&... args) {
     using namespace internal;
 
     using RetWire = BindingType<Ret>::WireType;
 
-    static constexpr typename Policy::template ArgTypeList<Ret, Args...> argTypes;
-    thread_local EM_INVOKER mc = _emval_create_invoker(argTypes.getCount(), argTypes.getTypes(), Kind);
-
     WireTypePack<Args...> argv(std::forward<Args>(args)...);
-    EM_DESTRUCTORS destructors = nullptr;
 
     RetWire result;
     if constexpr (std::is_integral<RetWire>::value && sizeof(RetWire) == 8) {
       // 64-bit integers can't go through "generic wire type" because double and int64 have different ABI.
       result = static_cast<RetWire>(_emval_invoke_i64(
-        mc,
+        caller,
         handle,
         methodName,
-        &destructors,
+        destructors,
         argv));
     } else {
       result = GenericWireTypeConverter<RetWire>::from(_emval_invoke(
-        mc,
+        caller,
         handle,
         methodName,
-        &destructors,
+        destructors,
         argv));
     }
+    return result;
+  }
+
+  template<internal::EM_INVOKER_KIND Kind, typename Policy, typename Ret, typename... Args>
+  static Ret internalCall(EM_VAL handle, const char *methodName, Args&&... args) {
+    static_assert(!std::is_lvalue_reference<Ret>::value,
+                  "Cannot create a lvalue reference out of a JS value.");
+
+    using namespace internal;
+
+    static constexpr typename Policy::template ArgTypeList<Ret, Args...> argTypes;
+    thread_local EM_INVOKER mc = _emval_create_invoker(argTypes.getCount(), argTypes.getTypes(), Kind);
+
+    EM_DESTRUCTORS destructors = nullptr;
+
+    auto result = internalDoCall<Ret>(mc, handle, methodName, &destructors, std::forward<Args>(args)...);
     DestructorsRunner rd(destructors);
     return BindingType<Ret>::fromWireType(result);
   }
 
+  template<typename Ret, typename Arg, typename TransformFn>
+  static auto internalDynCast(internal::TYPEID retType, internal::TYPEID argType, EM_VAL handle, Arg&& arg, TransformFn transform) {
+    static_assert(!std::is_lvalue_reference<Ret>::value,
+                  "Cannot create a lvalue reference out of a JS value.");
+
+    using namespace internal;
+
+    TYPEID const argTypes[2] { retType, argType };
+    EM_INVOKER mc = _emval_create_invoker(2, argTypes, EM_INVOKER_KIND::CAST);
+
+    EM_DESTRUCTORS destructors = nullptr;
+
+    auto result = internalDoCall<Ret>(mc, handle, nullptr, &destructors, std::forward<Arg>(arg));
+    DestructorsRunner rd(destructors);
+    return transform(BindingType<Ret>::fromWireType(result));
+  }
+
   template<typename T>
   val val_ref(const T& v) const {
     return val(v);