style: clang-tidy: google-readability-casting (partial)

Author: henryiii

.clang-tidy

@@ -1,5 +1,8 @@
 FormatStyle: file
 
+# Partially implemented
+# google-readability-casting,
+
 Checks: '
 llvm-namespace-comment,
 modernize-use-override,

include/pybind11/attr.h

@@ -289,7 +289,7 @@ struct type_record {
                     (base_info->default_holder ? "does not" : "does"));
         }
 
-        bases.append((PyObject *) base_info->type);
+        bases.append(reinterpret_cast<PyObject *>(base_info->type));
 
         if (base_info->type->tp_dictoffset != 0)
             dynamic_attr = true;

include/pybind11/buffer_info.h

@@ -30,9 +30,9 @@ struct buffer_info {
                 detail::any_container<ssize_t> shape_in, detail::any_container<ssize_t> strides_in, bool readonly=false)
     : ptr(ptr), itemsize(itemsize), size(1), format(format), ndim(ndim),
       shape(std::move(shape_in)), strides(std::move(strides_in)), readonly(readonly) {
-        if (ndim != (ssize_t) shape.size() || ndim != (ssize_t) strides.size())
+        if (ndim != static_cast<ssize_t>(shape.size()) || ndim != static_cast<ssize_t>(strides.size()))
             pybind11_fail("buffer_info: ndim doesn't match shape and/or strides length");
-        for (size_t i = 0; i < (size_t) ndim; ++i)
+        for (size_t i = 0; i < static_cast<size_t>(ndim); ++i)
             size *= shape[i];
     }
 
@@ -106,7 +106,7 @@ template <typename T, typename SFINAE = void> struct compare_buffer_info {
 
 template <typename T> struct compare_buffer_info<T, detail::enable_if_t<std::is_integral<T>::value>> {
     static bool compare(const buffer_info& b) {
-        return (size_t) b.itemsize == sizeof(T) && (b.format == format_descriptor<T>::value ||
+        return static_cast<size_t>(b.itemsize) == sizeof(T) && (b.format == format_descriptor<T>::value ||
             ((sizeof(T) == sizeof(long)) && b.format == (std::is_unsigned<T>::value ? "L" : "l")) ||
             ((sizeof(T) == sizeof(size_t)) && b.format == (std::is_unsigned<T>::value ? "N" : "n")));
     }

include/pybind11/cast.h

@@ -95,7 +95,7 @@ inline std::pair<decltype(internals::registered_types_py)::iterator, bool> all_t
 PYBIND11_NOINLINE inline void all_type_info_populate(PyTypeObject *t, std::vector<type_info *> &bases) {
     std::vector<PyTypeObject *> check;
     for (handle parent : reinterpret_borrow<tuple>(t->tp_bases))
-        check.push_back((PyTypeObject *) parent.ptr());
+        check.push_back(reinterpret_cast<PyTypeObject *>(parent.ptr()));
 
     auto const &type_dict = get_internals().registered_types_py;
     for (size_t i = 0; i < check.size(); i++) {
@@ -132,7 +132,7 @@ PYBIND11_NOINLINE inline void all_type_info_populate(PyTypeObject *t, std::vecto
                 i--;
             }
             for (handle parent : reinterpret_borrow<tuple>(type->tp_bases))
-                check.push_back((PyTypeObject *) parent.ptr());
+                check.push_back(reinterpret_cast<PyTypeObject *>(parent.ptr()));
         }
     }
 }
@@ -204,7 +204,7 @@ PYBIND11_NOINLINE inline detail::type_info *get_type_info(const std::type_index
 
 PYBIND11_NOINLINE inline handle get_type_handle(const std::type_info &tp, bool throw_if_missing) {
     detail::type_info *type_info = get_type_info(tp, throw_if_missing);
-    return handle(type_info ? ((PyObject *) type_info->type) : nullptr);
+    return handle(type_info ? (reinterpret_cast<PyObject *>(type_info->type)) : nullptr);
 }
 
 struct value_and_holder {
@@ -245,7 +245,7 @@ struct value_and_holder {
         else if (v)
             inst->nonsimple.status[index] |= instance::status_holder_constructed;
         else
-            inst->nonsimple.status[index] &= (uint8_t) ~instance::status_holder_constructed;
+            inst->nonsimple.status[index] &= static_cast<uint8_t>(~instance::status_holder_constructed);
     }
     bool instance_registered() const {
         return inst->simple_layout
@@ -258,7 +258,7 @@ struct value_and_holder {
         else if (v)
             inst->nonsimple.status[index] |= instance::status_instance_registered;
         else
-            inst->nonsimple.status[index] &= (uint8_t) ~instance::status_instance_registered;
+            inst->nonsimple.status[index] &= static_cast<uint8_t>(~instance::status_instance_registered);
     }
 };
 
@@ -383,7 +383,7 @@ PYBIND11_NOINLINE inline void instance::allocate_layout() {
         // like the one we're doing here; in earlier versions (and for larger allocations) they are
         // just wrappers around malloc.
 #if PY_VERSION_HEX >= 0x03050000
-        nonsimple.values_and_holders = (void **) PyMem_Calloc(space, sizeof(void *));
+        nonsimple.values_and_holders = static_cast<void **>(PyMem_Calloc(space, sizeof(void *)));
         if (!nonsimple.values_and_holders) throw std::bad_alloc();
 #else
         nonsimple.values_and_holders = (void **) PyMem_New(void *, space);
@@ -421,7 +421,7 @@ PYBIND11_NOINLINE inline std::string error_string() {
         errorString += ": ";
     }
     if (scope.value)
-        errorString += (std::string) str(scope.value);
+        errorString += std::string(str(scope.value));
 
     PyErr_NormalizeException(&scope.type, &scope.value, &scope.trace);
 
@@ -432,7 +432,7 @@ PYBIND11_NOINLINE inline std::string error_string() {
 
 #if !defined(PYPY_VERSION)
     if (scope.trace) {
-        auto *trace = (PyTracebackObject *) scope.trace;
+        auto *trace = reinterpret_cast<PyTracebackObject *>(scope.trace);
 
         /* Get the deepest trace possible */
         while (trace->tb_next)
@@ -460,7 +460,7 @@ PYBIND11_NOINLINE inline handle get_object_handle(const void *ptr, const detail:
     for (auto it = range.first; it != range.second; ++it) {
         for (const auto &vh : values_and_holders(it->second)) {
             if (vh.type == type)
-                return handle((PyObject *) it->second);
+                return handle(reinterpret_cast<PyObject *>(it->second));
         }
     }
     return handle();
@@ -512,7 +512,7 @@ class type_caster_generic {
         for (auto it_i = it_instances.first; it_i != it_instances.second; ++it_i) {
             for (auto instance_type : detail::all_type_info(Py_TYPE(it_i->second))) {
                 if (instance_type && same_type(*instance_type->cpptype, *tinfo->cpptype))
-                    return handle((PyObject *) it_i->second).inc_ref();
+                    return handle(reinterpret_cast<PyObject *>(it_i->second)).inc_ref();
             }
         }
 
@@ -1130,7 +1130,7 @@ template <> class type_caster<void> : public type_caster<void_type> {
         }
 
         /* Check if this is a C++ type */
-        auto &bases = all_type_info((PyTypeObject *) h.get_type().ptr());
+        auto &bases = all_type_info(reinterpret_cast<PyTypeObject *>(h.get_type().ptr()));
         if (bases.size() == 1) { // Only allowing loading from a single-value type
             value = values_and_holders(reinterpret_cast<instance *>(h.ptr())).begin()->value_ptr();
             return true;
@@ -1184,7 +1184,7 @@ template <> class type_caster<bool> {
             }
             #endif
             if (res == 0 || res == 1) {
-                value = (bool) res;
+                value = static_cast<bool>(res);
                 return true;
             } else {
                 PyErr_Clear();
@@ -1245,7 +1245,7 @@ template <typename StringType, bool IsView = false> struct string_caster {
         if (!utfNbytes) { PyErr_Clear(); return false; }
 
         const auto *buffer = reinterpret_cast<const CharT *>(PYBIND11_BYTES_AS_STRING(utfNbytes.ptr()));
-        size_t length = (size_t) PYBIND11_BYTES_SIZE(utfNbytes.ptr()) / sizeof(CharT);
+        size_t length = static_cast<size_t>(PYBIND11_BYTES_SIZE(utfNbytes.ptr())) / sizeof(CharT);
         if (UTF_N > 8) { buffer++; length--; } // Skip BOM for UTF-16/32
         value = StringType(buffer, length);
 

include/pybind11/detail/class.h

@@ -53,7 +53,7 @@ inline PyTypeObject *make_static_property_type() {
        issue no Python C API calls which could potentially invoke the
        garbage collector (the GC will call type_traverse(), which will in
        turn find the newly constructed type in an invalid state) */
-    auto heap_type = (PyHeapTypeObject *) PyType_Type.tp_alloc(&PyType_Type, 0);
+    auto heap_type = reinterpret_cast<PyHeapTypeObject *>(PyType_Type.tp_alloc(&PyType_Type, 0));
     if (!heap_type)
         pybind11_fail("make_static_property_type(): error allocating type!");
 
@@ -72,7 +72,7 @@ inline PyTypeObject *make_static_property_type() {
     if (PyType_Ready(type) < 0)
         pybind11_fail("make_static_property_type(): failure in PyType_Ready()!");
 
-    setattr((PyObject *) type, "__module__", str("pybind11_builtins"));
+    setattr(reinterpret_cast<PyObject *>(type), "__module__", str("pybind11_builtins"));
     PYBIND11_SET_OLDPY_QUALNAME(type, name_obj);
 
     return type;
@@ -192,7 +192,7 @@ inline PyTypeObject* make_default_metaclass() {
        issue no Python C API calls which could potentially invoke the
        garbage collector (the GC will call type_traverse(), which will in
        turn find the newly constructed type in an invalid state) */
-    auto heap_type = (PyHeapTypeObject *) PyType_Type.tp_alloc(&PyType_Type, 0);
+    auto heap_type = reinterpret_cast<PyHeapTypeObject *>(PyType_Type.tp_alloc(&PyType_Type, 0));
     if (!heap_type)
         pybind11_fail("make_default_metaclass(): error allocating metaclass!");
 
@@ -216,7 +216,7 @@ inline PyTypeObject* make_default_metaclass() {
     if (PyType_Ready(type) < 0)
         pybind11_fail("make_default_metaclass(): failure in PyType_Ready()!");
 
-    setattr((PyObject *) type, "__module__", str("pybind11_builtins"));
+    setattr(reinterpret_cast<PyObject *>(type), "__module__", str("pybind11_builtins"));
     PYBIND11_SET_OLDPY_QUALNAME(type, name_obj);
 
     return type;
@@ -228,7 +228,7 @@ inline PyTypeObject* make_default_metaclass() {
 inline void traverse_offset_bases(void *valueptr, const detail::type_info *tinfo, instance *self,
         bool (*f)(void * /*parentptr*/, instance * /*self*/)) {
     for (handle h : reinterpret_borrow<tuple>(tinfo->type->tp_bases)) {
-        if (auto parent_tinfo = get_type_info((PyTypeObject *) h.ptr())) {
+        if (auto parent_tinfo = get_type_info(reinterpret_cast<PyTypeObject *>(h.ptr()))) {
             for (auto &c : parent_tinfo->implicit_casts) {
                 if (c.first == tinfo->cpptype) {
                     auto *parentptr = c.second(valueptr);
@@ -403,7 +403,7 @@ inline PyObject *make_object_base_type(PyTypeObject *metaclass) {
        issue no Python C API calls which could potentially invoke the
        garbage collector (the GC will call type_traverse(), which will in
        turn find the newly constructed type in an invalid state) */
-    auto heap_type = (PyHeapTypeObject *) metaclass->tp_alloc(metaclass, 0);
+    auto heap_type = reinterpret_cast<PyHeapTypeObject *>(metaclass->tp_alloc(metaclass, 0));
     if (!heap_type)
         pybind11_fail("make_object_base_type(): error allocating type!");
 
@@ -428,11 +428,11 @@ inline PyObject *make_object_base_type(PyTypeObject *metaclass) {
     if (PyType_Ready(type) < 0)
         pybind11_fail("PyType_Ready failed in make_object_base_type():" + error_string());
 
-    setattr((PyObject *) type, "__module__", str("pybind11_builtins"));
+    setattr(reinterpret_cast<PyObject *>(type), "__module__", str("pybind11_builtins"));
     PYBIND11_SET_OLDPY_QUALNAME(type, name_obj);
 
     assert(!PyType_HasFeature(type, Py_TPFLAGS_HAVE_GC));
-    return (PyObject *) heap_type;
+    return reinterpret_cast<PyObject *>(heap_type);
 }
 
 /// dynamic_attr: Support for `d = instance.__dict__`.
@@ -482,7 +482,7 @@ inline void enable_dynamic_attributes(PyHeapTypeObject *heap_type) {
 #endif
     type->tp_flags |= Py_TPFLAGS_HAVE_GC;
     type->tp_dictoffset = type->tp_basicsize; // place dict at the end
-    type->tp_basicsize += (ssize_t)sizeof(PyObject *); // and allocate enough space for it
+    type->tp_basicsize += static_cast<ssize_t>(sizeof(PyObject *)); // and allocate enough space for it
     type->tp_traverse = pybind11_traverse;
     type->tp_clear = pybind11_clear;
 
@@ -586,7 +586,7 @@ inline PyObject* make_new_python_type(const type_record &rec) {
         /* Allocate memory for docstring (using PyObject_MALLOC, since
            Python will free this later on) */
         size_t size = strlen(rec.doc) + 1;
-        tp_doc = (char *) PyObject_MALLOC(size);
+        tp_doc = static_cast<char *>(PyObject_MALLOC(size));
         memcpy((void *) tp_doc, rec.doc, size);
     }
 
@@ -599,10 +599,10 @@ inline PyObject* make_new_python_type(const type_record &rec) {
        issue no Python C API calls which could potentially invoke the
        garbage collector (the GC will call type_traverse(), which will in
        turn find the newly constructed type in an invalid state) */
-    auto metaclass = rec.metaclass.ptr() ? (PyTypeObject *) rec.metaclass.ptr()
+    auto metaclass = rec.metaclass.ptr() ? reinterpret_cast<PyTypeObject *>(rec.metaclass.ptr())
                                          : internals.default_metaclass;
 
-    auto heap_type = (PyHeapTypeObject *) metaclass->tp_alloc(metaclass, 0);
+    auto heap_type = reinterpret_cast<PyHeapTypeObject *>(metaclass->tp_alloc(metaclass, 0));
     if (!heap_type)
         pybind11_fail(std::string(rec.name) + ": Unable to create type object!");
 
@@ -614,7 +614,7 @@ inline PyObject* make_new_python_type(const type_record &rec) {
     auto type = &heap_type->ht_type;
     type->tp_name = full_name;
     type->tp_doc = tp_doc;
-    type->tp_base = type_incref((PyTypeObject *)base);
+    type->tp_base = type_incref(reinterpret_cast<PyTypeObject *>(base));
     type->tp_basicsize = static_cast<ssize_t>(sizeof(instance));
     if (!bases.empty())
         type->tp_bases = bases.release().ptr();
@@ -652,16 +652,16 @@ inline PyObject* make_new_python_type(const type_record &rec) {
 
     /* Register type with the parent scope */
     if (rec.scope)
-        setattr(rec.scope, rec.name, (PyObject *) type);
+        setattr(rec.scope, rec.name, reinterpret_cast<PyObject *>(type));
     else
         Py_INCREF(type); // Keep it alive forever (reference leak)
 
     if (module) // Needed by pydoc
-        setattr((PyObject *) type, "__module__", module);
+        setattr(reinterpret_cast<PyObject *>(type), "__module__", module);
 
     PYBIND11_SET_OLDPY_QUALNAME(type, qualname);
 
-    return (PyObject *) type;
+    return reinterpret_cast<PyObject *>(type);
 }
 
 PYBIND11_NAMESPACE_END(detail)

include/pybind11/detail/init.h

@@ -293,7 +293,7 @@ template <typename Class, typename T, typename O,
           enable_if_t<std::is_convertible<O, handle>::value, int> = 0>
 void setstate(value_and_holder &v_h, std::pair<T, O> &&result, bool need_alias) {
     construct<Class>(v_h, std::move(result.first), need_alias);
-    setattr((PyObject *) v_h.inst, "__dict__", result.second);
+    setattr(reinterpret_cast<PyObject *>(v_h.inst), "__dict__", result.second);
 }
 
 /// Implementation for py::pickle(GetState, SetState)

include/pybind11/eval.h

@@ -33,7 +33,7 @@ object eval(str expr, object global = globals(), object local = object()) {
 
     /* PyRun_String does not accept a PyObject / encoding specifier,
        this seems to be the only alternative */
-    std::string buffer = "# -*- coding: utf-8 -*-\n" + (std::string) expr;
+    std::string buffer = "# -*- coding: utf-8 -*-\n" + std::string(expr);
 
     int start;
     switch (mode) {
@@ -94,7 +94,7 @@ object eval_file(str fname, object global = globals(), object local = object())
     }
 
     int closeFile = 1;
-    std::string fname_str = (std::string) fname;
+    std::string fname_str = std::string(fname);
 #if PY_VERSION_HEX >= 0x03040000
     FILE *f = _Py_fopen_obj(fname.ptr(), "r");
 #elif PY_VERSION_HEX >= 0x03000000