Fix passing of extra arguments to py_safe_call_once (#7585)

da-woods · da-woods · commit d7d6ae5b10df · 2026-04-01T07:56:22.000+01:00
It wasn't compiling because I wasn't using `std::forward` correctly -
they should be consistently forwarding references.

Being able to pass arguments is useful because it can avoid the need for
a closure in some cases.
diff --git a/Cython/Includes/libcpp/mutex.pxd b/Cython/Includes/libcpp/mutex.pxd
@@ -232,7 +232,7 @@ cdef extern from *:
     }
 
     template <typename Callable, typename ... Args>
-    void __pyx_cpp_py_safe_call_once(std::once_flag& flag, Callable& callable, Args&&... args) {
+    void __pyx_cpp_py_safe_call_once(std::once_flag& flag, Callable&& callable, Args&&... args) {
         class PyException : public std::exception {
         public:
             using std::exception::exception;
@@ -246,7 +246,7 @@ cdef extern from *:
 
         try {
             std::call_once(flag,
-                [&](Args& ...args) {
+                [&](Args&& ...args) {
                     // Make sure we have the GIL
                     PyGILState_STATE gil_state;
                     int had_gil_on_call = __Pyx_UnknownThreadStateDefinitelyHadGil(thread_state);
diff --git a/tests/run/cpp_mutex.pyx b/tests/run/cpp_mutex.pyx
@@ -270,6 +270,79 @@ def test_py_safe_once_cdef_nogil():
     print(global_value)
 
 
+cdef void _do_lazy_init(void *o):
+    as_py = <SomeCdefClass>o
+    as_py._lazy_init_value = as_py.initial_value * 2
+    as_py.initial_value = -1  # change it so it doesn't work a second time
+
+cdef class SomeCdefClass:
+    cdef py_safe_once_flag flag
+    cdef double initial_value
+    cdef double _lazy_init_value
+
+    def __cinit__(self, initial_value):
+        self.initial_value = initial_value
+
+    @property
+    def lazy_init_value(self):
+        # Pass as void* because we can't pass object to variadic functions
+        py_safe_call_once(self.flag, _do_lazy_init, <void*>self)
+        return self._lazy_init_value
+
+    @property
+    def lazy_init_lvalue(self):
+        # Pass as void* because we can't pass object to variadic functions
+        cdef void* self_v = <void*>self
+        py_safe_call_once(self.flag, _do_lazy_init, self_v)
+        return self._lazy_init_value
+
+def test_py_safe_call_once_with_arg_passing(v):
+    """
+    >>> test_py_safe_call_once_with_arg_passing(20)
+    40.0
+    >>> test_py_safe_call_once_with_arg_passing(1)
+    2.0
+    """
+    inst = SomeCdefClass(v)
+    v1 = inst.lazy_init_value
+    v2 = inst.lazy_init_value
+    assert v1 == v2
+    return v1
+
+def test_py_safe_call_once_with_lvalue_arg_passing(v):
+    """
+    >>> test_py_safe_call_once_with_lvalue_arg_passing(20)
+    40.0
+    >>> test_py_safe_call_once_with_lvalue_arg_passing(1)
+    2.0
+    """
+    inst = SomeCdefClass(v)
+    v1 = inst.lazy_init_lvalue
+    v2 = inst.lazy_init_lvalue
+    assert v1 == v2
+    return v1
+
+
+cdef void print_arg(int arg) noexcept:
+    print(arg)
+
+ctypedef void (*void_int_func)(int) noexcept
+
+cdef void_int_func get_print_arg() noexcept:
+    return print_arg
+
+def test_py_safe_call_once_rvalue_func(int arg):
+    """
+    >>> test_py_safe_call_once_rvalue_func(5)
+    5
+    >>> test_py_safe_call_once_rvalue_func(0)
+    0
+    """
+    cdef py_safe_once_flag flag
+    py_safe_call_once(flag, get_print_arg(), arg)
+    py_safe_call_once(flag, get_print_arg(), arg)
+
+
 def test_scoped_lock():
     """
     >>> test_scoped_lock()
