nb::ref<T>, std::shared<T> and T* allow casting from None if elements of a container like std::vector<nb::ref<T>>

[ramenguy99]

Hi, I am using types like std::vector<nb::ref<T>> as function arguments in multiple places. I just noticed that nb::ref and other pointer types like std::shared_ptr<T> and T* implicitly allow casting from the python None object when used inside containers.

For example:

void foo(std::vector<nb::ref<T>> a);

can be called with:

foo([None])

The same cast is also allowed for other containers like std::tuple and std::array.

From a quick look at the call stack of this cast it looks like the cast to null is allowed by:

nanobind/src/nb_type.cpp

Lines 1490 to 1496 in 109af19

	bool nb_type_get(const std::type_info *cpp_type, PyObject *src, uint8_t flags,
	cleanup_list *cleanup, void **out) noexcept {
	// Convert None -> nullptr
	if (src == Py_None) {
	*out = nullptr;
	return true;
	}

This can make it quite inconvenient because it requires checks in multiple places if elements of container objects are actually null pointers, risking null derefs if this is forgot. Due to the default policy of not implicitly casting None to pointer types for function arguments I would have expected the same rule to apply here, and require something like std::vector<std::optional<nb::ref<T>>> if None is acceptable.

Another option would be to have an additional reference type that is more strict with casting and would not allow None, something like NonNullRef<T>, but I am not sure if this would be preferred. In my (limited) experience I almost always want nb::ref to not be null in the first place.

Is there a recommended way to disallow None for this kind of use case?