Remove nb::any nd-array size tag

This is the first in a sequence of two API-breaking commits that
repurposes ``nb::any`` to be a wrapper type for ``typing.Any``.

To fix code impacted by this commit, change

 ``nb::shape<.., nb::any, ..>`` to ``nb::shape<.., -1, ..>``.

Author: wjakob

docs/api_extra.rst

@@ -799,19 +799,19 @@ nanobind does not support non-standard types as documented in the section on
 Shape
 +++++
 
-.. cpp:class:: template <size_t... Is> shape
+.. cpp:class:: template <ssize_t... Is> shape
 
    Require the array to have ``sizeof...(Is)`` dimensions. Each entry of `Is`
    specifies a fixed size constraint for that specific dimension. An entry
-   equal to :cpp:var:`any` indicates that any size should be accepted for this
+   equal to ``-1`` indicates that *any* size should be accepted for this
    dimension.
 
+   (An alias named ``nb::any`` representing ``-1`` was removed in nanobind 2).
+
 .. cpp:class:: template <size_t N> ndim
 
    Alternative to the above that only constrains the array dimension.
-   ``nb::ndim<2>`` is equivalent to ``nb::shape<nb::any, nb::any>``.
-
-.. cpp:var:: constexpr size_t any = (size_t) -1
+   ``nb::ndim<2>`` is equivalent to ``nb::shape<-1, -1>``.
 
 Contiguity
 ++++++++++

docs/changelog.rst

@@ -155,6 +155,14 @@ noteworthy:
   nanobind versions but was awkward to use, as it required the user to provide
   a custom type formatter. This release makes the interface more convenient.
 
+* The ``nb::any`` placeholder to specify an unconstrained
+  :cpp:class:`nb::ndarray <ndarray>` axis was removed. This name was given to a
+  new wrapper type :cpp:class:`nb::any`` indicating ``typing.Any``-typed
+  values.
+
+  All use of ``nb::any`` in existing code must be replaced with ``-1`` (for
+  example, ``nb::shape<3, nb::any, 4>`` → ``nb::shape<3, -1, 4>``).
+
 * :ref:`Keyword-only arguments <kw_only>` are now supported, and can be
   indicated using the new :cpp:struct:`nb::kw_only() <kw_only>` function
   annotation. (PR `#448 <https://github.com/wjakob/nanobind/pull/448>`__).

include/nanobind/eigen/dense.h

@@ -95,9 +95,9 @@ using array_for_eigen_t = ndarray<
     numpy,
     std::conditional_t<
         ndim_v<T> == 1,
-        shape<(size_t) T::SizeAtCompileTime>,
-        shape<(size_t) T::RowsAtCompileTime,
-              (size_t) T::ColsAtCompileTime>>,
+        shape<T::SizeAtCompileTime>,
+        shape<T::RowsAtCompileTime,
+              T::ColsAtCompileTime>>,
     std::conditional_t<
         is_contiguous_v<T>,
         std::conditional_t<

include/nanobind/eigen/sparse.h

@@ -39,8 +39,8 @@ template <typename T> struct type_caster<T, enable_if_t<is_eigen_sparse_matrix_v
 
     static constexpr bool RowMajor = T::IsRowMajor;
 
-    using ScalarNDArray = ndarray<numpy, Scalar, shape<any>>;
-    using StorageIndexNDArray = ndarray<numpy, StorageIndex, shape<any>>;
+    using ScalarNDArray = ndarray<numpy, Scalar, shape<-1>>;
+    using StorageIndexNDArray = ndarray<numpy, StorageIndex, shape<-1>>;
 
     using ScalarCaster = make_caster<ScalarNDArray>;
     using StorageIndexCaster = make_caster<StorageIndexNDArray>;

include/nanobind/nb_traits.h

@@ -8,6 +8,8 @@
 */
 
 NAMESPACE_BEGIN(NB_NAMESPACE)
+using ssize_t = std::make_signed_t<size_t>;
+
 NAMESPACE_BEGIN(detail)
 
 struct void_type { };

include/nanobind/ndarray.h

@@ -71,9 +71,11 @@ template <typename T> struct is_complex : std::false_type { };
 
 NAMESPACE_END(detail)
 
-constexpr size_t any = (size_t) -1;
-
-template <size_t... Is> struct shape {
+template <ssize_t... Is> struct shape {
+    static_assert(
+        ((Is >= 0 || Is == -1) && ...),
+        "The arguments to nanobind::shape must either be positive or equal to -1"
+    );
     static constexpr size_t size = sizeof...(Is);
 };
 
@@ -103,7 +105,7 @@ constexpr bool is_ndarray_scalar_v =
 
 template <typename> struct ndim_shape;
 template <size_t... S> struct ndim_shape<std::index_sequence<S...>> {
-    using type = shape<((void) S, any)...>;
+    using type = shape<((void) S, -1)...>;
 };
 
 NAMESPACE_END(detail)
@@ -227,16 +229,16 @@ template<> struct ndarray_arg<ro> {
     }
 };
 
-template <size_t... Is> struct ndarray_arg<shape<Is...>> {
+template <ssize_t... Is> struct ndarray_arg<shape<Is...>> {
     static constexpr size_t size = sizeof...(Is);
     static constexpr auto name =
         const_name("shape=(") +
-        concat(const_name<Is == any>(const_name("*"), const_name<Is>())...) +
+        concat(const_name<Is == -1>(const_name("*"), const_name<(size_t) Is>())...) +
         const_name(")");
 
     static void apply(ndarray_req &tr) {
         size_t i = 0;
-        ((tr.shape[i++] = Is), ...);
+        ((tr.shape[i++] = (size_t) Is), ...);
         tr.ndim = (uint32_t) sizeof...(Is);
         tr.req_shape = true;
     }
@@ -281,7 +283,7 @@ template <typename T, typename... Ts> struct ndarray_info<T, Ts...>  : ndarray_i
                            T, typename ndarray_info<Ts...>::scalar_type>;
 };
 
-template <size_t... Is, typename... Ts> struct ndarray_info<shape<Is...>, Ts...> : ndarray_info<Ts...> {
+template <ssize_t... Is, typename... Ts> struct ndarray_info<shape<Is...>, Ts...> : ndarray_info<Ts...> {
     using shape_type = shape<Is...>;
 };
 
@@ -347,14 +349,14 @@ template <typename Scalar, typename Shape, char Order> struct ndarray_view {
 private:
     template <typename...> friend class ndarray;
 
-    template <size_t... I1, size_t... I2>
+    template <size_t... I1, ssize_t... I2>
     ndarray_view(Scalar *data, const int64_t *shape, const int64_t *strides,
                  std::index_sequence<I1...>, nanobind::shape<I2...>)
         : m_data(data) {
 
         /* Initialize shape/strides with compile-time knowledge if
            available (to permit vectorization, loop unrolling, etc.) */
-        ((m_shape[I1] = (I2 == any) ? shape[I1] : I2), ...);
+        ((m_shape[I1] = (I2 == -1) ? shape[I1] : (int64_t) I2), ...);
         ((m_strides[I1] = strides[I1]), ...);
 
         if constexpr (Order == 'F') {

src/nb_ndarray.cpp

@@ -375,7 +375,7 @@ ndarray_handle *ndarray_import(PyObject *o, const ndarray_req *req,
         if (pass_shape) {
             for (uint32_t i = 0; i < req->ndim; ++i) {
                 if (req->shape[i] != (size_t) t.shape[i] &&
-                    req->shape[i] != nanobind::any) {
+                    req->shape[i] != (size_t) -1) {
                     pass_shape = false;
                     break;
                 }

tests/test_ndarray.cpp

@@ -76,11 +76,11 @@ NB_MODULE(test_ndarray_ext, m) {
     m.def("pass_uint32", [](const nb::ndarray<uint32_t> &) { }, "array"_a.noconvert());
     m.def("pass_bool", [](const nb::ndarray<bool> &) { }, "array"_a.noconvert());
     m.def("pass_float32_shaped",
-          [](const nb::ndarray<float, nb::shape<3, nb::any, 4>> &) {}, "array"_a.noconvert());
+          [](const nb::ndarray<float, nb::shape<3, -1, 4>> &) {}, "array"_a.noconvert());
 
     m.def("pass_float32_shaped_ordered",
           [](const nb::ndarray<float, nb::c_contig,
-                               nb::shape<nb::any, nb::any, 4>> &) {}, "array"_a.noconvert());
+                               nb::shape<-1, -1, 4>> &) {}, "array"_a.noconvert());
 
     m.def("check_order", [](nb::ndarray<nb::c_contig>) -> char { return 'C'; });
     m.def("check_order", [](nb::ndarray<nb::f_contig>) -> char { return 'F'; });
@@ -98,7 +98,7 @@ NB_MODULE(test_ndarray_ext, m) {
           });
 
     m.def("initialize",
-          [](nb::ndarray<float, nb::shape<10, nb::any>, nb::device::cpu> &t) {
+          [](nb::ndarray<float, nb::shape<10, -1>, nb::device::cpu> &t) {
               int k = 0;
               for (size_t i = 0; i < 10; ++i)
                   for (size_t j = 0; j < t.shape(1); ++j)
@@ -132,7 +132,7 @@ NB_MODULE(test_ndarray_ext, m) {
         );
     });
 
-    m.def("process", [](nb::ndarray<uint8_t, nb::shape<nb::any, nb::any, 3>,
+    m.def("process", [](nb::ndarray<uint8_t, nb::shape<-1, -1, 3>,
                                    nb::c_contig, nb::device::cpu> ndarray) {
         // Double brightness of the MxNx3 RGB image
         for (size_t y = 0; y < ndarray.shape(0); ++y)