Removing PYBIND11_NOINLINE_FWD macro (after learning that it makes no sense).

rwgk · rwgk · commit cbbf839d0ea7 · 2021-08-03T14:33:48.000-07:00
diff --git a/docs/Doxyfile b/docs/Doxyfile
@@ -20,4 +20,4 @@ WARNINGS               = YES
 WARN_IF_UNDOCUMENTED   = NO
 PREDEFINED             = DOXYGEN_SHOULD_SKIP_THIS \
                          PY_MAJOR_VERSION=3 \
-                         PYBIND11_NOINLINE_DCL
+                         PYBIND11_NOINLINE
diff --git a/include/pybind11/attr.h b/include/pybind11/attr.h
@@ -129,7 +129,7 @@ enum op_id : int;
 enum op_type : int;
 struct undefined_t;
 template <op_id id, op_type ot, typename L = undefined_t, typename R = undefined_t> struct op_;
-PYBIND11_NOINLINE_FWD void keep_alive_impl(size_t Nurse, size_t Patient, function_call &call, handle ret);
+void keep_alive_impl(size_t Nurse, size_t Patient, function_call &call, handle ret);
 
 /// Internal data structure which holds metadata about a keyword argument
 struct argument_record {
@@ -225,7 +225,7 @@ struct function_record {
 
 /// Special data structure which (temporarily) holds metadata about a bound class
 struct type_record {
-    PYBIND11_NOINLINE_DCL type_record()
+    PYBIND11_NOINLINE type_record()
         : multiple_inheritance(false), dynamic_attr(false), buffer_protocol(false),
           default_holder(true), module_local(false), is_final(false) { }
 
@@ -283,7 +283,7 @@ struct type_record {
     /// Is the class inheritable from python classes?
     bool is_final : 1;
 
-    PYBIND11_NOINLINE_DCL void add_base(const std::type_info &base, void *(*caster)(void *)) {
+    PYBIND11_NOINLINE void add_base(const std::type_info &base, void *(*caster)(void *)) {
         auto base_info = detail::get_type_info(base, false);
         if (!base_info) {
             std::string tname(base.name());
diff --git a/include/pybind11/detail/common.h b/include/pybind11/detail/common.h
@@ -109,15 +109,14 @@
 #  define PYBIND11_NOINLINE_DISABLED
 #endif
 
+// Note: Forward declaration should never be `inline`:
+// https://stackoverflow.com/questions/9317473/forward-declaration-of-inline-functions
 #if defined(PYBIND11_NOINLINE_DISABLED)
-#  define PYBIND11_NOINLINE_DCL inline
-#  define PYBIND11_NOINLINE_FWD inline
+#  define PYBIND11_NOINLINE inline
 #elif defined(_MSC_VER)
-#  define PYBIND11_NOINLINE_DCL __declspec(noinline) inline
-#  define PYBIND11_NOINLINE_FWD
+#  define PYBIND11_NOINLINE __declspec(noinline) inline
 #else
-#  define PYBIND11_NOINLINE_DCL __attribute__ ((noinline)) inline
-#  define PYBIND11_NOINLINE_FWD
+#  define PYBIND11_NOINLINE __attribute__ ((noinline)) inline
 #endif
 
 // DECISION TO BE MADE before this PR is merged:
@@ -813,8 +812,8 @@ PYBIND11_RUNTIME_EXCEPTION(import_error, PyExc_ImportError)
 PYBIND11_RUNTIME_EXCEPTION(cast_error, PyExc_RuntimeError) /// Thrown when pybind11::cast or handle::call fail due to a type casting error
 PYBIND11_RUNTIME_EXCEPTION(reference_cast_error, PyExc_RuntimeError) /// Used internally
 
-[[noreturn]] PYBIND11_NOINLINE_DCL void pybind11_fail(const char *reason) { throw std::runtime_error(reason); }
-[[noreturn]] PYBIND11_NOINLINE_DCL void pybind11_fail(const std::string &reason) { throw std::runtime_error(reason); }
+[[noreturn]] PYBIND11_NOINLINE void pybind11_fail(const char *reason) { throw std::runtime_error(reason); }
+[[noreturn]] PYBIND11_NOINLINE void pybind11_fail(const std::string &reason) { throw std::runtime_error(reason); }
 
 template <typename T, typename SFINAE = void> struct format_descriptor { };
 
diff --git a/include/pybind11/detail/internals.h b/include/pybind11/detail/internals.h
@@ -262,7 +262,7 @@ inline void translate_local_exception(std::exception_ptr p) {
 #endif
 
 /// Return a reference to the current `internals` data
-PYBIND11_NOINLINE_DCL internals &get_internals() {
+PYBIND11_NOINLINE internals &get_internals() {
     auto **&internals_pp = get_internals_pp();
     if (internals_pp && *internals_pp)
         return **internals_pp;
@@ -357,14 +357,14 @@ PYBIND11_NAMESPACE_END(detail)
 /// Returns a named pointer that is shared among all extension modules (using the same
 /// pybind11 version) running in the current interpreter. Names starting with underscores
 /// are reserved for internal usage. Returns `nullptr` if no matching entry was found.
-PYBIND11_NOINLINE_DCL void *get_shared_data(const std::string &name) {
+PYBIND11_NOINLINE void *get_shared_data(const std::string &name) {
     auto &internals = detail::get_internals();
     auto it = internals.shared_data.find(name);
     return it != internals.shared_data.end() ? it->second : nullptr;
 }
 
 /// Set the shared data that can be later recovered by `get_shared_data()`.
-PYBIND11_NOINLINE_DCL void *set_shared_data(const std::string &name, void *data) {
+PYBIND11_NOINLINE void *set_shared_data(const std::string &name, void *data) {
     detail::get_internals().shared_data[name] = data;
     return data;
 }
diff --git a/include/pybind11/detail/type_caster_base.h b/include/pybind11/detail/type_caster_base.h
@@ -59,7 +59,7 @@ class loader_life_support {
 
     /// This can only be used inside a pybind11-bound function, either by `argument_loader`
     /// at argument preparation time or by `py::cast()` at execution time.
-    PYBIND11_NOINLINE_DCL static void add_patient(handle h) {
+    PYBIND11_NOINLINE static void add_patient(handle h) {
         auto &stack = get_internals().loader_patient_stack;
         if (stack.empty())
             throw cast_error("When called outside a bound function, py::cast() cannot "
@@ -86,7 +86,7 @@ class loader_life_support {
 inline std::pair<decltype(internals::registered_types_py)::iterator, bool> all_type_info_get_cache(PyTypeObject *type);
 
 // Populates a just-created cache entry.
-PYBIND11_NOINLINE_DCL void all_type_info_populate(PyTypeObject *t, std::vector<type_info *> &bases) {
+PYBIND11_NOINLINE 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());
@@ -155,7 +155,7 @@ inline const std::vector<detail::type_info *> &all_type_info(PyTypeObject *type)
  * ancestors are pybind11-registered.  Throws an exception if there are multiple bases--use
  * `all_type_info` instead if you want to support multiple bases.
  */
-PYBIND11_NOINLINE_DCL detail::type_info* get_type_info(PyTypeObject *type) {
+PYBIND11_NOINLINE detail::type_info* get_type_info(PyTypeObject *type) {
     auto &bases = all_type_info(type);
     if (bases.empty())
         return nullptr;
@@ -181,7 +181,7 @@ inline detail::type_info *get_global_type_info(const std::type_index &tp) {
 }
 
 /// Return the type info for a given C++ type; on lookup failure can either throw or return nullptr.
-PYBIND11_NOINLINE_DCL detail::type_info *get_type_info(const std::type_index &tp,
+PYBIND11_NOINLINE detail::type_info *get_type_info(const std::type_index &tp,
                                                           bool throw_if_missing = false) {
     if (auto ltype = get_local_type_info(tp))
         return ltype;
@@ -196,13 +196,13 @@ PYBIND11_NOINLINE_DCL detail::type_info *get_type_info(const std::type_index &tp
     return nullptr;
 }
 
-PYBIND11_NOINLINE_DCL handle get_type_handle(const std::type_info &tp, bool throw_if_missing) {
+PYBIND11_NOINLINE 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);
 }
 
 // Searches the inheritance graph for a registered Python instance, using all_type_info().
-PYBIND11_NOINLINE_DCL handle find_registered_python_instance(void *src,
+PYBIND11_NOINLINE handle find_registered_python_instance(void *src,
                                                                 const detail::type_info *tinfo) {
     auto it_instances = get_internals().registered_instances.equal_range(src);
     for (auto it_i = it_instances.first; it_i != it_instances.second; ++it_i) {
@@ -330,7 +330,7 @@ struct values_and_holders {
  * The returned object should be short-lived: in particular, it must not outlive the called-upon
  * instance.
  */
-PYBIND11_NOINLINE_DCL value_and_holder instance::get_value_and_holder(const type_info *find_type /*= nullptr default in common.h*/, bool throw_if_missing /*= true in common.h*/) {
+PYBIND11_NOINLINE value_and_holder instance::get_value_and_holder(const type_info *find_type /*= nullptr default in common.h*/, bool throw_if_missing /*= true in common.h*/) {
     // Optimize common case:
     if (!find_type || Py_TYPE(this) == find_type->type)
         return value_and_holder(this, find_type, 0, 0);
@@ -354,7 +354,7 @@ PYBIND11_NOINLINE_DCL value_and_holder instance::get_value_and_holder(const type
 #endif
 }
 
-PYBIND11_NOINLINE_DCL void instance::allocate_layout() {
+PYBIND11_NOINLINE void instance::allocate_layout() {
     auto &tinfo = all_type_info(Py_TYPE(this));
 
     const size_t n_types = tinfo.size();
@@ -402,19 +402,19 @@ PYBIND11_NOINLINE_DCL void instance::allocate_layout() {
     owned = true;
 }
 
-PYBIND11_NOINLINE_DCL void instance::deallocate_layout() const {
+PYBIND11_NOINLINE void instance::deallocate_layout() const {
     if (!simple_layout)
         PyMem_Free(nonsimple.values_and_holders);
 }
 
-PYBIND11_NOINLINE_DCL bool isinstance_generic(handle obj, const std::type_info &tp) {
+PYBIND11_NOINLINE bool isinstance_generic(handle obj, const std::type_info &tp) {
     handle type = detail::get_type_handle(tp, false);
     if (!type)
         return false;
     return isinstance(obj, type);
 }
 
-PYBIND11_NOINLINE_DCL std::string error_string() {
+PYBIND11_NOINLINE std::string error_string() {
     if (!PyErr_Occurred()) {
         PyErr_SetString(PyExc_RuntimeError, "Unknown internal error occurred");
         return "Unknown internal error occurred";
@@ -461,7 +461,7 @@ PYBIND11_NOINLINE_DCL std::string error_string() {
     return errorString;
 }
 
-PYBIND11_NOINLINE_DCL handle get_object_handle(const void *ptr, const detail::type_info *type ) {
+PYBIND11_NOINLINE handle get_object_handle(const void *ptr, const detail::type_info *type ) {
     auto &instances = get_internals().registered_instances;
     auto range = instances.equal_range(ptr);
     for (auto it = range.first; it != range.second; ++it) {
@@ -488,12 +488,12 @@ inline PyThreadState *get_thread_state_unchecked() {
 }
 
 // Forward declarations
-PYBIND11_NOINLINE_FWD void keep_alive_impl(handle nurse, handle patient);
+void keep_alive_impl(handle nurse, handle patient);
 inline PyObject *make_new_instance(PyTypeObject *type);
 
 class type_caster_generic {
 public:
-    PYBIND11_NOINLINE_DCL type_caster_generic(const std::type_info &type_info)
+    PYBIND11_NOINLINE type_caster_generic(const std::type_info &type_info)
         : typeinfo(get_type_info(type_info)), cpptype(&type_info) { }
 
     type_caster_generic(const type_info *typeinfo)
@@ -503,7 +503,7 @@ class type_caster_generic {
         return load_impl<type_caster_generic>(src, convert);
     }
 
-    PYBIND11_NOINLINE_DCL static handle cast(const void *_src, return_value_policy policy, handle parent,
+    PYBIND11_NOINLINE static handle cast(const void *_src, return_value_policy policy, handle parent,
                                          const detail::type_info *tinfo,
                                          void *(*copy_constructor)(const void *),
                                          void *(*move_constructor)(const void *),
@@ -627,7 +627,7 @@ class type_caster_generic {
     }
     void check_holder_compat() {}
 
-    PYBIND11_NOINLINE_DCL static void *local_load(PyObject *src, const type_info *ti) {
+    PYBIND11_NOINLINE static void *local_load(PyObject *src, const type_info *ti) {
         auto caster = type_caster_generic(ti);
         if (caster.load(src, false))
             return caster.value;
@@ -636,7 +636,7 @@ class type_caster_generic {
 
     /// Try to load with foreign typeinfo, if available. Used when there is no
     /// native typeinfo, or when the native one wasn't able to produce a value.
-    PYBIND11_NOINLINE_DCL bool try_load_foreign_module_local(handle src) {
+    PYBIND11_NOINLINE bool try_load_foreign_module_local(handle src) {
         constexpr auto *local_key = PYBIND11_MODULE_LOCAL_ID;
         const auto pytype = type::handle_of(src);
         if (!hasattr(pytype, local_key))
@@ -659,7 +659,7 @@ class type_caster_generic {
     // bits of code between here and copyable_holder_caster where the two classes need different
     // logic (without having to resort to virtual inheritance).
     template <typename ThisT>
-    PYBIND11_NOINLINE_DCL bool load_impl(handle src, bool convert) {
+    PYBIND11_NOINLINE bool load_impl(handle src, bool convert) {
         if (!src) return false;
         if (!typeinfo) return try_load_foreign_module_local(src);
 
@@ -749,7 +749,7 @@ class type_caster_generic {
     // Called to do type lookup and wrap the pointer and type in a pair when a dynamic_cast
     // isn't needed or can't be used.  If the type is unknown, sets the error and returns a pair
     // with .second = nullptr.  (p.first = nullptr is not an error: it becomes None).
-    PYBIND11_NOINLINE_DCL static std::pair<const void *, const type_info *> src_and_type(
+    PYBIND11_NOINLINE static std::pair<const void *, const type_info *> src_and_type(
             const void *src, const std::type_info &cast_type, const std::type_info *rtti_type = nullptr) {
         if (auto *tpi = get_type_info(cast_type))
             return {src, const_cast<const type_info *>(tpi)};
diff --git a/include/pybind11/detail/typeid.h b/include/pybind11/detail/typeid.h
@@ -34,7 +34,7 @@ inline void erase_all(std::string &string, const std::string &search) {
     }
 }
 
-PYBIND11_NOINLINE_DCL void clean_type_id(std::string &name) {
+PYBIND11_NOINLINE void clean_type_id(std::string &name) {
 #if defined(__GNUG__)
     int status = 0;
     std::unique_ptr<char, void (*)(void *)> res {
diff --git a/include/pybind11/gil.h b/include/pybind11/gil.h
@@ -53,7 +53,7 @@ PYBIND11_NAMESPACE_END(detail)
 
 class gil_scoped_acquire {
 public:
-    PYBIND11_NOINLINE_DCL gil_scoped_acquire() {
+    PYBIND11_NOINLINE gil_scoped_acquire() {
         auto const &internals = detail::get_internals();
         tstate = (PyThreadState *) PYBIND11_TLS_GET_VALUE(internals.tstate);
 
@@ -89,7 +89,7 @@ class gil_scoped_acquire {
         ++tstate->gilstate_counter;
     }
 
-    PYBIND11_NOINLINE_DCL void dec_ref() {
+    PYBIND11_NOINLINE void dec_ref() {
         --tstate->gilstate_counter;
         #if !defined(NDEBUG)
             if (detail::get_thread_state_unchecked() != tstate)
@@ -115,11 +115,11 @@ class gil_scoped_acquire {
     /// could be shutting down when this is called, as thread deletion is not
     /// allowed during shutdown. Check _Py_IsFinalizing() on Python 3.7+, and
     /// protect subsequent code.
-    PYBIND11_NOINLINE_DCL void disarm() {
+    PYBIND11_NOINLINE void disarm() {
         active = false;
     }
 
-    PYBIND11_NOINLINE_DCL ~gil_scoped_acquire() {
+    PYBIND11_NOINLINE ~gil_scoped_acquire() {
         dec_ref();
         if (release)
            PyEval_SaveThread();
@@ -149,7 +149,7 @@ class gil_scoped_release {
     /// could be shutting down when this is called, as thread deletion is not
     /// allowed during shutdown. Check _Py_IsFinalizing() on Python 3.7+, and
     /// protect subsequent code.
-    PYBIND11_NOINLINE_DCL void disarm() {
+    PYBIND11_NOINLINE void disarm() {
         active = false;
     }
 
diff --git a/include/pybind11/numpy.h b/include/pybind11/numpy.h
@@ -109,7 +109,7 @@ struct numpy_internals {
     }
 };
 
-PYBIND11_NOINLINE_DCL void load_numpy_internals(numpy_internals* &ptr) {
+PYBIND11_NOINLINE void load_numpy_internals(numpy_internals* &ptr) {
     ptr = &get_or_create_shared_data<numpy_internals>("_numpy_internals");
 }
 
@@ -1115,7 +1115,7 @@ struct field_descriptor {
     dtype descr;
 };
 
-PYBIND11_NOINLINE_DCL void register_structured_dtype(
+PYBIND11_NOINLINE void register_structured_dtype(
     any_container<field_descriptor> fields,
     const std::type_info& tinfo, ssize_t itemsize,
     bool (*direct_converter)(PyObject *, void *&)) {
diff --git a/include/pybind11/pybind11.h b/include/pybind11/pybind11.h
@@ -151,7 +151,7 @@ class cpp_function : public function {
     using unique_function_record = std::unique_ptr<detail::function_record, InitializingFunctionRecordDeleter>;
 
     /// Space optimization: don't inline this frequently instantiated fragment
-    PYBIND11_NOINLINE_DCL unique_function_record make_function_record() {
+    PYBIND11_NOINLINE unique_function_record make_function_record() {
         return unique_function_record(new detail::function_record());
     }
 
@@ -1061,7 +1061,7 @@ class module_ : public object {
         ``overwrite`` should almost always be false: attempting to overwrite objects that pybind11 has
         established will, in most cases, break things.
     \endrst */
-    PYBIND11_NOINLINE_DCL void add_object(const char *name, handle obj, bool overwrite = false) {
+    PYBIND11_NOINLINE void add_object(const char *name, handle obj, bool overwrite = false) {
         if (!overwrite && hasattr(*this, name))
             pybind11_fail("Error during initialization: multiple incompatible definitions with name \"" +
                     std::string(name) + "\"");
@@ -1676,7 +1676,7 @@ inline str enum_name(handle arg) {
 struct enum_base {
     enum_base(handle base, handle parent) : m_base(base), m_parent(parent) { }
 
-    PYBIND11_NOINLINE_DCL void init(bool is_arithmetic, bool is_convertible) {
+    PYBIND11_NOINLINE void init(bool is_arithmetic, bool is_convertible) {
         m_base.attr("__entries") = dict();
         auto property = handle((PyObject *) &PyProperty_Type);
         auto static_property = handle((PyObject *) get_internals().static_property_type);
@@ -1802,7 +1802,7 @@ struct enum_base {
             [](const object &arg) { return int_(arg); }, name("__hash__"), is_method(m_base));
     }
 
-    PYBIND11_NOINLINE_DCL void value(char const* name_, object value, const char *doc = nullptr) {
+    PYBIND11_NOINLINE void value(char const* name_, object value, const char *doc = nullptr) {
         dict entries = m_base.attr("__entries");
         str name(name_);
         if (entries.contains(name)) {
@@ -1814,7 +1814,7 @@ struct enum_base {
         m_base.attr(name) = value;
     }
 
-    PYBIND11_NOINLINE_DCL void export_values() {
+    PYBIND11_NOINLINE void export_values() {
         dict entries = m_base.attr("__entries");
         for (auto kv : entries)
             m_parent.attr(kv.first) = kv.second[int_(0)];
@@ -1879,7 +1879,7 @@ template <typename Type> class enum_ : public class_<Type> {
 
 PYBIND11_NAMESPACE_BEGIN(detail)
 
-PYBIND11_NOINLINE_DCL void keep_alive_impl(handle nurse, handle patient) {
+PYBIND11_NOINLINE void keep_alive_impl(handle nurse, handle patient) {
     if (!nurse || !patient)
         pybind11_fail("Could not activate keep_alive!");
 
@@ -1906,7 +1906,7 @@ PYBIND11_NOINLINE_DCL void keep_alive_impl(handle nurse, handle patient) {
     }
 }
 
-PYBIND11_NOINLINE_DCL void keep_alive_impl(size_t Nurse, size_t Patient, function_call &call, handle ret) {
+PYBIND11_NOINLINE void keep_alive_impl(size_t Nurse, size_t Patient, function_call &call, handle ret) {
     auto get_arg = [&](size_t n) {
         if (n == 0)
             return ret;
@@ -2156,7 +2156,7 @@ exception<CppException> &register_local_exception(handle scope,
 }
 
 PYBIND11_NAMESPACE_BEGIN(detail)
-PYBIND11_NOINLINE_DCL void print(const tuple &args, const dict &kwargs) {
+PYBIND11_NOINLINE void print(const tuple &args, const dict &kwargs) {
     auto strings = tuple(args.size());
     for (size_t i = 0; i < args.size(); ++i) {
         strings[i] = str(args[i]);
diff --git a/include/pybind11/pytypes.h b/include/pybind11/pytypes.h

Original file line number	Diff line number	Diff line change
`@@ -34,7 +34,7 @@ inline void erase_all(std::string &string, const std::string &search) {`
`34`	`34`	`}`
`35`	`35`	`}`
`36`	`36`
`37`		`-PYBIND11_NOINLINE_DCL void clean_type_id(std::string &name) {`
	`37`	`+PYBIND11_NOINLINE void clean_type_id(std::string &name) {`
`38`	`38`	`#if defined(__GNUG__)`
`39`	`39`	`int status = 0;`
`40`	`40`	`std::unique_ptr<char, void ()(void )> res {`
Original file line number	Diff line number	Diff line change
`@@ -109,7 +109,7 @@ struct numpy_internals {`
`109`	`109`	`}`
`110`	`110`	`};`
`111`	`111`
`112`		`-PYBIND11_NOINLINE_DCL void load_numpy_internals(numpy_internals* &ptr) {`
	`112`	`+PYBIND11_NOINLINE void load_numpy_internals(numpy_internals* &ptr) {`
`113`	`113`	`ptr = &get_or_create_shared_data<numpy_internals>("_numpy_internals");`
`114`	`114`	`}`
`115`	`115`
`@@ -1115,7 +1115,7 @@ struct field_descriptor {`
`1115`	`1115`	`dtype descr;`
`1116`	`1116`	`};`
`1117`	`1117`
`1118`		`-PYBIND11_NOINLINE_DCL void register_structured_dtype(`
	`1118`	`+PYBIND11_NOINLINE void register_structured_dtype(`
`1119`	`1119`	`any_container<field_descriptor> fields,`
`1120`	`1120`	`const std::type_info& tinfo, ssize_t itemsize,`
`1121`	`1121`	`bool (direct_converter)(PyObject , void *&)) {`