fix: some pedantic warnings

Signed-off-by: Henry Schreiner <[email protected]>

Author: henryiii

tests/test_class_sh_trampoline_shared_ptr_cpp_arg.cpp

@@ -30,7 +30,7 @@ std::shared_ptr<SpBase> pass_through_shd_ptr(const std::shared_ptr<SpBase> &obj)
 
 struct PySpBase : SpBase, py::trampoline_self_life_support {
     using SpBase::SpBase;
-    bool is_base_used() override { PYBIND11_OVERRIDE(bool, SpBase, is_base_used); }
+    bool is_base_used() override { PYBIND11_OVERRIDE(bool, SpBase, is_base_used, ); }
 };
 
 struct SpBaseTester {

tests/test_class_sh_trampoline_unique_ptr.cpp

@@ -39,10 +39,10 @@ namespace class_sh_trampoline_unique_ptr {
 class PyClass : public Class, public py::trampoline_self_life_support {
 public:
     std::unique_ptr<Class> clone() const override {
-        PYBIND11_OVERRIDE_PURE(std::unique_ptr<Class>, Class, clone);
+        PYBIND11_OVERRIDE_PURE(std::unique_ptr<Class>, Class, clone, );
     }
 
-    int foo() const override { PYBIND11_OVERRIDE_PURE(int, Class, foo); }
+    int foo() const override { PYBIND11_OVERRIDE_PURE(int, Class, foo, ); }
 };
 
 } // namespace class_sh_trampoline_unique_ptr

tests/test_class_sh_virtual_py_cpp_mix.cpp

@@ -32,13 +32,13 @@ int get_from_cpp_unique_ptr(std::unique_ptr<Base> b) { return b->get() + 5000; }
 struct BaseVirtualOverrider : Base, py::trampoline_self_life_support {
     using Base::Base;
 
-    int get() const override { PYBIND11_OVERRIDE(int, Base, get); }
+    int get() const override { PYBIND11_OVERRIDE(int, Base, get, ); }
 };
 
 struct CppDerivedVirtualOverrider : CppDerived, py::trampoline_self_life_support {
     using CppDerived::CppDerived;
 
-    int get() const override { PYBIND11_OVERRIDE(int, CppDerived, get); }
+    int get() const override { PYBIND11_OVERRIDE(int, CppDerived, get, ); }
 };
 
 } // namespace class_sh_virtual_py_cpp_mix

tests/test_cross_module_rtti/bindings.cpp

@@ -5,10 +5,10 @@
 class BaseTrampoline : public lib::Base, public pybind11::trampoline_self_life_support {
 public:
     using lib::Base::Base;
-    int get() const override { PYBIND11_OVERLOAD(int, lib::Base, get); }
+    int get() const override { PYBIND11_OVERLOAD(int, lib::Base, get, ); }
 };
 
-PYBIND11_MODULE(test_cross_module_rtti_bindings, m) {
+PYBIND11_MODULE(test_cross_module_rtti_bindings, m, pybind11::mod_gil_not_used()) {
     pybind11::classh<lib::Base, BaseTrampoline>(m, "Base")
         .def(pybind11::init<int, int>())
         .def_readwrite("a", &lib::Base::a)

tests/test_embed/test_interpreter.cpp

@@ -45,8 +45,8 @@ class Widget {
 class PyWidget final : public Widget {
     using Widget::Widget;
 
-    int the_answer() const override { PYBIND11_OVERRIDE_PURE(int, Widget, the_answer); }
-    std::string argv0() const override { PYBIND11_OVERRIDE_PURE(std::string, Widget, argv0); }
+    int the_answer() const override { PYBIND11_OVERRIDE_PURE(int, Widget, the_answer, ); }
+    std::string argv0() const override { PYBIND11_OVERRIDE_PURE(std::string, Widget, argv0, ); }
 };
 
 class test_override_cache_helper {
@@ -62,7 +62,7 @@ class test_override_cache_helper {
 };
 
 class test_override_cache_helper_trampoline : public test_override_cache_helper {
-    int func() override { PYBIND11_OVERRIDE(int, test_override_cache_helper, func); }
+    int func() override { PYBIND11_OVERRIDE(int, test_override_cache_helper, func, ); }
 };
 
 PYBIND11_EMBEDDED_MODULE(widget_module, m, py::multiple_interpreters::per_interpreter_gil()) {

tests/test_potentially_slicing_weak_ptr.cpp

@@ -56,12 +56,12 @@ const char *determine_trampoline_state(const std::shared_ptr<VB> &sp) {
 
 struct PyVirtBaseSH : VirtBaseSH, py::trampoline_self_life_support, trampoline_is_alive_simple {
     using VirtBaseSH::VirtBaseSH;
-    int get_code() override { PYBIND11_OVERRIDE(int, VirtBaseSH, get_code); }
+    int get_code() override { PYBIND11_OVERRIDE(int, VirtBaseSH, get_code, ); }
 };
 
 struct PyVirtBaseSP : VirtBaseSP, trampoline_is_alive_simple { // self-life-support not available
     using VirtBaseSP::VirtBaseSP;
-    int get_code() override { PYBIND11_OVERRIDE(int, VirtBaseSP, get_code); }
+    int get_code() override { PYBIND11_OVERRIDE(int, VirtBaseSP, get_code, ); }
 };
 
 template <typename VB>

tests/test_smart_ptr.cpp

@@ -313,11 +313,11 @@ struct holder_helper<ref<T>> {
 PYBIND11_DECLARE_HOLDER_TYPE(T, ref<T>, true)
 PYBIND11_DECLARE_HOLDER_TYPE(T, const_only_shared_ptr<T>, true)
 // The following is not required anymore for std::shared_ptr, but it should compile without error:
-PYBIND11_DECLARE_HOLDER_TYPE(T, std::shared_ptr<T>)
-PYBIND11_DECLARE_HOLDER_TYPE(T, huge_unique_ptr<T>)
-PYBIND11_DECLARE_HOLDER_TYPE(T, custom_unique_ptr<T>)
-PYBIND11_DECLARE_HOLDER_TYPE(T, shared_ptr_with_addressof_operator<T>)
-PYBIND11_DECLARE_HOLDER_TYPE(T, unique_ptr_with_addressof_operator<T>)
+PYBIND11_DECLARE_HOLDER_TYPE(T, std::shared_ptr<T>, )
+PYBIND11_DECLARE_HOLDER_TYPE(T, huge_unique_ptr<T>, )
+PYBIND11_DECLARE_HOLDER_TYPE(T, custom_unique_ptr<T>, )
+PYBIND11_DECLARE_HOLDER_TYPE(T, shared_ptr_with_addressof_operator<T>, )
+PYBIND11_DECLARE_HOLDER_TYPE(T, unique_ptr_with_addressof_operator<T>, )
 
 namespace holder_caster_traits_test {
 struct example_base {};

tests/test_virtual_functions.cpp

@@ -145,7 +145,7 @@ class NCVirt {
 class NCVirtTrampoline : public NCVirt {
 #if !defined(__INTEL_COMPILER) && !defined(__CUDACC__) && !defined(__PGIC__)
     NonCopyable get_noncopyable(int a, int b) override {
-        PYBIND11_OVERRIDE(NonCopyable, NCVirt, get_noncopyable, a, b);
+        PYBIND11_OVERRIDE(NonCopyable, NCVirt, get_noncopyable, a, b, );
     }
 #endif
     Movable get_movable(int a, int b) override {
@@ -220,7 +220,7 @@ class test_override_cache_helper {
 };
 
 class test_override_cache_helper_trampoline : public test_override_cache_helper {
-    int func() override { PYBIND11_OVERRIDE(int, test_override_cache_helper, func); }
+    int func() override { PYBIND11_OVERRIDE(int, test_override_cache_helper, func, ); }
 };
 
 inline int test_override_cache(std::shared_ptr<test_override_cache_helper> const &instance) {
@@ -280,7 +280,7 @@ TEST_SUBMODULE(virtual_functions, m) {
             py::print("PyA.f()");
             // This convolution just gives a `void`, but tests that PYBIND11_TYPE() works to
             // protect a type containing a ,
-            PYBIND11_OVERRIDE(PYBIND11_TYPE(typename std::enable_if<true, void>::type), A, f);
+            PYBIND11_OVERRIDE(PYBIND11_TYPE(typename std::enable_if<true, void>::type), A, f, );
         }
     };
 
@@ -303,7 +303,7 @@ TEST_SUBMODULE(virtual_functions, m) {
         ~PyA2() override { py::print("PyA2.~PyA2()"); }
         void f() override {
             py::print("PyA2.f()");
-            PYBIND11_OVERRIDE(void, A2, f);
+            PYBIND11_OVERRIDE(void, A2, f, );
         }
     };
 
@@ -371,26 +371,26 @@ TEST_SUBMODULE(virtual_functions, m) {
     public:
         using OverrideTest::OverrideTest;
         std::string str_value() override {
-            PYBIND11_OVERRIDE(std::string, OverrideTest, str_value);
+            PYBIND11_OVERRIDE(std::string, OverrideTest, str_value, );
         }
         // Not allowed (enabling the below should hit a static_assert failure): we can't get a
         // reference to a python numeric value, since we only copy values in the numeric type
         // caster:
 #ifdef PYBIND11_NEVER_DEFINED_EVER
         std::string &str_ref() override {
-            PYBIND11_OVERRIDE(std::string &, OverrideTest, str_ref);
+            PYBIND11_OVERRIDE(std::string &, OverrideTest, str_ref, );
         }
 #endif
         // But we can work around it like this:
     private:
         std::string _tmp;
-        std::string str_ref_helper() { PYBIND11_OVERRIDE(std::string, OverrideTest, str_ref); }
+        std::string str_ref_helper() { PYBIND11_OVERRIDE(std::string, OverrideTest, str_ref, ); }
 
     public:
         std::string &str_ref() override { return _tmp = str_ref_helper(); }
 
-        A A_value() override { PYBIND11_OVERRIDE(A, OverrideTest, A_value); }
-        A &A_ref() override { PYBIND11_OVERRIDE(A &, OverrideTest, A_ref); }
+        A A_value() override { PYBIND11_OVERRIDE(A, OverrideTest, A_value, ); }
+        A &A_ref() override { PYBIND11_OVERRIDE(A &, OverrideTest, A_ref, ); }
     };
 
     py::class_<OverrideTest::A>(m, "OverrideTest_A")
@@ -502,7 +502,7 @@ class PyC_Repeat : public C_Repeat {
     std::string say_something(unsigned times) override {
         PYBIND11_OVERRIDE(std::string, C_Repeat, say_something, times);
     }
-    double lucky_number() override { PYBIND11_OVERRIDE(double, C_Repeat, lucky_number, ); }
+    double lucky_number() override { PYBIND11_OVERRIDE(double, C_Repeat, lucky_number); }
 };
 class PyD_Repeat : public D_Repeat {
 public: