[embind] Support policies in allow_subclass (#26307)

Add support for passing policies to the allow_subclass method in embind.
This allows the use of constructors that require policies, such as those
taking raw pointers, when enabling C++ subclassing from JavaScript.

Previously, allow_subclass only accepted a constructor argument, making
it impossible to use policies like allow_raw_pointer with the generated
'implement' method.

Fixes #26270

Author: brendandahl

system/include/emscripten/bind.h

@@ -1424,6 +1424,32 @@ struct RegisterClassMethod<FunctionTag<Callable, ReturnType (ThisType, Args...)>
     }
 };
 
+// Helper structs for shifting argument indices when a policy is applied.
+template<typename Slot>
+struct ShiftSlot {
+    using type = Slot;
+};
+
+template<int Index>
+struct ShiftSlot<arg<Index>> {
+    using type = arg<Index + 1>;
+};
+
+template<typename Policy>
+struct ShiftPolicy {
+    using type = Policy;
+};
+
+template<typename Slot>
+struct ShiftPolicy<allow_raw_pointer<Slot>> {
+    using type = allow_raw_pointer<typename ShiftSlot<Slot>::type>;
+};
+
+template<typename Slot>
+struct ShiftPolicy<nonnull<Slot>> {
+    using type = nonnull<typename ShiftSlot<Slot>::type>;
+};
+
 } // end namespace internal
 
 template<typename... ConstructorArgs>
@@ -1532,10 +1558,11 @@ class class_ {
         return *this;
     }
 
-    template<typename WrapperType, typename... ConstructorArgs>
+    template<typename WrapperType, typename... ConstructorArgs, typename... Policies>
     EMSCRIPTEN_ALWAYS_INLINE const class_& allow_subclass(
         const char* wrapperClassName,
-        ::emscripten::constructor<ConstructorArgs...> = ::emscripten::constructor<>()
+        ::emscripten::constructor<ConstructorArgs...> = ::emscripten::constructor<>(),
+        Policies... policies
     ) const {
         using namespace internal;
 
@@ -1549,18 +1576,20 @@ class class_ {
             class_function(
                 "implement",
                 &wrapped_new<WrapperType*, WrapperType, val, ConstructorArgs...>,
-                allow_raw_pointer<ret_val>(), nonnull<ret_val>())
+                allow_raw_pointer<ret_val>(), nonnull<ret_val>(),
+                typename ShiftPolicy<Policies>::type()...)
             .class_function(
                 "extend",
                 &wrapped_extend<WrapperType>)
             ;
     }
 
-    template<typename WrapperType, typename PointerType, typename... ConstructorArgs>
+    template<typename WrapperType, typename PointerType, typename... ConstructorArgs, typename... Policies>
     EMSCRIPTEN_ALWAYS_INLINE const class_& allow_subclass(
         const char* wrapperClassName,
         const char* pointerName,
-        ::emscripten::constructor<ConstructorArgs...> = ::emscripten::constructor<>()
+        ::emscripten::constructor<ConstructorArgs...> = ::emscripten::constructor<>(),
+        Policies... policies
     ) const {
         using namespace internal;
 
@@ -1575,7 +1604,8 @@ class class_ {
             class_function(
                 "implement",
                 &wrapped_new<PointerType, WrapperType, val, ConstructorArgs...>,
-                allow_raw_pointer<ret_val>())
+                allow_raw_pointer<ret_val>(),
+                typename ShiftPolicy<Policies>::type()...)
             .class_function(
                 "extend",
                 &wrapped_extend<WrapperType>)

test/embind/test_embind_subclass_pointer.cpp

@@ -0,0 +1,29 @@
+#include <emscripten/bind.h>
+
+using namespace emscripten;
+
+struct Base {
+    virtual ~Base() {}
+};
+
+struct Sub : Base {
+    Sub(Base* b) {}
+};
+
+struct SubWrapper : wrapper<Sub> {
+    EMSCRIPTEN_WRAPPER(SubWrapper);
+};
+
+EMSCRIPTEN_BINDINGS(test) {
+    class_<Base>("Base")
+        .constructor<>()
+        ;
+
+    class_<Sub>("Sub")
+        .allow_subclass<SubWrapper>("SubWrapper", constructor<Base*>(), allow_raw_pointer<arg<0>>())
+        ;
+}
+
+int main() {
+    return 0;
+}

test/test_other.py

@@ -3381,6 +3381,9 @@ def test_embind_no_raw_pointers(self, filename):
   def test_embind_allow_raw_pointer(self):
     self.emcc(test_file('embind/test_embind_allow_raw_pointer.cpp'), ['-lembind'])
 
+  def test_embind_subclass_pointer(self):
+    self.emcc(test_file('embind/test_embind_subclass_pointer.cpp'), ['-lembind'])
+
   @is_slow_test
   @parameterized({
     '': [],