[embind] Add pointer policies for val's call, operator(), and new_.

After #24175, pointer policies were required in more places, but there
was no way to pass the policy into val's `call`, `operator()`, and `new_`
methods and use pointers.

All of these methods take variadic template arguments already
which made passing separate variadic policy arguments challenging. I used
some C++14/17 tricks to separate the regular arguments and policy
arguments.

Author: brendandahl

system/include/emscripten/val.h

@@ -345,7 +345,7 @@ class EMBIND_VISIBILITY_DEFAULT val {
   explicit val(T&& value, Policies...) {
     using namespace internal;
 
-    new (this) val(internalCall<EM_INVOKER_KIND::CAST, WithPolicies<Policies...>, val>(nullptr, nullptr, std::forward<T>(value)));
+    new (this) val(internalCallWithPolicy<EM_INVOKER_KIND::CAST, WithPolicies<Policies...>, val>(nullptr, nullptr, std::forward<T>(value)));
   }
 
   val() : val(EM_VAL(internal::_EMVAL_UNDEFINED)) {}
@@ -492,28 +492,28 @@ class EMBIND_VISIBILITY_DEFAULT val {
   val new_(Args&&... args) const {
     using namespace internal;
 
-    return internalCall<EM_INVOKER_KIND::CONSTRUCTOR, WithPolicies<>, val>(as_handle(), nullptr, std::forward<Args>(args)...);
+    return internalCall<EM_INVOKER_KIND::CONSTRUCTOR, val>(as_handle(), nullptr, std::forward<Args>(args)...);
   }
 
   template<typename... Args>
   val operator()(Args&&... args) const {
     using namespace internal;
 
-    return internalCall<EM_INVOKER_KIND::FUNCTION, WithPolicies<>, val>(as_handle(), nullptr, std::forward<Args>(args)...);
+    return internalCall<EM_INVOKER_KIND::FUNCTION, val>(as_handle(), nullptr, std::forward<Args>(args)...);
   }
 
   template<typename ReturnValue, typename... Args>
   ReturnValue call(const char* name, Args&&... args) const {
     using namespace internal;
 
-    return internalCall<EM_INVOKER_KIND::METHOD, WithPolicies<>, ReturnValue>(as_handle(), name, std::forward<Args>(args)...);
+    return internalCall<EM_INVOKER_KIND::METHOD, ReturnValue>(as_handle(), name, std::forward<Args>(args)...);
   }
 
   template<typename T, typename ...Policies>
   T as(Policies...) const {
     using namespace internal;
 
-    return internalCall<EM_INVOKER_KIND::CAST, WithPolicies<Policies...>, T>(as_handle(), nullptr, *this);
+    return internalCallWithPolicy<EM_INVOKER_KIND::CAST, WithPolicies<Policies...>, T>(as_handle(), nullptr, *this);
   }
 
 // 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.
@@ -573,8 +573,27 @@ 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>
+  template<internal::EM_INVOKER_KIND Kind, typename Ret, typename... Args>
   static Ret internalCall(EM_VAL handle, const char *methodName, Args&&... args) {
+    using namespace internal;
+#if __cplusplus >= 201703L
+    using Policy = WithPolicies<FilterTypes<isPolicy, Args...>>;
+    auto filteredArgs = Filter<isNotPolicy>(args...);
+    return std::apply(
+        [&](auto&&... filteredArgs) {
+          return internalCallWithPolicy<Kind, Policy, Ret>(handle, methodName, std::forward<decltype(filteredArgs)>(filteredArgs)...);
+        },
+        filteredArgs
+    );
+#else
+    // When std::apply is not available allow pointers by default. std::apply
+    // could be polyfilled, but it requires a lot of code.
+    return internalCallWithPolicy<Kind, WithPolicies<allow_raw_pointers>, Ret>(handle, methodName, std::forward<decltype(args)>(args)...);
+#endif
+  }
+
+  template<internal::EM_INVOKER_KIND Kind, typename Policy, typename Ret, typename... Args>
+  static Ret internalCallWithPolicy(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.");
 

system/include/emscripten/wire.h

@@ -265,6 +265,9 @@ struct WithPolicies {
     };
 };
 
+template<typename... Policies>
+struct WithPolicies<std::tuple<Policies...>> : WithPolicies<Policies...> {};
+
 // BindingType<T>
 
 // The second typename is an unused stub so it's possible to
@@ -672,6 +675,34 @@ using isAsync = disjunction<std::is_same<async, Policies>...>;
 template<typename... Policies>
 using isNonnullReturn = disjunction<std::is_same<nonnull<ret_val>, Policies>...>;
 
+// Build a tuple type that contains all the types where the predicate is true.
+// e.g. FilterTypes<std::is_integral, int, char, float> would return std::tuple<int, char>.
+template <template <class> class Predicate, class... T>
+using FilterTypes = decltype(std::tuple_cat(
+        std::declval<
+            typename std::conditional<
+                Predicate<T>::value,
+                std::tuple<T>,
+                std::tuple<>
+            >::type
+        >()...
+    ));
+
+#if __cplusplus >= 201402L
+// Build a tuple that contains all the args where the predicate is true.
+template<template <class> class Predicate, typename... Args>
+auto Filter(Args&&... args) {
+    return std::tuple_cat(
+        std::get<Predicate<typename std::decay_t<Args>>::value ? 0 : 1>(
+            std::make_tuple(
+                [](auto&& arg) { return std::forward_as_tuple(std::forward<decltype(arg)>(arg)); },
+                [](auto&&) { return std::tuple<>(); }
+            )
+        )(std::forward<Args>(args))...
+    );
+}
+#endif
+
 } // namespace internal
 
 } // namespace emscripten

test/embind/test_embind_no_raw_pointers_val_call.cpp

@@ -0,0 +1,6 @@
+#include <emscripten/bind.h>
+#include <emscripten/val.h>
+int main() {
+  void* x = nullptr;
+  emscripten::val::global().call<void>("test", x);
+}

test/embind/test_embind_no_raw_pointers_val_invoke.cpp

@@ -0,0 +1,6 @@
+#include <emscripten/bind.h>
+#include <emscripten/val.h>
+int main() {
+  void* x = nullptr;
+  emscripten::val::global()("test", x);
+}

test/embind/test_embind_no_raw_pointers_val_new.cpp

@@ -0,0 +1,6 @@
+#include <emscripten/bind.h>
+#include <emscripten/val.h>
+int main() {
+  void* x = nullptr;
+  emscripten::val::global().new_(x);
+}

test/embind/test_val.cpp

@@ -41,6 +41,7 @@ EMSCRIPTEN_BINDINGS(test_bindings) {
 
 int main() {
   printf("start\n");
+  Dummy *dummy;
 
   test("val array()");
   val::global().set("a", val::array());
@@ -408,6 +409,14 @@ int main() {
   ensure_js("a instanceof A");
   ensure_js("a.arg1 == 2");
   ensure_js("a.arg2 == 'b'");
+#if __cplusplus >= 201703L
+  dummy = new Dummy();
+  val::global().set("a", val::global("A").new_(dummy, val("b"), allow_raw_pointers()));
+  ensure_js("a instanceof A");
+  ensure_js("a.arg1 instanceof Module.Dummy");
+  ensure_js("a.arg2 == 'b'");
+  delete dummy;
+#endif
 
   test("template<typename T> val operator[](const T& key)");
   EM_ASM(
@@ -457,6 +466,11 @@ int main() {
   );
   ensure(val::global("f1")(val(2),val("3")).as<int>() == 2);
   ensure(val::global("f2")(val(2),val("3")).as<string>() == "3");
+#if __cplusplus >= 201703L
+  dummy = new Dummy();
+  ensure(val::global("f1")(dummy, 42, allow_raw_pointers()).as<Dummy*>(allow_raw_pointers()) == dummy);
+  delete dummy;
+#endif
 
   test("template<typename ReturnValue, typename... Args> ReturnValue call(const char* name, Args&&... args)");
   EM_ASM(
@@ -473,6 +487,18 @@ int main() {
     c = new C;
   );
   ensure(val::global("c").call<int>("method", val(2)) == 2);
+#if __cplusplus >= 201703L
+  dummy = new Dummy();
+  EM_ASM(
+    globalThis.C = function() {
+      this.method = function(arg) { this.obj = arg; };
+    };
+    c = new C;
+  );
+  val::global("c").call<void>("method", dummy, allow_raw_pointers());
+  ensure_js("c.obj instanceof Module.Dummy");
+  delete dummy;
+#endif
 
   test("template<typename T, typename ...Policies> T as(Policies...)");
   EM_ASM(
@@ -677,7 +703,7 @@ int main() {
   ensure_js("a == '😃 = \U0001F603 is :-D'");
 
   test("val set() with policy");
-  Dummy *dummy = new Dummy();
+  dummy = new Dummy();
   val::global().set("a", dummy, allow_raw_pointers());
   ensure_js("a instanceof Module.Dummy");
   val::global().set("a", val::null());

test/test_other.py

@@ -3332,6 +3332,9 @@ def test_embind_closure_no_dynamic_execution(self):
     'val_1': ['embind/test_embind_no_raw_pointers_val_1.cpp'],
     'val_2': ['embind/test_embind_no_raw_pointers_val_2.cpp'],
     'val_3': ['embind/test_embind_no_raw_pointers_val_3.cpp'],
+    'val_invoke': ['embind/test_embind_no_raw_pointers_val_invoke.cpp'],
+    'val_call': ['embind/test_embind_no_raw_pointers_val_call.cpp'],
+    'val_new': ['embind/test_embind_no_raw_pointers_val_new.cpp'],
   })
   def test_embind_no_raw_pointers(self, filename):
     stderr = self.expect_fail([EMCC, '-lembind', test_file(filename)])