Do minimal processing of ignored functions

- Still need to track whether they're an overload or not, otherwise we
  run into ambiguity

robotpy_build/autowrap/cxxparser.py

@@ -286,6 +286,7 @@ class ClassStateData(typing.NamedTuple):
 
     # have to defer processing these
     defer_protected_methods: typing.List[Method]
+    defer_private_nonvirtual_methods: typing.List[Method]
     defer_private_virtual_methods: typing.List[Method]
     defer_protected_fields: typing.List[Field]
 
@@ -750,6 +751,7 @@ def on_class_start(self, state: AWClassBlockState) -> typing.Optional[bool]:
             typealias_names=typealias_names,
             # Method data
             defer_protected_methods=[],
+            defer_private_nonvirtual_methods=[],
             defer_private_virtual_methods=[],
             defer_protected_fields=[],
             # Trampoline data
@@ -983,8 +985,11 @@ def on_class_method(self, state: AWClassBlockState, method: Method) -> None:
             self._on_class_method(state, method, cctx.wrapped_public_methods)
         elif access == "protected":
             cdata.defer_protected_methods.append(method)
-        elif access == "private" and is_polymorphic:
-            cdata.defer_private_virtual_methods.append(method)
+        elif access == "private":
+            if is_polymorphic:
+                cdata.defer_private_virtual_methods.append(method)
+            else:
+                cdata.defer_private_nonvirtual_methods.append(method)
 
     def _on_class_method(
         self,
@@ -1152,6 +1157,23 @@ def _on_class_method(
                     f"{cdata.cls_key}::{method_name}: has && ref-qualifier which cannot be directly bound by pybind11, must specify cpp_code or ignore_py"
                 )
 
+    def _on_class_method_process_overload_only(
+        self, state: AWClassBlockState, method: Method
+    ):
+        cdata = state.user_data
+
+        method_name = self._get_fn_name(method)
+        if not method_name:
+            return
+
+        self.gendata.get_function_data(
+            method_name,
+            method,
+            cdata.cls_key,
+            cdata.data,
+            True,
+        )
+
     def _is_copy_move_constructor(
         self, cctx: ClassContext, first_type_param: DecoratedType
     ) -> bool:
@@ -1242,6 +1264,17 @@ def on_class_end(self, state: AWClassBlockState) -> None:
                 f"{cdata.cls_key} has trampoline_inline_code specified, but there is no trampoline!"
             )
 
+        else:
+            # still need to do minimal processing to add deferred functions
+            # to the overload tracker, otherwise we won't handle it correctly
+            for m in cdata.defer_protected_methods:
+                self._on_class_method_process_overload_only(state, m)
+            for m in cdata.defer_private_virtual_methods:
+                self._on_class_method_process_overload_only(state, m)
+
+        for m in cdata.defer_private_nonvirtual_methods:
+            self._on_class_method_process_overload_only(state, m)
+
     #
     # Function/method processing
     #

tests/cpp/rpytest/ft/include/overloads.h

@@ -51,6 +51,12 @@ struct OverloadedObject
         return 0x4;
     }
 
+    void overloaded_private(int a) {}
+
 private:
+
+    // this causes errors if we don't account for it
+    void overloaded_private(int a, int b) {}
+
     int o;
 };