Pass pointers as integers

[MatthiasKohl]

This is similar to #11 but my issue is that the definition of the opaque type is incomplete when compiling the binding, so I just want to treat the pointer to the type as an integer, then reinterpret_cast it.

struct OpaqueType;  // forward declaration

typedef OpaqueType* opaque_ptr;

namespace nanobind::detail {

template <>
struct type_caster<opaque_ptr> : type_caster<uintptr_t> {};

}  // namespace nanobind::detail

void foo(const opaque_ptr& ptr) { // do something }

...
{
  m.def("foo", &foo);  // here, nanobind still looks for `OpaqueType` instead of casting the pointer as an int
}

This is fairly easy to solve since I can just do:
void foo(const uintptr_t& _ptr) { ptr = reinterpret_cast<const opaque_ptr&>(_ptr); // do something }

But I was wondering if this is the only way ? I'd prefer the type_caster approach because it makes the binding functions a bit cleaner, but nanobind wants me to cast the underlying type instead.

[wjakob]

Could you try this with the very latest version of nanobind, building on type_caster<void> {}; instead? This will produce opaque capsule objects which wrap the pointer.

[MatthiasKohl]

I tried this right now, and unfortunately, it doesn't work.
It fails in two places: one is in nb_descr.h where we get the typeid of the underlying type: ((out[ctr++] = &typeid(Ts)), ...);.

And another must be in nb_func.h (if I understand the error message correctly), where std::is_base_of_v is used with base nanobind::detail::api_tag and the derived type the underlying type.

[wjakob]

Could you post a concrete example of a binding declaration that fails (with extra type caster bits)?

[MatthiasKohl]

This is based on the nanobind example and should have the same issue than my original one here in the question : https://github.com/MatthiasKohl/nanobind-test

EDIT: tested with latest nanobind, with both deriving from type_caster<uintptr_t> and type_caster<void>

[wjakob]

I took a look. It seems like a serious issue -- partial overloads based on a type that isn't even fully defined breaks too many things in nanobind.

[MatthiasKohl]

I see, in that case, I'll keep using uintptr_t on the binding, then cast it to the actual pointer type.
It would be more a nice-to-have to be able to use that type definition for the function signature/docstring etc.