[embind] Allow raw pointers for individual arguments and return values. (#25912)

Previously, allow_raw_pointer<arg<x>> mapped to allow_raw_pointers,
which allowed pointers for all arguments. This PR implements the checks
to verify just the specified argument or return value are allowed
pointers.

Author: brendandahl

system/include/emscripten/wire.h

@@ -510,37 +510,38 @@ struct ret_val {
     static constexpr int index = 0;
 };
 
-/*
+namespace internal {
+
+template <typename InputType, bool EnableWrapper>
+struct RawPointerTransformer {
+    // Use decay to handle references to pointers e.g.(T*&)->(T*).
+    using DecayedType = std::decay_t<InputType>;
+    static constexpr bool ShouldWrap = EnableWrapper && std::is_pointer_v<DecayedType>;
+    using type = std::conditional_t<
+        ShouldWrap,
+        internal::AllowedRawPointer<std::remove_pointer_t<DecayedType>>,
+        InputType
+    >;
+};
+
+} // namespace internal
+
 template<typename Slot>
 struct allow_raw_pointer {
     template<typename InputType, int Index>
-    struct Transform {
-        typedef typename std::conditional<
-            Index == Slot::index,
-            internal::AllowedRawPointer<typename std::remove_pointer<InputType>::type>,
-            InputType
-        >::type type;
-    };
+    struct Transform : internal::RawPointerTransformer<
+        InputType,
+        Index == Slot::index
+    > {};
 };
-*/
 
 // allow all raw pointers
 struct allow_raw_pointers {
     template<typename InputType, int Index>
-    struct Transform {
-        // Use decay to handle references to pointers e.g.(T*&)->(T*).
-        typedef typename std::decay<InputType>::type DecayedType;
-        typedef typename std::conditional<
-            std::is_pointer<DecayedType>::value,
-            internal::AllowedRawPointer<typename std::remove_pointer<DecayedType>::type>,
-            InputType
-        >::type type;
-    };
-};
-
-// this is temporary until arg policies are reworked
-template<typename Slot>
-struct allow_raw_pointer : public allow_raw_pointers {
+    struct Transform : internal::RawPointerTransformer<
+        InputType,
+        true
+    > {};
 };
 
 struct async {

test/embind/test_embind_allow_raw_pointer.cpp

@@ -0,0 +1,21 @@
+#include <emscripten/bind.h>
+
+using namespace emscripten;
+
+class C {};
+
+void onePointerArg(C* ptr) {}
+void twoPointerArg(C* ptr1, C* ptr2) {}
+void sandwich(int a, C* ptr1, int b) {}
+
+C* pointerRet() { return nullptr; }
+C* pointerRetPointerArg(C* ptr) { return nullptr; }
+
+EMSCRIPTEN_BINDINGS(raw_pointers) {
+  class_<C>("C");
+  function("onePointerArg", &onePointerArg, allow_raw_pointer<arg<0>>());
+  function("twoPointerArg", &twoPointerArg, allow_raw_pointer<arg<0>>(), allow_raw_pointer<arg<1>>());
+  function("sandwich", &sandwich, allow_raw_pointer<arg<1>>());
+  function("pointerRet", &pointerRet, allow_raw_pointer<ret_val>());
+  function("pointerRetPointerArg", &pointerRetPointerArg, allow_raw_pointer<ret_val>(), allow_raw_pointer<arg<0>>());
+}

test/embind/test_embind_wrong_arg_allow.cpp

@@ -0,0 +1,12 @@
+#include <emscripten/bind.h>
+
+using namespace emscripten;
+
+class C {};
+
+void passThrough(int arg0, C* ptr) {}
+
+EMSCRIPTEN_BINDINGS(raw_pointers) {
+  class_<C>("C");
+  function("passThrough", &passThrough, allow_raw_pointer<arg<0>>());
+}

test/embind/test_embind_wrong_ret_allow.cpp

@@ -0,0 +1,12 @@
+#include <emscripten/bind.h>
+
+using namespace emscripten;
+
+class C {};
+
+void passThrough(C* ptr) {}
+
+EMSCRIPTEN_BINDINGS(raw_pointers) {
+  class_<C>("C");
+  function("passThrough", &passThrough, allow_raw_pointer<ret_val>());
+}

test/test_other.py

@@ -3362,10 +3362,15 @@ def test_embind_closure_no_dynamic_execution(self):
     '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'],
+    'wrong_ret_allow': ['embind/test_embind_wrong_ret_allow.cpp'],
+    'wrong_arg_allow': ['embind/test_embind_wrong_arg_allow.cpp'],
   })
   def test_embind_no_raw_pointers(self, filename):
     self.assert_fail([EMCC, '-lembind', test_file(filename)], 'Implicitly binding raw pointers is illegal')
 
+  def test_embind_allow_raw_pointer(self):
+    self.emcc(test_file('embind/test_embind_allow_raw_pointer.cpp'), ['-lembind'])
+
   @is_slow_test
   @parameterized({
     '': [],