MAINT rename scoped_ref to owned_ref to better match cpython terms (#146)

Author: gerrymanoim

include/libpy/any.h

@@ -33,8 +33,8 @@ struct any_vtable_impl {
     void (*destruct)(void* addr);
     bool (*ne)(const void* lhs, const void* rhs);
     bool (*eq)(const void* lhs, const void* rhs);
-    py::scoped_ref<> (*to_object)(const void* addr);
-    py::scoped_ref<PyArray_Descr> (*new_dtype)();
+    py::owned_ref<> (*to_object)(const void* addr);
+    py::owned_ref<PyArray_Descr> (*new_dtype)();
     std::ostream& (*ostream_format)(std::ostream& stream, const void* addr);
     std::string (*type_name)();
 };
@@ -86,7 +86,7 @@ inline constexpr any_vtable_impl any_vtable_instance = {
     [](const void* lhs, const void* rhs) -> bool {
         return *static_cast<const T*>(lhs) == *static_cast<const T*>(rhs);
     },
-    []([[maybe_unused]] const void* addr) -> scoped_ref<> {
+    []([[maybe_unused]] const void* addr) -> owned_ref<> {
         if constexpr (py::has_to_object<T>) {
             return py::to_object(*static_cast<const T*>(addr));
         }
@@ -97,7 +97,7 @@ inline constexpr any_vtable_impl any_vtable_instance = {
                                 " into Python object");
         }
     },
-    []() -> scoped_ref<PyArray_Descr> {
+    []() -> owned_ref<PyArray_Descr> {
         if constexpr (py::has_new_dtype<T>) {
             return py::new_dtype<T>();
         }
@@ -145,8 +145,8 @@ inline constexpr any_vtable_impl any_vtable_instance<void> = {
     [](void*) { void_vtable(); },
     [](const void*, const void*) -> bool { void_vtable(); },
     [](const void*, const void*) -> bool { void_vtable(); },
-    [](const void*) -> scoped_ref<> { void_vtable(); },
-    []() -> scoped_ref<PyArray_Descr> { void_vtable(); },
+    [](const void*) -> owned_ref<> { void_vtable(); },
+    []() -> owned_ref<PyArray_Descr> { void_vtable(); },
     [](std::ostream&, const void*) -> std::ostream& { void_vtable(); },
     []() { return py::util::type_name<void>(); },
 };
@@ -255,11 +255,11 @@ class any_vtable {
         return m_impl->eq(lhs, rhs);
     }
 
-    inline scoped_ref<> to_object(const void* addr) const {
+    inline owned_ref<> to_object(const void* addr) const {
         return m_impl->to_object(addr);
     }
 
-    inline scoped_ref<PyArray_Descr> new_dtype() const {
+    inline owned_ref<PyArray_Descr> new_dtype() const {
         return m_impl->new_dtype();
     }
 
@@ -574,14 +574,14 @@ namespace dispatch {
  */
 template<>
 struct to_object<py::any_ref> {
-    static py::scoped_ref<> f(const py::any_ref& ref) {
+    static py::owned_ref<> f(const py::any_ref& ref) {
         return ref.vtable().to_object(ref.addr());
     }
 };
 
 template<>
 struct to_object<py::any_cref> {
-    static py::scoped_ref<> f(const py::any_cref& ref) {
+    static py::owned_ref<> f(const py::any_cref& ref) {
         return ref.vtable().to_object(ref.addr());
     }
 };
@@ -675,7 +675,7 @@ dtype_to_vtable(py::borrowed_ref<PyArray_Descr> dtype) {
             throw exception(PyExc_TypeError, "unknown datetime unit: ", unit);
         }
     case NPY_OBJECT:
-        return any_vtable::make<scoped_ref<>>();
+        return any_vtable::make<owned_ref<>>();
     case NPY_STRING:
         return detail::make_string_vtable(dtype->elsize);
     }

include/libpy/any_vector.h

@@ -612,7 +612,7 @@ class any_vector {
 };
 
 
-inline scoped_ref<> move_to_numpy_array(py::any_vector&& values) {
+inline owned_ref<> move_to_numpy_array(py::any_vector&& values) {
 
     auto descr = values.vtable().new_dtype();
     if (!descr) {

include/libpy/autoclass.h

@@ -84,9 +84,9 @@ class autoclass_impl {
 private:
     std::vector<PyType_Slot> m_slots;
     std::unique_ptr<detail::autoclass_storage> m_storage;
-    py::scoped_ref<PyTypeObject> m_type;
+    py::owned_ref<PyTypeObject> m_type;
     PyType_Spec m_spec;
-    py::scoped_ref<PyTypeObject> m_py_basetype;
+    py::owned_ref<PyTypeObject> m_py_basetype;
 
     /** Check if this type uses the `Py_TPFLAGS_HAVE_GC`, which requires that we implement
         at least `Py_tp_traverse`, and will use `PyObject_GC_New` and `PyObject_GC_Del`.
@@ -243,12 +243,12 @@ class autoclass_impl {
 
         @return The already created type, or `nullptr` if the type wasn't yet created.
      */
-    static py::scoped_ref<PyTypeObject> lookup_type() {
+    static py::owned_ref<PyTypeObject> lookup_type() {
         auto type_search = detail::autoclass_type_cache.get().find(typeid(T));
         if (type_search != detail::autoclass_type_cache.get().end()) {
             PyTypeObject* type = type_search->second->type;
             Py_INCREF(type);
-            return py::scoped_ref(type);
+            return py::owned_ref(type);
         }
         return nullptr;
     }
@@ -262,7 +262,7 @@ class autoclass_impl {
                 Python wrapped version of `T`, or nullptr on failure.
     */
     template<typename... Args>
-    static std::tuple<py::scoped_ref<PyTypeObject>, py::scoped_ref<>>
+    static std::tuple<py::owned_ref<PyTypeObject>, py::owned_ref<>>
     construct_with_type(Args&&... args) {
         auto cls = lookup_type();
         if (!cls) {
@@ -280,7 +280,7 @@ class autoclass_impl {
             out = constructor_new_impl<false>(cls.get(), std::forward<Args>(args)...);
         }
 
-        return {std::move(cls), py::scoped_ref(out)};
+        return {std::move(cls), py::owned_ref(out)};
     }
 
 public:
@@ -291,7 +291,7 @@ class autoclass_impl {
         @return A new reference to a Python wrapped version of `T`, or nullptr on failure.
      */
     template<typename... Args>
-    static py::scoped_ref<> construct(Args&&... args) {
+    static py::owned_ref<> construct(Args&&... args) {
         auto [cls, ob] = construct_with_type(std::forward<Args>(args)...);
         return ob;
     }
@@ -344,7 +344,7 @@ class autoclass_impl {
                   0,
                   flags(extra_flags, base_type),
                   nullptr}),
-          m_py_basetype(py::scoped_ref<PyTypeObject>::xnew_reference(base_type)) {
+          m_py_basetype(py::owned_ref<PyTypeObject>::xnew_reference(base_type)) {
         if (base_type) {
             // Check to make sure that the static base type is not obviously
             // wrong. This check does not ensure that the static base type is
@@ -1091,11 +1091,11 @@ class autoclass_impl {
         using end_type = decltype(std::declval<T>().end());
 
         struct iter {
-            scoped_ref<> iterable;
+            owned_ref<> iterable;
             begin_type it;
             end_type end;
 
-            iter(const scoped_ref<>& iterable, begin_type it, end_type end)
+            iter(const owned_ref<>& iterable, begin_type it, end_type end)
                 : iterable(iterable), it(it), end(end) {}
 
             int traverse(visitproc visit, void* arg) {
@@ -1108,7 +1108,7 @@ class autoclass_impl {
             try {
                 iter& unboxed = autoclass<iter>::unbox(self);
                 if (unboxed.it != unboxed.end) {
-                    py::scoped_ref out = py::to_object(*unboxed.it);
+                    py::owned_ref out = py::to_object(*unboxed.it);
                     ++unboxed.it;
                     return std::move(out).escape();
                 }
@@ -1133,15 +1133,15 @@ class autoclass_impl {
 
         return [](PyObject* self) -> PyObject* {
             try {
-                py::scoped_ref<PyTypeObject> cls = autoclass<iter>::lookup_type();
+                py::owned_ref<PyTypeObject> cls = autoclass<iter>::lookup_type();
                 if (!cls) {
                     py::raise(PyExc_RuntimeError)
                         << "no iterator type found for " << util::type_name<T>();
                     return nullptr;
                 }
 
                 Py_INCREF(self);
-                py::scoped_ref self_ref(self);
+                py::owned_ref self_ref(self);
                 return autoclass<iter>::template constructor_new_impl<true>(
                     cls.get(), self_ref, unbox(self).begin(), unbox(self).end());
             }
@@ -1306,7 +1306,7 @@ class autoclass_impl {
         @note If an exception is thrown, the state of the `autoclass` object is
               unspecified.
      */
-    scoped_ref<PyTypeObject> type() {
+    owned_ref<PyTypeObject> type() {
         if (m_type) {
             return m_type;
         }
@@ -1375,7 +1375,7 @@ class autoclass_impl {
         finalize_slots();
         m_spec.slots = m_slots.data();
 
-        py::scoped_ref type(reinterpret_cast<PyTypeObject*>(PyType_FromSpec(&m_spec)));
+        py::owned_ref type(reinterpret_cast<PyTypeObject*>(PyType_FromSpec(&m_spec)));
         if (!type) {
             throw py::exception{};
         }
@@ -1392,15 +1392,15 @@ class autoclass_impl {
         // `PyCFunctionObject` has a pointer to the input `PyMethodDef` which is why
         // we need to store the methoddef on the type cache storage itself.
         storage->callback_method = automethod<cache_cleanup>("cache_cleanup");
-        py::scoped_ref callback_func(
+        py::owned_ref callback_func(
             PyCFunction_NewEx(&storage->callback_method, nullptr, nullptr));
         if (!callback_func) {
             throw py::exception{};
         }
         // Create a weakref that calls `callback_func` (A Python function) when `type`
         // dies. This will take a reference to `callback_func`, and after we leave this
         // scope, it will be the sole owner of that function.
-        storage->cleanup_wr = py::scoped_ref(
+        storage->cleanup_wr = py::owned_ref(
             PyWeakref_NewRef(static_cast<PyObject*>(type), callback_func.get()));
         if (!storage->cleanup_wr) {
             throw py::exception{};
@@ -1427,7 +1427,7 @@ class autoclass_impl {
     class to_object {
         template<typename U>
         static PyObject* f(U&& value) {
-            py::scoped_ref<PyTypeObject> cls = lookup_type();
+            py::owned_ref<PyTypeObject> cls = lookup_type();
             if (!cls) {
                 py::raise(PyExc_RuntimeError) << "autoclass type wasn't initialized yet";
                 return nullptr;
@@ -1456,7 +1456,7 @@ class autoclass_impl {
     you can write the following:
 
     \code
-    py::scoped_ref<PyTypeObject> t = py::autoclass<my_type>("modname.PythonName").type();
+    py::owned_ref<PyTypeObject> t = py::autoclass<my_type>("modname.PythonName").type();
     \endcode
 
     The resulting type will have a `__name__` of "PythonName", and a
@@ -1469,7 +1469,7 @@ class autoclass_impl {
     accepts an int and a double:
 
     \code
-    py::scoped_ref<PyTypeObject> t = py::autoclass<my_type>("modname.PythonName")
+    py::owned_ref<PyTypeObject> t = py::autoclass<my_type>("modname.PythonName")
                                          .new_<int, double>()
                                          .type();
     \endcode
@@ -1485,7 +1485,7 @@ class autoclass_impl {
     as a Python method named `bar`:
 
     \code
-    py::scoped_ref<PyTypeObject> t = py::autoclass<my_type>("modname.PythonName")
+    py::owned_ref<PyTypeObject> t = py::autoclass<my_type>("modname.PythonName")
                                          .new_<int, double>()
                                          .def<&my_type::foo>("bar")
                                          .type();
@@ -1611,7 +1611,7 @@ void initialize_interface_type(typename object::base* ptr) {
     `py::autoclass_interface`:
 
     \code
-    py::scoped_ref interface_pytype =
+    py::owned_ref interface_pytype =
         py::autoclass_interface<I>("Interface").type();
     \endcode
 
@@ -1625,7 +1625,7 @@ void initialize_interface_type(typename object::base* ptr) {
     interface. Adding methods is the same as `py::automethod`:
 
     \code
-    py::scoped_ref interface_pytype =
+    py::owned_ref interface_pytype =
         py::autoclass_interface<I>("Interface")
         .def<&interface::f>("f")
         .type();
@@ -1638,12 +1638,12 @@ void initialize_interface_type(typename object::base* ptr) {
     `py::autoclass_interface_instance`. For example:
 
     \code
-    py::scoped_ref concrete_a_pytype =
+    py::owned_ref concrete_a_pytype =
         py::autoclass_interface_instance<concrete_a, interface>("ConcreteA")
         .new_()
         .type();
 
-    py::scoped_ref concrete_b_pytype =
+    py::owned_ref concrete_b_pytype =
         py::autoclass_interface_instance<concrete_b, interface>("ConcreteB")
         .new_<std::string_view>()
         .def<&concrete_b::non_interface_method>("non_interface_method")
@@ -1760,7 +1760,7 @@ struct autoclass_interface_instance final
     static_assert(std::is_base_of_v<I, T>, "interface type is not a base of T");
 
 private:
-    static py::scoped_ref<PyTypeObject> resolve_pybase() {
+    static py::owned_ref<PyTypeObject> resolve_pybase() {
         auto res = py::autoclass_interface<I>::lookup_type();
         if (!res) {
             throw std::runtime_error{

include/libpy/automethod.h

@@ -482,7 +482,7 @@ struct argument_parser {
 
         // flatten the args + kwargs into a single tuple to pass to
         // `positional_args`
-        py::scoped_ref<> flat(PyTuple_New(arity));
+        py::owned_ref<> flat(PyTuple_New(arity));
         if (!flat) {
             throw py::exception{};
         }

include/libpy/borrowed_ref.h

@@ -4,17 +4,17 @@
 
 namespace py {
 template<typename T>
-class scoped_ref;
+class owned_ref;
 
 /** A type that explicitly indicates that a Python object is a borrowed
     reference. This is implicitly convertible from a regular `PyObject*` or a
-    `py::scoped_ref`. This type may be used as a Python object parameter like:
+    `py::owned_ref`. This type may be used as a Python object parameter like:
 
     \code
     int f(borrowed_ref a, borrowed_ref b);
     \endcode
 
-    This allows calling this function with either `py::scoped_ref` or
+    This allows calling this function with either `py::owned_ref` or
     `PyObject*`.
 
     @note A `borrowed_ref` may still hold a value of `nullptr`.
@@ -28,7 +28,7 @@ class borrowed_ref {
     constexpr borrowed_ref() : m_ref(nullptr) {}
     constexpr borrowed_ref(std::nullptr_t) : m_ref(nullptr) {}
     constexpr borrowed_ref(T* ref) : m_ref(ref) {}
-    constexpr borrowed_ref(const py::scoped_ref<T>& ref) : m_ref(ref.get()) {}
+    constexpr borrowed_ref(const py::owned_ref<T>& ref) : m_ref(ref.get()) {}
 
     constexpr borrowed_ref(const borrowed_ref&) = default;
     constexpr borrowed_ref& operator=(const borrowed_ref& ob) = default;

include/libpy/build_tuple.h

@@ -1,12 +1,12 @@
 #pragma once
 
-#include "libpy/scoped_ref.h"
+#include "libpy/owned_ref.h"
 #include "libpy/to_object.h"
 
 namespace py {
 template<typename... Args>
-py::scoped_ref<> build_tuple(const Args&... args) {
-    py::scoped_ref out(PyTuple_New(sizeof...(args)));
+py::owned_ref<> build_tuple(const Args&... args) {
+    py::owned_ref out(PyTuple_New(sizeof...(args)));
     if (!out) {
         return nullptr;
     }