SYMBOL INDEX (3162 symbols across 238 files)

FILE: docs/benchmark.py
  function generate_dummy_code_pybind11 (line 11) | def generate_dummy_code_pybind11(nclasses=10):
  function generate_dummy_code_boost (line 42) | def generate_dummy_code_boost(nclasses=10):

FILE: docs/conf.py
  function generate_doxygen_xml (line 328) | def generate_doxygen_xml(app):
  function prepare (line 342) | def prepare(app):
  function clean_up (line 357) | def clean_up(app, exception):  # noqa: ARG001
  function setup (line 361) | def setup(app):

FILE: include/pybind11/attr.h
  function is_method (line 19) | PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
  type is_setter (line 31) | struct is_setter {}
  type is_operator (line 34) | struct is_operator {}
  type is_final (line 37) | struct is_final {}
  type name (line 52) | struct name {
  type op_type (line 176) | enum op_type : int
  type undefined_t (line 177) | struct undefined_t
  type function_record (line 197) | struct function_record {
  type type_record (line 284) | struct type_record {
  function function_call (line 390) | inline function_call::function_call(const function_record &f, handle p) ...
  type is_new_style_constructor (line 396) | struct is_new_style_constructor {}
  function init (line 410) | static void init(const T &, function_record *) {}
  function init (line 411) | static void init(const T &, type_record *) {}
  function precall (line 412) | static void precall(function_call &) {}
  function postcall (line 413) | static void postcall(function_call &, handle) {}
  function name (line 418) | struct process_attribute<name> : process_attribute_default<name> {
  function doc (line 424) | struct process_attribute<doc> : process_attribute_default<doc> {
  type process_attribute (line 430) | struct process_attribute
  function init (line 431) | static void init(const char *d, function_record *r) { r->doc = const_cas...
  function init (line 432) | static void init(const char *d, type_record *r) { r->doc = d; }
  type process_attribute (line 435) | struct process_attribute
  function return_value_policy (line 439) | struct process_attribute<return_value_policy> : process_attribute_defaul...
  function sibling (line 446) | struct process_attribute<sibling> : process_attribute_default<sibling> {
  function is_method (line 452) | struct process_attribute<is_method> : process_attribute_default<is_metho...
  function is_setter (line 461) | struct process_attribute<is_setter> : process_attribute_default<is_sette...
  function scope (line 467) | struct process_attribute<scope> : process_attribute_default<scope> {
  function is_operator (line 473) | struct process_attribute<is_operator> : process_attribute_default<is_ope...
  function is_new_style_constructor (line 478) | struct process_attribute<is_new_style_constructor>
  function check_kw_only_arg (line 485) | inline void check_kw_only_arg(const arg &a, function_record *r) {
  function append_self_arg_if_needed (line 492) | inline void append_self_arg_if_needed(function_record *r) {
  function arg (line 500) | struct process_attribute<arg> : process_attribute_default<arg> {
  function arg_v (line 511) | struct process_attribute<arg_v> : process_attribute_default<arg_v> {
  function kw_only (line 552) | struct process_attribute<kw_only> : process_attribute_default<kw_only> {
  function pos_only (line 565) | struct process_attribute<pos_only> : process_attribute_default<pos_only> {
  function init (line 581) | static void init(const handle &h, type_record *r) { r->bases.append(h); }
  function init (line 587) | static void init(const base<T> &, type_record *r) { r->add_base(typeid(T...
  function multiple_inheritance (line 592) | struct process_attribute<multiple_inheritance> : process_attribute_defau...
  function dynamic_attr (line 599) | struct process_attribute<dynamic_attr> : process_attribute_default<dynam...
  function custom_type_setup (line 604) | struct process_attribute<custom_type_setup> {
  function is_final (line 611) | struct process_attribute<is_final> : process_attribute_default<is_final> {
  function buffer_protocol (line 616) | struct process_attribute<buffer_protocol> : process_attribute_default<bu...
  function metaclass (line 621) | struct process_attribute<metaclass> : process_attribute_default<metaclas...
  function module_local (line 626) | struct process_attribute<module_local> : process_attribute_default<modul...
  function release_gil_before_calling_cpp_dtor (line 631) | struct process_attribute<release_gil_before_calling_cpp_dtor>
  function prepend (line 640) | struct process_attribute<prepend> : process_attribute_default<prepend> {
  function arithmetic (line 646) | struct process_attribute<arithmetic> : process_attribute_default<arithme...
  function init (line 676) | static void init(const Args &...args, function_record *r) {
  function init (line 683) | static void init(const Args &...args, type_record *r) {
  function precall (line 690) | static void precall(function_call &call) {
  function postcall (line 696) | static void postcall(function_call &call, handle fn_ret) {

FILE: include/pybind11/buffer_info.h
  function PYBIND11_NAMESPACE_BEGIN (line 14) | PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
  function std (line 31) | inline std::vector<ssize_t> f_strides(const std::vector<ssize_t> &shape,...
  function Py_buffer (line 154) | Py_buffer *view() const { return m_view; }
  type private_ctr_tag (line 169) | struct private_ctr_tag {}
  type compare_buffer_info (line 189) | struct compare_buffer_info {
  function compare (line 198) | static bool compare(const buffer_info &b) {

FILE: include/pybind11/cast.h
  function handle (line 82) | handle cast(SrcType *src, return_value_policy policy, handle parent) {
  function load (line 86) | bool load(handle src, bool convert) {
  function operator (line 114) | operator EnumType *() { return native_loaded ? &native_value : legacy_pt...
  function handle (line 179) | static handle
  function handle (line 368) | static handle cast(T, return_value_policy /* policy */, handle /* parent...
  function load (line 382) | bool load(handle h, bool) {
  function handle (line 409) | static handle cast(const void *ptr, return_value_policy /* policy */, ha...
  function else (line 453) | else if (hasattr(src, PYBIND11_BOOL_ATTR)) {
  function handle (line 473) | static handle cast(bool src, return_value_policy /* policy */, handle /*...
  function load (line 510) | bool load(handle src, bool) {
  function handle (line 562) | static handle
  function handle (line 667) | static handle cast(const CharT *src, return_value_policy policy, handle ...
  function handle (line 674) | static handle cast(CharT src, return_value_policy policy, handle parent) {
  function handle (line 776) | handle cast(T *src, return_value_policy policy, handle parent) {
  function load (line 889) | bool load(handle src, bool convert) {
  function load (line 980) | bool load(handle src, bool convert) {
  function typename (line 1019) | typename type_caster_base<type>::cast_sources srcs{ptr};
  function std (line 1032) | static std::shared_ptr<type> shared_ptr_with_responsible_parent(handle r...
  function check_holder_compat (line 1042) | void check_holder_compat() {
  function set_foreign_holder (line 1051) | bool set_foreign_holder(handle src) {
  function load_value (line 1056) | void load_value(value_and_holder &&v_h) {
  function potentially_slicing_weak_ptr (line 1114) | PYBIND11_NAMESPACE_END(detail)
  function handle (line 1171) | static handle cast(holder_type &&src, return_value_policy, handle) {
  function handle (line 1197) | static handle
  function try_direct_conversions (line 1306) | static bool try_direct_conversions(handle) { return false; }
  function object (line 1370) | struct handle_type_name<object> {
  function list (line 1374) | struct handle_type_name<list> {
  function dict (line 1378) | struct handle_type_name<dict> {
  function anyset (line 1382) | struct handle_type_name<anyset> {
  function set (line 1386) | struct handle_type_name<set> {
  function frozenset (line 1390) | struct handle_type_name<frozenset> {
  function str (line 1394) | struct handle_type_name<str> {
  function tuple (line 1398) | struct handle_type_name<tuple> {
  function bool_ (line 1402) | struct handle_type_name<bool_> {
  function bytes (line 1406) | struct handle_type_name<bytes> {
  function buffer (line 1410) | struct handle_type_name<buffer> {
  function int_ (line 1414) | struct handle_type_name<int_> {
  function iterable (line 1418) | struct handle_type_name<iterable> {
  function iterator (line 1422) | struct handle_type_name<iterator> {
  function float_ (line 1426) | struct handle_type_name<float_> {
  function function (line 1430) | struct handle_type_name<function> {
  function handle (line 1434) | struct handle_type_name<handle> {
  function none (line 1438) | struct handle_type_name<none> {
  function sequence (line 1442) | struct handle_type_name<sequence> {
  function bytearray (line 1446) | struct handle_type_name<bytearray> {
  function memoryview (line 1450) | struct handle_type_name<memoryview> {
  function slice (line 1454) | struct handle_type_name<slice> {
  function type (line 1458) | struct handle_type_name<type> {
  function capsule (line 1462) | struct handle_type_name<capsule> {
  function ellipsis (line 1466) | struct handle_type_name<ellipsis> {
  function weakref (line 1470) | struct handle_type_name<weakref> {
  function args (line 1475) | struct handle_type_name<args> {
  type handle_type_name (line 1497) | struct handle_type_name<str_attr_accessor> {
  type handle_type_name (line 1501) | struct handle_type_name<item_accessor> {
  type handle_type_name (line 1505) | struct handle_type_name<sequence_accessor> {
  type handle_type_name (line 1509) | struct handle_type_name<list_accessor> {
  type handle_type_name (line 1513) | struct handle_type_name<tuple_accessor> {
  function return_value_policy (line 1618) | static return_value_policy policy(return_value_policy p) { return p; }
  function return_value_policy (line 1625) | static return_value_policy policy(return_value_policy p) {
  type override_unused (line 1853) | struct override_unused {}
  type arg (line 1958) | struct arg {
  function arg (line 1985) | struct arg_v : arg {
  type kw_only (line 2041) | struct kw_only {}
  type pos_only (line 2046) | struct pos_only {}
  function namespace (line 2057) | inline namespace literals {
  type function_record (line 2080) | struct function_record
  type function_call (line 2086) | struct function_call {
  function load_args (line 2145) | bool load_args(function_call &call) { return load_impl_sequence(call, in...
  function object (line 2242) | object call(PyObject *ptr) const {
  function tuple (line 2255) | tuple args() const {
  function dict (line 2268) | dict kwargs() const {
  function process (line 2296) | void process(list & /*names_list*/, detail::args_proxy ap) {
  function process (line 2307) | void process(list &names_list, arg_v a) {
  function process (line 2336) | void process(list &names_list, detail::kwargs_proxy kp) {

FILE: include/pybind11/chrono.h
  function PYBIND11_NAMESPACE_BEGIN (line 21) | PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
  function handle (line 77) | static handle cast(const type &src, return_value_policy /* policy */, ha...
  function std (line 105) | inline std::tm *localtime_thread_safe(const std::time_t *time, std::tm *...
  function load (line 126) | bool load(handle src, bool) {
  function handle (line 176) | static handle cast(const std::chrono::time_point<std::chrono::system_clo...

FILE: include/pybind11/complex.h
  function std (line 27) | static std::string format() { return std::string(value); }
  function handle (line 84) | static handle

FILE: include/pybind11/conduit/pybind11_conduit_v1.h
  function namespace (line 79) | namespace pybind11_conduit_v1 {

FILE: include/pybind11/critical_section.h
  function scoped_critical_section (line 9) | PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)

FILE: include/pybind11/detail/argument_vector.h
  function else (line 58) | struct heap_vector {
  type small_vector (line 128) | struct small_vector {
  function T (line 145) | T const *data() const {
  function T (line 160) | T const &operator[](std::size_t idx) const {
  function push_back (line 168) | void push_back(const T &x) { emplace_back(x); }
  function push_back (line 170) | void push_back(T &&x) { emplace_back(std::move(x)); }
  function reserve (line 187) | void reserve(std::size_t sz) {
  function PYBIND11_NOINLINE (line 201) | PYBIND11_NOINLINE void move_to_heap_vector_with_reserved_size(std::size_...
  function PYBIND11_NOINLINE (line 215) | PYBIND11_NOINLINE void reserve_slow_path(std::size_t sz) { m_repr.hvecto...
  function reserve (line 250) | void reserve(std::size_t sz) {
  function const (line 260) | bool operator[](std::size_t idx) const {
  function push_back (line 268) | void push_back(bool b) {
  function swap (line 308) | void swap(small_vector &rhs) noexcept { std::swap(m_repr, rhs.m_repr); }
  type WordAndBitIndex (line 311) | struct WordAndBitIndex {
  function WordAndBitIndex (line 316) | static WordAndBitIndex word_and_bit_index(std::size_t idx) {
  function push_back_steal (line 393) | void push_back_steal(PyObject *p) { m_ptrs.push_back(p); }
  function push_back_borrow (line 396) | void push_back_borrow(PyObject *p) {
  function push_back_null (line 402) | void push_back_null() { m_ptrs.push_back(nullptr); }
  function reserve (line 404) | void reserve(std::size_t sz) { m_ptrs.reserve(sz); }
  function PyObject (line 408) | PyObject *operator[](std::size_t idx) const { return m_ptrs[idx]; }
  function PyObject (line 410) | PyObject *const *data() const { return m_ptrs.data(); }

FILE: include/pybind11/detail/class.h
  function std (line 30) | inline std::string get_fully_qualified_tp_name(PyTypeObject *type) {
  function PyTypeObject (line 42) | inline PyTypeObject *type_incref(PyTypeObject *type) {
  function PyObject (line 50) | inline PyObject *pybind11_static_get(PyObject *self, PyObject * /*ob*/, ...
  function pybind11_static_set (line 55) | inline int pybind11_static_set(PyObject *self, PyObject *obj, PyObject *...
  function PyTypeObject (line 66) | inline PyTypeObject *make_static_property_type() {
  function PyTypeObject (line 112) | inline PyTypeObject *make_static_property_type() {
  function pybind11_meta_setattro (line 138) | inline int pybind11_meta_setattro(PyObject *obj, PyObject *name, PyObjec...
  function PyObject (line 175) | inline PyObject *pybind11_meta_getattro(PyObject *obj, PyObject *name) {
  function PyTypeObject (line 260) | inline PyTypeObject *make_default_metaclass() {
  function PyObject (line 406) | inline PyObject *pybind11_object_new(PyTypeObject *type, PyObject *, PyO...
  function pybind11_object_init (line 413) | inline int pybind11_object_init(PyObject *self, PyObject *, PyObject *) {
  function add_patient (line 420) | inline void add_patient(PyObject *nurse, PyObject *patient) {
  function clear_patients (line 428) | inline void clear_patients(PyObject *self) {
  function clear_instance (line 455) | inline void clear_instance(PyObject *self) {
  function pybind11_object_dealloc (line 496) | inline void pybind11_object_dealloc(PyObject *self) {
  function PYBIND11_WARNING_POP (line 520) | PYBIND11_WARNING_POP
  function pybind11_traverse (line 568) | inline int pybind11_traverse(PyObject *self, visitproc visit, void *arg) {
  function pybind11_clear (line 583) | inline int pybind11_clear(PyObject *self) {
  function enable_dynamic_attributes (line 594) | inline void enable_dynamic_attributes(PyHeapTypeObject *heap_type) {

FILE: include/pybind11/detail/common.h
  function return_value_policy (line 551) | enum class return_value_policy : uint8_t {
  function size_in_ptrs (line 607) | static constexpr size_t size_in_ptrs(size_t s) { return 1 + ((s - 1) >> ...
  function instance_simple_holder_in_ptrs (line 615) | constexpr size_t instance_simple_holder_in_ptrs() {
  type type_info (line 622) | struct type_info
  type value_and_holder (line 623) | struct value_and_holder
  type nonsimple_values_and_holders (line 625) | struct nonsimple_values_and_holders {
  type instance (line 631) | struct instance {
  function next_power_of_2 (line 783) | constexpr size_t next_power_of_2(size_t N) { return N == 0 ? 1 : next_po...
  type select_indices_impl (line 795) | struct select_indices_impl
  type void_type (line 908) | struct void_type {}
  function constexpr_sum (line 917) | size_t constexpr_sum(Ts... ns) {
  function constexpr_sum (line 921) | constexpr size_t constexpr_sum() { return 0; }
  function constexpr_sum (line 923) | size_t constexpr_sum(T n, Ts... ns) {
  function first (line 928) | PYBIND11_NAMESPACE_BEGIN(constexpr_impl)
  function last (line 936) | constexpr int last(int /*i*/, int result) { return result; }
  function PYBIND11_EXPORT_EXCEPTION (line 1091) | PYBIND11_EXPORT_EXCEPTION builtin_exception : public std::runtime_error {
  function pybind11_fail (line 1119) | void pybind11_fail(const char *reason) {
  function PYBIND11_NOINLINE (line 1123) | [[noreturn]] PYBIND11_NOINLINE void pybind11_fail(const std::string &rea...
  function std (line 1170) | static std::string format() { return std::string(1, c); }
  type error_scope (line 1182) | struct error_scope {
  type nodelete (line 1191) | struct nodelete {
  function detail (line 1225) | constexpr detail::overload_cast_impl<Args...> overload_cast{}
  function const_ (line 1231) | static constexpr auto const_ = std::true_type{}
  function operator (line 1277) | operator std::vector<T> &&() && { return std::move(v); }

FILE: include/pybind11/detail/cpp_conduit.h
  function PYBIND11_NAMESPACE_BEGIN (line 12) | PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
  function is_instance_method_of_type (line 28) | inline bool is_instance_method_of_type(PyTypeObject *type_obj, PyObject ...
  function object (line 33) | inline object try_get_cpp_conduit_method(PyObject *obj) {

FILE: include/pybind11/detail/descr.h
  function descr (line 63) | constexpr descr<0> const_name(char const (&)[1]) { return {}; }
  function descr (line 159) | constexpr descr<0> concat() { return {}; }
  function descr (line 160) | constexpr descr<0> union_concat() { return {}; }
  function decltype (line 197) | auto concat(const descr<N, Ts...> &d, const Args &...args)
  function decltype (line 203) | auto union_concat(const descr<N, Ts...> &d, const Args &...args)

FILE: include/pybind11/detail/dynamic_raw_ptr_cast_if_possible.h
  function PYBIND11_NAMESPACE_BEGIN (line 11) | PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)

FILE: include/pybind11/detail/exception_translation.h
  function PYBIND11_NAMESPACE_BEGIN (line 15) | PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
  function try_translate_exceptions (line 36) | inline void try_translate_exceptions() {

FILE: include/pybind11/detail/function_record_pyobject.h
  function PYBIND11_NAMESPACE_BEGIN (line 18) | PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
  function is_function_record_PyObject (line 106) | inline bool is_function_record_PyObject(PyObject *obj) {
  function function_record (line 127) | inline function_record *function_record_ptr_from_PyObject(PyObject *obj) {
  function object (line 134) | inline object function_record_PyObject_New() {
  function PyObject (line 151) | inline PyObject *tp_alloc_impl(PyTypeObject *, Py_ssize_t) {
  function tp_init_impl (line 156) | inline int tp_init_impl(PyObject *, PyObject *, PyObject *) {
  function tp_free_impl (line 161) | inline void tp_free_impl(void *) {
  function PyObject (line 165) | inline PyObject *reduce_ex_impl(PyObject *self, PyObject *, PyObject *) {

FILE: include/pybind11/detail/holder_caster_foreign_helpers.h
  function PYBIND11_NAMESPACE_BEGIN (line 17) | PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)

FILE: include/pybind11/detail/init.h
  function PYBIND11_WARNING_DISABLE_MSVC (line 15) | PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)

FILE: include/pybind11/detail/internals.h
  function T (line 118) | T *get() const { return reinterpret_cast<T *>(PYBIND11_TLS_GET_VALUE(key...
  function PyThreadState (line 146) | inline PyThreadState *get_thread_state_unchecked() {
  function PyInterpreterState (line 156) | inline PyInterpreterState *get_interpreter_state_unchecked() {
  function object (line 161) | inline object get_python_state_dict() {
  function same_type (line 185) | inline bool same_type(const std::type_info &lhs, const std::type_info &r...
  function same_type (line 189) | inline bool same_type(const std::type_info &lhs, const std::type_info &r...
  type type_hash (line 193) | struct type_hash {
  type type_equal_to (line 204) | struct type_equal_to {
  type override_hash (line 220) | struct override_hash {
  function class (line 232) | class pymutex {
  function class (line 242) | class pycritical_section {
  type instance_map_shard (line 274) | struct instance_map_shard {
  function round_up_to_next_pow2 (line 284) | inline uint64_t round_up_to_next_pow2(uint64_t x) {
  type internals (line 304) | struct internals {
  function raise_err (line 500) | inline bool raise_err(PyObject *exc_type, const char *msg) {
  function translate_exception (line 509) | inline void translate_exception(std::exception_ptr p) {
  function translate_local_exception (line 569) | inline void translate_local_exception(std::exception_ptr p) {
  function storage_ptr (line 627) | auto storage_ptr = std::unique_ptr<Payload>(new Payload{}
  function internals_pp_manager (line 681) | static internals_pp_manager &get_instance(char const *id, on_fetch_funct...
  function unref (line 714) | void unref() {
  function destroy (line 725) | void destroy() {
  function create_pp_content_once (line 750) | void create_pp_content_once(std::unique_ptr<InternalsType> *const pp) {
  function PyInterpreterState (line 811) | static PyInterpreterState *&last_istate_tls() {
  function std (line 816) | static std::unique_ptr<InternalsType> *&internals_p_tls() {
  function check_internals_local_exception_translator (line 842) | inline void check_internals_local_exception_translator(internals *intern...
  function internals_pp_manager (line 854) | inline internals_pp_manager<internals> &get_internals_pp_manager() {
  function PYBIND11_NOINLINE (line 865) | PYBIND11_NOINLINE internals &get_internals() {
  function PyObject (line 886) | inline PyObject *get_internals_capsule() {
  function std (line 895) | inline const std::string &get_local_internals_key() {
  function PyObject (line 903) | inline PyObject *get_local_internals_capsule() {
  function ensure_internals (line 909) | inline void ensure_internals() {
  function internals_pp_manager (line 919) | inline internals_pp_manager<local_internals> &get_local_internals_pp_man...
  function local_internals (line 927) | inline local_internals &get_local_internals() {
  function mix64 (line 976) | inline std::uint64_t mix64(std::uint64_t z) {
  function num_registered_instances (line 1011) | inline size_t num_registered_instances() {
  function PYBIND11_NOINLINE (line 1054) | PYBIND11_NOINLINE void *set_shared_data(const std::string &name, void *d...

FILE: include/pybind11/detail/native_enum_data.h
  function class (line 28) | class native_enum_data {
  function arm_finalize_check (line 79) | void arm_finalize_check() {
  function handle (line 104) | inline handle
  function global_internals_native_enum_type_map_contains (line 115) | inline bool
  function object (line 122) | inline object import_or_getattr(const std::string &fully_qualified_name,
  function finalize (line 185) | inline void native_enum_data::finalize() {

FILE: include/pybind11/detail/struct_smart_holder.h
  function PYBIND11_NAMESPACE_BEGIN (line 62) | PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
  function guarded_delete (line 105) | inline guarded_delete *get_guarded_delete(const std::shared_ptr<void> &p...
  function explicit (line 133) | explicit custom_deleter(D &&deleter) : deleter{std::forward<D>(deleter)} {}
  function uqp_del_is_std_default_delete (line 144) | bool uqp_del_is_std_default_delete() {
  function type_info_equal_across_dso_boundaries (line 149) | inline bool type_info_equal_across_dso_boundaries(const std::type_info &a,
  type smart_holder (line 156) | struct smart_holder {

FILE: include/pybind11/detail/type_caster_base.h
  function PYBIND11_NAMESPACE_BEGIN (line 38) | PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
  function PYBIND11_NOINLINE (line 86) | PYBIND11_NOINLINE static void add_patient(handle h) {
  function all_type_info_add_base_most_derived_first (line 111) | inline void all_type_info_add_base_most_derived_first(std::vector<type_i...
  function PYBIND11_NOINLINE (line 124) | PYBIND11_NOINLINE void all_type_info_populate(PyTypeObject *t, std::vect...
  function std (line 187) | inline const std::vector<detail::type_info *> &all_type_info(PyTypeObjec...
  function PYBIND11_NOINLINE (line 196) | PYBIND11_NOINLINE detail::type_info *get_type_info(PyTypeObject *type) {
  function detail (line 208) | inline detail::type_info *get_local_type_info_lock_held(const std::type_...
  function detail (line 217) | inline detail::type_info *get_local_type_info(const std::type_info &tp) {
  function detail (line 223) | inline detail::type_info *get_global_type_info_lock_held(const std::type...
  function detail (line 261) | inline detail::type_info *get_global_type_info(const std::type_info &tp) {
  function PYBIND11_NOINLINE (line 287) | PYBIND11_NOINLINE handle get_type_handle(const std::type_info &tp, bool ...
  function try_incref (line 292) | inline bool try_incref(PyObject *obj) {
  function PYBIND11_NOINLINE (line 336) | PYBIND11_NOINLINE handle find_registered_python_instance(void *src,
  function object (line 1306) | inline object cpp_conduit_method(handle self,
  type recursive_bottom (line 1415) | struct recursive_bottom {}
  function type_caster_base (line 1617) | type_caster_base(typeid(type)) {}
  function explicit (line 1618) | explicit type_caster_base(const std::type_info &info) : type_caster_gene...
  function cast_sources (line 1623) | struct cast_sources : detail::cast_sources {
  function handle (line 1627) | static handle cast(const itype &src, return_value_policy policy, handle ...
  function handle (line 1635) | static handle cast(itype &&src, return_value_policy, handle parent) {
  function handle (line 1639) | static handle cast(const itype *src, return_value_policy policy, handle ...
  function handle (line 1643) | static handle cast(const cast_sources &srcs, return_value_policy policy,...
  function handle (line 1651) | static handle cast_holder(const itype *src, const void *holder) {
  function handle (line 1655) | static handle cast_holder(const cast_sources &srcs, const void *holder) {
  function operator (line 1664) | operator itype *() { return (type *) value; }
  function Constructor (line 1693) | static Constructor make_copy_constructor(...) { return nullptr; }
  function Constructor (line 1694) | static Constructor make_move_constructor(...) { return nullptr; }
  function std (line 1697) | inline std::string quote_cpp_type_name(const std::string &cpp_type_name) {
  function PYBIND11_NOINLINE (line 1701) | PYBIND11_NOINLINE std::string type_info_description(const std::type_info...

FILE: include/pybind11/detail/typeid.h
  function PYBIND11_NAMESPACE_BEGIN (line 21) | PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
  function std (line 51) | inline std::string clean_type_id(const char *typeid_name) {
  function type_id (line 57) | PYBIND11_NAMESPACE_END(detail)

FILE: include/pybind11/detail/value_and_holder.h
  function explicit (line 32) | explicit value_and_holder(size_t index) : index{index}
  function is_holder_constructed (line 86) | inline bool is_holder_constructed(PyObject *obj) {

FILE: include/pybind11/eigen/matrix.h
  function EigenDStride (line 87) | EigenDStride stride{0, 0};    // Only valid if negativestrides is false!
  type eigen_extract_stride (line 132) | struct eigen_extract_stride
  type eigen_extract_stride (line 136) | struct eigen_extract_stride
  function EigenConformable (line 173) | static EigenConformable<row_major> conformable(const array &a) {
  function capsule (line 286) | capsule base(src, [](void *o) { delete static_cast<Type *>(o); }
  function load (line 299) | bool load(handle src, bool convert) {
  function handle (line 347) | handle cast_impl(CType *src, return_value_policy policy, handle parent) {
  function handle (line 372) | static handle cast(const Type &&src, return_value_policy /* policy */, h...
  function handle (line 376) | static handle cast(Type &src, return_value_policy policy, handle parent) {
  function handle (line 384) | static handle cast(const Type &src, return_value_policy policy, handle p...
  function handle (line 392) | static handle cast(Type *src, return_value_policy policy, handle parent) {
  function handle (line 396) | static handle cast(const Type *src, return_value_policy policy, handle p...
  function operator (line 403) | operator Type *() { return &value; }
  function operator (line 556) | operator Type *() { return ref.get(); }
  function handle (line 637) | static handle cast(const Type *src, return_value_policy policy, handle p...
  function load (line 661) | bool load(handle src, bool) {
  function handle (line 700) | static handle cast(const Type &src, return_value_policy /* policy */, ha...

FILE: include/pybind11/eigen/tensor.h
  function PYBIND11_WARNING_DISABLE_MSVC (line 33) | PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
  type eigen_tensor_helper (line 56) | struct eigen_tensor_helper
  function is_correct_shape (line 64) | static constexpr bool
  function free (line 85) | static void free(Type *tensor) { delete tensor; }
  type eigen_tensor_helper (line 89) | struct eigen_tensor_helper
  function load (line 178) | bool load(handle src, bool convert) {
  function handle (line 221) | static handle cast(Type &&src, return_value_policy policy, handle parent) {
  function handle (line 229) | static handle cast(const Type &&src, return_value_policy policy, handle ...
  function handle (line 237) | static handle cast(Type &src, return_value_policy policy, handle parent) {
  function handle (line 245) | static handle cast(const Type &src, return_value_policy policy, handle p...
  function handle (line 253) | static handle cast(Type *src, return_value_policy policy, handle parent) {
  function handle (line 262) | static handle cast(const Type *src, return_value_policy policy, handle p...
  function handle (line 272) | handle cast_impl(C *src, return_value_policy policy, handle parent) {
  function load (line 374) | bool load(handle src, bool /*convert*/) {
  function handle (line 416) | static handle cast(MapType &&src, return_value_policy policy, handle par...
  function handle (line 420) | static handle cast(const MapType &&src, return_value_policy policy, hand...
  function handle (line 424) | static handle cast(MapType &src, return_value_policy policy, handle pare...
  function handle (line 432) | static handle cast(const MapType &src, return_value_policy policy, handl...
  function handle (line 440) | static handle cast(MapType *src, return_value_policy policy, handle pare...
  function handle (line 449) | static handle cast(const MapType *src, return_value_policy policy, handl...

FILE: include/pybind11/embed.h
  function PYBIND11_WARNING_POP (line 65) | PYBIND11_WARNING_POP
  type wide_char_arg_deleter (line 85) | struct wide_char_arg_deleter {
  function wchar_t (line 92) | inline wchar_t *widen_chars(const char *safe_arg) {
  function precheck_interpreter (line 97) | inline void precheck_interpreter() {
  function initialize_interpreter_pre_pyconfig (line 108) | inline void initialize_interpreter_pre_pyconfig(bool init_signal_handlers,
  function finalize_interpreter (line 243) | inline void finalize_interpreter() {
  function class (line 287) | class scoped_interpreter {

FILE: include/pybind11/eval.h
  function PYBIND11_NAMESPACE_BEGIN (line 18) | PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
  function exec (line 88) | inline void exec(const str &expr, object global = globals(), object loca...

FILE: include/pybind11/functional.h
  function PYBIND11_NAMESPACE_BEGIN (line 16) | PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
  type func_wrapper_base (line 43) | struct func_wrapper_base {
  type capture (line 100) | struct capture {

FILE: include/pybind11/gil.h
  function PYBIND11_NAMESPACE_BEGIN (line 31) | PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
  function inc_ref (line 105) | void inc_ref() { ++tstate->gilstate_counter; }
  function PYBIND11_NOINLINE (line 107) | PYBIND11_NOINLINE void dec_ref() {
  function PYBIND11_NOINLINE (line 141) | PYBIND11_NOINLINE void disarm() { active = false; }
  function PYBIND11_NOINLINE (line 143) | PYBIND11_NOINLINE ~gil_scoped_acquire() {
  function class (line 156) | class gil_scoped_release {
  function PYBIND11_NOINLINE (line 180) | PYBIND11_NOINLINE void disarm() { active = false; }

FILE: include/pybind11/gil_safe_call_once.h
  function storage_type (line 252) | storage_type *get_or_create_storage_in_state_dict() {

FILE: include/pybind11/gil_simple.h
  function gil_scoped_acquire_simple (line 11) | PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
  function class (line 23) | class gil_scoped_release_simple {

FILE: include/pybind11/iostream.h
  function PYBIND11_NAMESPACE_BEGIN (line 34) | PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
  function utf8_remainder (line 58) | size_t utf8_remainder() const {
  function is_leading (line 62) | auto is_leading = [](char c) { return (static_cast<unsigned char>(c) & 0...
  function is_leading_2b (line 63) | auto is_leading_2b = [](char c) { return static_cast<unsigned char>(c) <...
  function is_leading_3b (line 64) | auto is_leading_3b = [](char c) { return static_cast<unsigned char>(c) <...
  function _sync (line 94) | int _sync() {
  function sync (line 117) | int sync() override { return _sync(); }
  function class (line 192) | class scoped_estream_redirect : public scoped_ostream_redirect {
  function OstreamRedirect (line 200) | PYBIND11_NAMESPACE_BEGIN(detail)
  function exit (line 222) | void exit() {

FILE: include/pybind11/numpy.h
  function PYBIND11_WARNING_DISABLE_MSVC (line 49) | PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
  function array (line 67) | struct handle_type_name<array> {
  type PyArrayDescr1_Proxy (line 75) | struct PyArrayDescr1_Proxy {
  type PyArrayDescr_Proxy (line 90) | struct PyArrayDescr_Proxy {
  type PyArrayDescr2_Proxy (line 102) | struct PyArrayDescr2_Proxy {
  type PyArray_Proxy (line 122) | struct PyArray_Proxy {
  type PyVoidScalarObject_Proxy (line 133) | struct PyVoidScalarObject_Proxy {
  type numpy_type_info (line 140) | struct numpy_type_info {
  function if (line 145) | struct numpy_internals {
  function numpy_internals (line 169) | inline numpy_internals &get_numpy_internals() {
  function PYBIND11_NOINLINE (line 177) | PYBIND11_NOINLINE module_ import_numpy_core_submodule(const char *submod...
  function PyArray_Check_ (line 207) | struct npy_api {
  function PyArrayDescr_Check_ (line 287) | bool PyArrayDescr_Check_(PyObject *obj) const {
  type functions (line 323) | enum functions {
  function npy_api (line 348) | static npy_api lookup() {
  function PyArray_Proxy (line 534) | inline PyArray_Proxy *array_proxy(void *ptr) { return reinterpret_cast<P...
  function PyArray_Proxy (line 536) | inline const PyArray_Proxy *array_proxy(const void *ptr) {
  function PyArrayDescr_Proxy (line 540) | inline PyArrayDescr_Proxy *array_descriptor_proxy(PyObject *ptr) {
  function PyArrayDescr_Proxy (line 544) | inline const PyArrayDescr_Proxy *array_descriptor_proxy(const PyObject *...
  function PyArrayDescr1_Proxy (line 548) | inline const PyArrayDescr1_Proxy *array_descriptor1_proxy(const PyObject...
  function PyArrayDescr2_Proxy (line 552) | inline const PyArrayDescr2_Proxy *array_descriptor2_proxy(const PyObject...
  function check_flags (line 556) | inline bool check_flags(const void *ptr, int flag) {
  function append_extents (line 571) | static void append_extents(list & /* shape */) {}
  function append_extents (line 586) | static void append_extents(list &shape) {
  function itemsize (line 706) | constexpr static ssize_t itemsize() { return sizeof(T); }
  function shape (line 709) | ssize_t shape(ssize_t dim) const { return shape_[(size_t) dim]; }
  function handle (line 784) | static handle &target_type() {
  function handle (line 789) | static handle &target_dtype() {
  function load (line 794) | bool load(handle src, bool) {
  function handle (line 802) | static handle cast(numpy_scalar<T> src, return_value_policy, handle) {
  function numpy_scalar (line 807) | PYBIND11_NAMESPACE_END(detail)
  function class (line 836) | class dtype : public object {
  function explicit (line 865) | explicit dtype(int typenum)
  function dtype (line 873) | static dtype from_args(const object &args) {
  function dtype (line 883) | dtype of() {
  function num_of (line 890) | constexpr int num_of() {
  function normalized_num (line 940) | int normalized_num() const {
  function byteorder (line 949) | char byteorder() const { return detail::array_descriptor_proxy(m_ptr)->b...
  function explicit (line 1122) | explicit array(const buffer_info &info, handle base = handle())
  function size (line 1131) | ssize_t size() const {
  function ndim (line 1142) | ssize_t ndim() const { return detail::array_proxy(m_ptr)->nd; }
  function strides (line 1176) | ssize_t strides(ssize_t dim) const {
  function flags (line 1184) | int flags() const { return detail::array_proxy(m_ptr)->flags; }
  function array (line 1266) | array squeeze() {
  function array (line 1291) | array reshape(ShapeContainer new_shape) {
  function array (line 1307) | array view(const std::string &dtype) {
  type detail (line 1329) | struct detail
  function fail_dim_check (line 1331) | void fail_dim_check(ssize_t dim, const std::string &msg) const {
  function check_dimensions_impl (line 1353) | void check_dimensions_impl(ssize_t, const ssize_t *) const {}
  type private_ctor (line 1379) | struct private_ctor {}
  function explicit (line 1414) | explicit array_t(const buffer_info &info, handle base = handle()) : arra...
  function array_t (line 1495) | static array_t ensure(handle h) {
  function check_ (line 1503) | static bool check_(handle h) {
  function std (line 1530) | static std::string format() {
  function string (line 1537) | string format() { return std::to_string(N) + 's'; }
  function string (line 1541) | string format() { return std::to_string(N) + 's'; }
  function std (line 1546) | static std::string format() {
  function std (line 1554) | static std::string format() {
  function load (line 1566) | bool load(handle src, bool convert) {
  function handle (line 1574) | static handle cast(const handle &src, return_value_policy /* policy */, ...
  function compare (line 1582) | static bool compare(const buffer_info &b) {
  function pybind11 (line 1613) | static pybind11::dtype dtype() { return pybind11::dtype(/*typenum*/ valu...
  function pybind11 (line 1626) | static pybind11::dtype dtype() { return pybind11::dtype(/*typenum*/ valu...
  function pybind11 (line 1654) | static pybind11::dtype dtype() {
  function pybind11 (line 1669) | static pybind11::dtype dtype() { return base_descr::dtype(); }
  type field_descriptor (line 1672) | struct field_descriptor {
  function pybind11 (line 1762) | static pybind11::dtype dtype() { return reinterpret_borrow<pybind11::dty...
  function std (line 1764) | static std::string format() {
  function register_dtype (line 1769) | static void register_dtype(any_container<field_descriptor> fields) {
  function direct_converter (line 1782) | static bool direct_converter(PyObject *obj, void *&value) {
  function class (line 1875) | class common_iterator {
  function init_common_iterator (line 1941) | void init_common_iterator(const buffer_info &buffer,
  function increment_common_iterator (line 1967) | void increment_common_iterator(size_t dim) {
  function broadcast_trivial (line 1978) | enum class broadcast_trivial { non_trivial, c_trivial, f_trivial };
  function Type (line 2095) | static Type create(broadcast_trivial trivial, const std::vector<ssize_t>...
  function Return (line 2102) | static Return *mutable_data(Type &array) { return array.mutable_data(); }
  function Return (line 2104) | static Return call(Func &f, Args &...args) { return f(args...); }
  function call (line 2106) | static void call(Return *out, size_t i, Func &f, Args &...args) { out[i]...
  function Type (line 2114) | static Type create(broadcast_trivial, const std::vector<ssize_t> &) { re...
  function detail (line 2118) | static detail::void_type call(Func &f, Args &...args) {
  function call (line 2123) | static void call(void *, size_t, Func &f, Args &...args) { f(args...); }
  function object (line 2149) | object operator()(typename vectorize_arg<Args>::type... args) {

FILE: include/pybind11/operators.h
  function PYBIND11_NAMESPACE_BEGIN (line 14) | PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
  type op_impl (line 82) | struct op_impl {}

FILE: include/pybind11/options.h
  function options (line 14) | PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
  function show_user_defined_docstrings (line 62) | static bool show_user_defined_docstrings() {
  function show_function_signatures (line 66) | static bool show_function_signatures() { return global_state().show_func...
  function show_enum_members_docstring (line 68) | static bool show_enum_members_docstring() {
  type state (line 76) | struct state {
  function state (line 84) | static state &global_state() {

FILE: include/pybind11/pybind11.h
  function replace_newlines_and_squash (line 68) | PYBIND11_NAMESPACE_BEGIN(detail)
  function std (line 112) | inline std::string generate_function_signature(const char *type_caster_n...
  type InitializingFunctionRecordDeleter (line 377) | struct InitializingFunctionRecordDeleter {
  function PYBIND11_NOINLINE (line 386) | PYBIND11_NOINLINE unique_function_record make_function_record() {
  function handle (line 396) | handle call_impl(detail::function_call &call, detail::function_ref<Retur...
  type capture (line 434) | struct capture {
  function class (line 584) | class strdup_guard {
  function release (line 600) | void release() { strings.clear(); }
  function initialize_generic (line 607) | void initialize_generic(unique_function_record &&unique_rec,
  function loader_life_support (line 1139) | loader_life_support guard{}
  function append_note_if_missing_header_is_suspected (line 1198) | auto append_note_if_missing_header_is_suspected = [](std::string &msg) {
  function keyword_index (line 1316) | static ssize_t keyword_index(PyObject *haystack, char const *needle) {
  function PYBIND11_NAMESPACE_BEGIN (line 1339) | PYBIND11_NAMESPACE_BEGIN(detail)
  function cpp_function (line 1350) | PYBIND11_NAMESPACE_END(function_record_PyTypeObject_methods)
  function mod_gil_not_used (line 1357) | PYBIND11_NAMESPACE_END(detail)
  function class (line 1369) | class multiple_interpreters {
  function gil_not_used_option (line 1392) | PYBIND11_NAMESPACE_BEGIN(detail)
  function gil_not_used_option (line 1398) | bool gil_not_used_option(mod_gil_not_used f, O &&...o) {
  function PyObject (line 1431) | inline PyObject *get_cached_module(pybind11::str const &nameobj) {
  function cache_completed_module (line 1448) | inline void cache_completed_module(pybind11::object const &mod) {
  function PyObject (line 1460) | inline PyObject *cached_create_module(PyObject *spec, PyModuleDef *) {
  function slots_array (line 1484) | slots_array init_slots(int (*exec_fn)(PyObject *), Options &&...options)...
  function module_ (line 1591) | static module_ import(const char *name) {
  function reload (line 1600) | void reload() {
  function module_ (line 1633) | static module_ create_extension_module(const char *name,
  function module_ (line 1667) | PYBIND11_NAMESPACE_BEGIN(detail)
  function dict (line 1684) | inline dict globals() {
  function mark_parents_nonsimple (line 1778) | void mark_parents_nonsimple(PyTypeObject *value) {
  function cpp_function (line 1930) | cpp_function readonly(PM pm, const handle &hdl) {
  function cpp_function (line 1935) | cpp_function read(PM pm, const handle &hdl) {
  function cpp_function (line 1940) | cpp_function write(PM pm, const handle &hdl) {
  function cpp_function (line 1977) | cpp_function readonly(PM pm, const handle &hdl) {
  function cpp_function (line 1994) | cpp_function read(PM pm, const handle &hdl) {
  function cpp_function (line 1999) | cpp_function write(PM pm, const handle &hdl) {
  function cpp_function (line 2017) | cpp_function readonly(PM pm, const handle &hdl) {
  function cpp_function (line 2034) | cpp_function read(PM pm, const handle &hdl) {
  function cpp_function (line 2050) | cpp_function write(PM pm, const handle &hdl) {
  function cpp_function (line 2069) | cpp_function readonly(PM, const handle &) {
  function cpp_function (line 2076) | cpp_function read(PM pm, const handle &hdl) {
  function add_base (line 2259) | void add_base(detail::type_record &rec) {
  function add_base (line 2266) | void add_base(detail::type_record &) {}
  type capture (line 2333) | struct capture {
  function cpp_function (line 2389) | cpp_function fget([pm](const object &) -> const D & { return *pm; }
  function cpp_function (line 2397) | cpp_function fget([pm](const object &) -> const D & { return *pm; }
  function init_holder (line 2515) | void init_holder(detail::instance *inst,
  function init_holder_from_existing (line 2533) | static void init_holder_from_existing(const detail::value_and_holder &v_h,
  function init_holder_from_existing (line 2539) | static void init_holder_from_existing(const detail::value_and_holder &v_h,
  function init_holder (line 2548) | static void init_holder(detail::instance *inst,
  function init_instance (line 2567) | void init_instance(detail::instance *inst, const void *holder_ptr) {
  function try_initialization_using_shared_from_this (line 2577) | bool try_initialization_using_shared_from_this(holder_type *, WrappedTyp...
  function try_initialization_using_shared_from_this (line 2587) | bool try_initialization_using_shared_from_this(
  function init_instance (line 2603) | void init_instance(detail::instance *inst, const void *holder_const_void...
  function dealloc_impl (line 2642) | static void dealloc_impl(detail::value_and_holder &v_h) {
  function dealloc_without_manipulating_gil (line 2653) | static void dealloc_without_manipulating_gil(detail::value_and_holder &v...
  function dealloc_release_gil_before_calling_cpp_dtor (line 2658) | static void dealloc_release_gil_before_calling_cpp_dtor(detail::value_an...
  function detail (line 2679) | static detail::function_record *get_function_record(handle h) {
  function enum_name (line 2731) | PYBIND11_NAMESPACE_BEGIN(detail)
  type enum_base (line 2743) | struct enum_base {
  function PYBIND11_NOINLINE (line 2891) | PYBIND11_NOINLINE void export_values() {
  type equivalent_integer (line 2905) | struct equivalent_integer
  type equivalent_integer (line 2909) | struct equivalent_integer
  type equivalent_integer (line 2913) | struct equivalent_integer
  type equivalent_integer (line 2917) | struct equivalent_integer
  type equivalent_integer (line 2921) | struct equivalent_integer
  type equivalent_integer (line 2925) | struct equivalent_integer
  type equivalent_integer (line 2929) | struct equivalent_integer
  type equivalent_integer (line 2933) | struct equivalent_integer
  function keep_alive_impl (line 3071) | void keep_alive_impl(handle nurse, handle patient) {
  function PYBIND11_NOINLINE (line 3101) | PYBIND11_NOINLINE void
  function std (line 3119) | inline std::pair<decltype(internals::registered_types_py)::iterator, bool>
  function result_type (line 3186) | result_type operator()(Iterator &it) const { return *it; }
  function result_type (line 3208) | result_type operator()(Iterator &it) const { return (*it).first; }
  function result_type (line 3221) | result_type operator()(Iterator &it) const { return (*it).second; }
  function set_flag (line 3362) | struct set_flag {
  function register_exception_translator (line 3400) | inline void register_exception_translator(ExceptionTranslator &&translat...
  function register_local_exception_translator (line 3415) | inline void register_local_exception_translator(ExceptionTranslator &&tr...
  function exception (line 3453) | PYBIND11_NAMESPACE_BEGIN(detail)
  function register_exception (line 3484) | PYBIND11_NAMESPACE_END(detail)
  function print (line 3513) | void print(const tuple &args, const dict &kwargs) {
  function m_fetched_error_deleter (line 3552) | inline void
  function get_type_override (line 3565) | PYBIND11_NAMESPACE_BEGIN(detail)
  function get_override (line 3671) | PYBIND11_NAMESPACE_END(detail)
  function function (line 3783) | inline function
  function function (line 3789) | function get_overload(const T *this_ptr, const char *name) {

FILE: include/pybind11/pytypes.h
  function PYBIND11_WARNING_DISABLE_MSVC (line 34) | PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
  function class (line 74) | class pyobject_tag {}
  function m_ptr (line 254) | m_ptr(ptr) {}
  function m_ptr (line 265) | m_ptr(obj) {}
  function PyObject (line 268) | PyObject *ptr() const { return m_ptr; }
  function throw_gilstate_error (line 328) | void throw_gilstate_error(const std::string &function_name) const {
  function inc_ref_counter (line 353) | static std::size_t inc_ref_counter(std::size_t add) {
  function set_error (line 364) | inline void set_error(const handle &type, const char *message) {
  function set_error (line 368) | inline void set_error(const handle &type, const handle &value) {
  function class (line 382) | class object : public handle {
  function restore (line 721) | void restore() {
  function matches (line 731) | bool matches(handle exc) const {
  function std (line 745) | inline std::string error_string() {
  function PYBIND11_EXPORT_EXCEPTION (line 755) | PYBIND11_EXPORT_EXCEPTION error_already_set : public std::exception {
  function raise_from (line 813) | inline void raise_from(PyObject *type, const char *message) {
  function raise_from (line 842) | inline void raise_from(error_already_set &err, PyObject *type, const cha...
  function isinstance (line 871) | inline bool isinstance<object>(handle obj) {
  function isinstance (line 877) | inline bool isinstance(handle obj, handle type) {
  function hasattr (line 887) | inline bool hasattr(handle obj, handle name) {
  function hasattr (line 891) | inline bool hasattr(handle obj, const char *name) {
  function delattr (line 895) | inline void delattr(handle obj, handle name) {
  function delattr (line 901) | inline void delattr(handle obj, const char *name) {
  function object (line 907) | inline object getattr(handle obj, handle name) {
  function object (line 915) | inline object getattr(handle obj, const char *name) {
  function object (line 923) | inline object getattr(handle obj, handle name, handle default_) {
  function object (line 931) | inline object getattr(handle obj, const char *name, handle default_) {
  function setattr (line 939) | inline void setattr(handle obj, handle name, handle value) {
  function setattr (line 945) | inline void setattr(handle obj, const char *name, handle value) {
  function hash (line 951) | inline ssize_t hash(handle obj) {
  function get_function (line 961) | PYBIND11_NAMESPACE_BEGIN(detail)
  function PyObject (line 977) | inline PyObject *dict_getitemstring(PyObject *v, const char *key) {
  function PyObject (line 992) | inline PyObject *dict_getitem(PyObject *v, PyObject *key) {
  function PyObject (line 1002) | inline PyObject *dict_getitemstringref(PyObject *v, const char *key) {
  function PyObject (line 1019) | inline PyObject *dict_setdefaultstring(PyObject *v, const char *key, PyO...
  function PyObject (line 1035) | inline PyObject *dict_setdefaultstringref(PyObject *v, const char *key, ...
  function handle (line 1070) | inline handle object_or_cast(PyObject *ptr) { return ptr; }
  function PYBIND11_WARNING_PUSH (line 1072) | PYBIND11_WARNING_PUSH
  function PyObject (line 1115) | PyObject *ptr() const { return get_cache().ptr(); }
  function object (line 1123) | static object ensure_object(handle h) { return reinterpret_borrow<object...
  function PYBIND11_WARNING_POP (line 1137) | PYBIND11_WARNING_POP
  function set (line 1146) | struct str_attr {
  type generic_item (line 1152) | struct generic_item {
  function set (line 1163) | static void set(handle obj, handle key, handle val) {
  type sequence_item (line 1170) | struct sequence_item {
  type list_item (line 1191) | struct list_item {
  type tuple_item (line 1212) | struct tuple_item {
  function reference (line 1252) | reference operator[](difference_type n) const { return *(*this + n); }
  function pointer (line 1253) | pointer operator->() const { return **this; }
  function arrow_proxy (line 1301) | PYBIND11_NAMESPACE_BEGIN(iterator_policies)
  function class (line 1313) | class sequence_fast_readonly {
  function class (line 1336) | class sequence_slow_readwrite {
  function class (line 1359) | class dict_readonly {
  function increment (line 1371) | void increment() {
  function equal (line 1376) | bool equal(const dict_readonly &b) const { return pos == b.pos; }
  function PyIterable_Check (line 1396) | inline bool PyIterable_Check(PyObject *obj) {
  function PyNone_Check (line 1406) | inline bool PyNone_Check(PyObject *o) { return o == Py_None; }
  function PyEllipsis_Check (line 1407) | inline bool PyEllipsis_Check(PyObject *o) { return o == Py_Ellipsis; }
  function PyUnicode_Check_Permissive (line 1410) | inline bool PyUnicode_Check_Permissive(PyObject *o) {
  function PyStaticMethod_Check (line 1418) | inline bool PyStaticMethod_Check(PyObject *o) { return Py_TYPE(o) == &Py...
  function class (line 1420) | class kwargs_proxy : public handle {
  function class (line 1425) | class args_proxy : public handle {
  function Parent (line 1484) | Name(const object &o)                                                   ...
  function Parent (line 1508) | Name(const object &o) : Parent(o) {                                     ...
  function class (line 1533) | class iterator : public object {
  function reference (line 1561) | reference operator*() const {
  function pointer (line 1566) | pointer operator->() const {
  function iterator (line 1584) | static iterator sentinel() { return {}; }
  function advance (line 1597) | void advance() {
  function class (line 1608) | class type : public object {
  function class (line 1636) | class iterable : public object {
  function namespace (line 1736) | inline namespace literals {
  function class (line 1753) | class bytes : public object {
  function bytes (line 1809) | inline bytes::bytes(const pybind11::str &s) {
  function str (line 1829) | inline str::str(const bytes &b) {
  function class (line 1847) | class bytearray : public object {
  function class (line 1877) | class none : public object {
  function class (line 1883) | class ellipsis : public object {
  function class (line 1889) | class bool_ : public object {
  function as_unsigned (line 1910) | PYBIND11_NAMESPACE_BEGIN(detail)
  function class (line 1963) | class float_ : public object {
  function class (line 1985) | class weakref : public object {
  function class (line 2002) | class slice : public object {
  function compute (line 2031) | bool compute(
  function object (line 2040) | object index_to_object(T index) {
  function class (line 2045) | class capsule : public object {
  function explicit (line 2078) | explicit capsule(void (*destructor)()) {
  function set_pointer (line 2110) | void set_pointer(const void *value) {
  function set_name (line 2125) | void set_name(const char *new_name) {
  function initialize_with_void_ptr_destructor (line 2144) | void initialize_with_void_ptr_destructor(const void *value,
  function class (line 2171) | class tuple : public object {
  function args_are_all_keyword_or_ds (line 2197) | bool args_are_all_keyword_or_ds() {
  function class (line 2201) | class dict : public object {
  function clear (line 2220) | void clear() /* py-non-const */ { PyDict_Clear(ptr()); }
  function class (line 2241) | class sequence : public object {
  function item_accessor (line 2254) | item_accessor operator[](T &&o) const {
  function class (line 2261) | class list : public object {
  function class (line 2305) | class args : public tuple {
  function memoryview (line 2502) | static memoryview from_memory(const void *mem, ssize_t size) {
  function memoryview (line 2507) | static memoryview from_memory(std::string_view mem) {
  function memoryview (line 2514) | inline memoryview memoryview::from_buffer(void *ptr,
  function len (line 2553) | inline size_t len(handle h) {
  function len_hint (line 2563) | inline size_t len_hint(handle h) {
  function str (line 2574) | inline str repr(handle h) {
  function iterator (line 2582) | inline iterator iter(handle obj) {
  function PYBIND11_MATH_OPERATOR_UNARY (line 2699) | PYBIND11_MATH_OPERATOR_UNARY(operator~, PyNumber_Invert)

FILE: include/pybind11/stl.h
  function PYBIND11_NAMESPACE_BEGIN (line 39) | PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
  function object_is_convertible_to_std_vector (line 91) | inline bool object_is_convertible_to_std_vector(const handle &src) {
  function object_is_convertible_to_std_set (line 102) | inline bool object_is_convertible_to_std_set(const handle &src, bool con...
  function object_is_convertible_to_std_map (line 110) | inline bool object_is_convertible_to_std_map(const handle &src, bool con...
  function reserve_maybe (line 168) | void reserve_maybe(const anyset &, void *) {}
  function convert_iterable (line 170) | bool convert_iterable(const iterable &itbl, bool convert) {
  function convert_anyset (line 181) | bool convert_anyset(const anyset &s, bool convert) {
  function reserve_maybe (line 235) | void reserve_maybe(const dict &, void *) {}
  function convert_elements (line 237) | bool convert_elements(const dict &d, bool convert) {
  function load (line 302) | bool load(handle src, bool convert) {
  function reserve_maybe (line 325) | void reserve_maybe(const sequence &, void *) {}
  function convert_elements (line 327) | bool convert_elements(handle seq, bool convert) {
  function operator (line 486) | operator ArrayType *() { return &(*value); }
  function load (line 544) | bool load(handle src, bool convert) {
  type variant_caster_visitor (line 582) | struct variant_caster_visitor {
  type type_caster (line 652) | struct type_caster

FILE: include/pybind11/stl/filesystem.h
  function PyObject (line 47) | static PyObject *unicode_from_fs_native(const std::wstring &w) {
  function load (line 61) | bool load(handle handle, bool) {
  type type_caster (line 106) | struct type_caster
  type type_caster (line 109) | struct type_caster

FILE: include/pybind11/stl_bind.h
  function PYBIND11_NAMESPACE_BEGIN (line 21) | PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
  type values_view (line 654) | struct values_view {
  type items_view (line 660) | struct items_view {
  function explicit (line 668) | explicit KeysViewImpl(Map &map) : map(map) {}
  function len (line 669) | size_t len() override { return map.size(); }
  function iterator (line 670) | iterator iter() override { return make_key_iterator(map.begin(), map.end...
  function contains (line 671) | bool contains(const handle &k) override {
  function explicit (line 683) | explicit ValuesViewImpl(Map &map) : map(map) {}
  function len (line 684) | size_t len() override { return map.size(); }
  function iterator (line 685) | iterator iter() override { return make_value_iterator(map.begin(), map.e...
  function explicit (line 691) | explicit ItemsViewImpl(Map &map) : map(map) {}
  function len (line 692) | size_t len() override { return map.size(); }
  function iterator (line 693) | iterator iter() override { return make_iterator(map.begin(), map.end()); }
  function str (line 697) | inline str format_message_key_error_key_object(handle py_key) {

FILE: include/pybind11/subinterpreter.h
  function class (line 29) | class subinterpreter_scoped_activate {
  function class (line 47) | class subinterpreter {
  function class (line 235) | class scoped_subinterpreter {
  function subinterpreter_scoped_activate (line 247) | inline subinterpreter_scoped_activate::subinterpreter_scoped_activate(su...
  function subinterpreter_scoped_activate (line 270) | inline subinterpreter_scoped_activate::~subinterpreter_scoped_activate() {

FILE: include/pybind11/trampoline_self_life_support.h
  function PYBIND11_NAMESPACE_BEGIN (line 11) | PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)

FILE: include/pybind11/type_caster_pyobject_ptr.h
  function PYBIND11_NAMESPACE_BEGIN (line 10) | PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
  function load (line 46) | bool load(handle src, bool) {

FILE: include/pybind11/typing.h
  function PYBIND11_NAMESPACE_BEGIN (line 26) | PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
  function PYBIND11_NAMESPACE_BEGIN (line 140) | PYBIND11_NAMESPACE_END(typing)

FILE: include/pybind11/warnings.h
  function PYBIND11_NAMESPACE_BEGIN (line 15) | PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)

FILE: noxfile.py
  function lint (line 25) | def lint(session: nox.Session) -> None:
  function tests (line 34) | def tests(session: nox.Session) -> None:
  function tests_packaging (line 55) | def tests_packaging(session: nox.Session) -> None:
  function docs (line 65) | def docs(session: nox.Session) -> None:
  function make_changelog (line 99) | def make_changelog(session: nox.Session) -> None:
  function build (line 107) | def build(session: nox.Session) -> None:
  function preserve_file (line 118) | def preserve_file(filename: Path) -> Generator[str, None, None]:
  function build_global (line 132) | def build_global(session: nox.Session) -> None:

FILE: pybind11/__main__.py
  function quote (line 23) | def quote(s: str) -> str:
  function quote (line 32) | def quote(s: str) -> str:
  function print_includes (line 36) | def print_includes() -> None:
  function main (line 52) | def main() -> None:

FILE: pybind11/_version.py
  function _to_int (line 27) | def _to_int(s: str) -> int | str:

FILE: pybind11/commands.py
  function get_include (line 8) | def get_include(user: bool = False) -> str:  # noqa: ARG001
  function get_cmake_dir (line 18) | def get_cmake_dir() -> str:
  function get_pkgconfig_dir (line 30) | def get_pkgconfig_dir() -> str:

FILE: pybind11/setup_helpers.py
  class Pybind11Extension (line 89) | class Pybind11Extension(_Extension):
    method _add_cflags (line 116) | def _add_cflags(self, flags: list[str]) -> None:
    method _add_ldflags (line 119) | def _add_ldflags(self, flags: list[str]) -> None:
    method __init__ (line 122) | def __init__(self, *args: Any, **kwargs: Any) -> None:
    method cxx_std (line 161) | def cxx_std(self) -> int:
    method cxx_std (line 172) | def cxx_std(self, level: int) -> None:
  function tmp_chdir (line 213) | def tmp_chdir() -> Iterator[str]:
  function has_flag (line 229) | def has_flag(compiler: Any, flag: str) -> bool:
  function auto_cpp_level (line 253) | def auto_cpp_level(compiler: Any) -> str | int:
  class build_ext (line 271) | class build_ext(_build_ext):  # noqa: N801
    method build_extensions (line 278) | def build_extensions(self) -> None:
  function intree_extensions (line 290) | def intree_extensions(
  function naive_recompile (line 332) | def naive_recompile(obj: str, src: str) -> bool:
  function no_recompile (line 341) | def no_recompile(obg: str, src: str) -> bool:  # noqa: ARG001
  class ParallelCompile (line 372) | class ParallelCompile:
    method __init__ (line 410) | def __init__(
    method function (line 423) | def function(self) -> CCompilerMethod:
    method install (line 488) | def install(self: S) -> S:
    method __enter__ (line 495) | def __enter__(self: S) -> S:
    method __exit__ (line 499) | def __exit__(self, *args: Any) -> None:

FILE: tests/conftest.py
  function use_multiprocessing_forkserver_on_linux (line 34) | def use_multiprocessing_forkserver_on_linux():
  function _strip_and_dedent (line 54) | def _strip_and_dedent(s):
  function _split_and_sort (line 59) | def _split_and_sort(s):
  function _make_explanation (line 64) | def _make_explanation(a, b):
  class Output (line 71) | class Output:
    method __init__ (line 74) | def __init__(self, string):
    method __str__ (line 78) | def __str__(self):
    method __eq__ (line 83) | def __eq__(self, other):
  class Unordered (line 97) | class Unordered(Output):
    method __eq__ (line 102) | def __eq__(self, other):
  class Capture (line 111) | class Capture:
    method __init__ (line 112) | def __init__(self, capfd):
    method __enter__ (line 117) | def __enter__(self):
    method __exit__ (line 121) | def __exit__(self, *args):
    method __eq__ (line 126) | def __eq__(self, other):
    method __str__ (line 134) | def __str__(self):
    method __contains__ (line 137) | def __contains__(self, item):
    method unordered (line 141) | def unordered(self):
    method stderr (line 145) | def stderr(self):
  function capture (line 150) | def capture(capsys):
  class SanitizedString (line 155) | class SanitizedString:
    method __init__ (line 156) | def __init__(self, sanitizer):
    method __call__ (line 161) | def __call__(self, thing):
    method __eq__ (line 167) | def __eq__(self, other):
  function _sanitize_general (line 176) | def _sanitize_general(s):
  function _sanitize_docstring (line 182) | def _sanitize_docstring(thing):
  function doc (line 188) | def doc():
  function _sanitize_message (line 193) | def _sanitize_message(thing):
  function msg (line 200) | def msg():
  function pytest_assertrepr_compare (line 205) | def pytest_assertrepr_compare(op, left, right):  # noqa: ARG001
  function gc_collect (line 221) | def gc_collect():
  function delattr_and_ensure_destroyed (line 228) | def delattr_and_ensure_destroyed(*specs):
  function pytest_configure (line 256) | def pytest_configure():
  function pytest_report_header (line 262) | def pytest_report_header():
  function backport_typehints (line 295) | def backport_typehints() -> Callable[[SanitizedString], SanitizedString]:

FILE: tests/constructor_stats.h
  function class (line 75) | class ConstructorStats {
  function value (line 142) | void value() {}
  function ConstructorStats (line 178) | static ConstructorStats &get(py::object class_) {

FILE: tests/cross_module_gil_utils.cpp
  function gil_acquire (line 31) | void gil_acquire() { py::gil_scoped_acquire gil; }
  function gil_multi_acquire_release (line 33) | std::string gil_multi_acquire_release(unsigned bits) {
  type CustomAutoGIL (line 49) | struct CustomAutoGIL {
    method CustomAutoGIL (line 50) | CustomAutoGIL() : gstate(PyGILState_Ensure()) {}
  type CustomAutoNoGIL (line 55) | struct CustomAutoNoGIL {
    method CustomAutoNoGIL (line 56) | CustomAutoNoGIL() : save(PyEval_SaveThread()) {}
  function gil_acquire_inner (line 63) | void gil_acquire_inner() {
  function gil_acquire_nested (line 70) | void gil_acquire_nested() {
  type PyModuleDef (line 80) | struct PyModuleDef
  function PYBIND11_EXPORT (line 88) | PYBIND11_EXPORT PyObject *PyInit_cross_module_gil_utils() {

FILE: tests/cross_module_interleaved_error_already_set.cpp
  function interleaved_error_already_set (line 18) | void interleaved_error_already_set() {
  type PyModuleDef (line 35) | struct PyModuleDef
  function PYBIND11_EXPORT (line 40) | PYBIND11_EXPORT PyObject *PyInit_cross_module_interleaved_error_already_...

FILE: tests/custom_exceptions.py
  class PythonMyException7 (line 4) | class PythonMyException7(Exception):
    method __init__ (line 5) | def __init__(self, message):
    method __str__ (line 9) | def __str__(self):

FILE: tests/eigen_tensor_avoid_stl_array.cpp
  function PYBIND11_MODULE (line 14) | PYBIND11_MODULE(eigen_tensor_avoid_stl_array, m, pybind11::mod_gil_not_u...

FILE: tests/env.py
  function _is_musl (line 20) | def _is_musl() -> bool:
  function check_script_success_in_subprocess (line 48) | def check_script_success_in_subprocess(code: str, *, rerun: int = 8) -> ...

FILE: tests/exo_planet_c_api.cpp
  function PyObject (line 28) | PyObject *wrapGetLuggage(PyObject * /*self*/, PyObject *traveler) {
  function PyObject (line 37) | PyObject *wrapGetPoints(PyObject * /*self*/, PyObject *premium_traveler) {
  type PyModuleDef (line 50) | struct PyModuleDef
  function EXO_PLANET_C_API_EXPORT (line 70) | EXO_PLANET_C_API_EXPORT PyObject *PyInit_exo_planet_c_api() {

FILE: tests/exo_planet_pybind11.cpp
  type pybind11_tests (line 10) | namespace pybind11_tests {
    type test_cpp_conduit (line 11) | namespace test_cpp_conduit {
      function PYBIND11_MODULE (line 13) | PYBIND11_MODULE(exo_planet_pybind11, m) {

FILE: tests/extra_python_package/test_files.py
  function preserve_file (line 150) | def preserve_file(filename: Path) -> Generator[str, None, None]:
  function build_global (line 161) | def build_global() -> Generator[None, None, None]:
  function read_tz_file (line 173) | def read_tz_file(tar: tarfile.TarFile, name: str) -> bytes:
  function normalize_line_endings (line 181) | def normalize_line_endings(value: bytes) -> bytes:
  function test_build_sdist (line 185) | def test_build_sdist(monkeypatch, tmpdir):
  function test_build_global_dist (line 214) | def test_build_global_dist(monkeypatch, tmpdir):
  function tests_build_wheel (line 251) | def tests_build_wheel(monkeypatch, tmpdir):
  function tests_build_global_wheel (line 298) | def tests_build_global_wheel(monkeypatch, tmpdir):
  function test_version_matches (line 356) | def test_version_matches():

FILE: tests/extra_setuptools/test_setuphelper.py
  function test_simple_setup_py (line 17) | def test_simple_setup_py(monkeypatch, tmpdir, parallel, std):
  function test_intree_extensions (line 113) | def test_intree_extensions(monkeypatch, tmpdir):
  function test_intree_extensions_package_dir (line 133) | def test_intree_extensions_package_dir(monkeypatch, tmpdir):

FILE: tests/home_planet_very_lonely_traveler.cpp
  type pybind11_tests (line 5) | namespace pybind11_tests {
    type test_cpp_conduit (line 6) | namespace test_cpp_conduit {
      function PYBIND11_MODULE (line 8) | PYBIND11_MODULE(home_planet_very_lonely_traveler, m) {

FILE: tests/local_bindings.h
  function class (line 41) | class LocalException : public std::exception {
  function class (line 51) | class LocalSimpleException : public std::exception {
  function namespace (line 77) | namespace pets {

FILE: tests/mod_per_interpreter_gil.cpp
  function PYBIND11_MODULE (line 9) | PYBIND11_MODULE(mod_per_interpreter_gil,

FILE: tests/mod_per_interpreter_gil_with_singleton.cpp
  type pybind11_tests (line 12) | namespace pybind11_tests {
    type mod_per_interpreter_gil_with_singleton (line 13) | namespace mod_per_interpreter_gil_with_singleton {
      class MySingleton (line 16) | class MySingleton {
        method MySingleton (line 18) | MySingleton() = default;
        method MySingleton (line 20) | MySingleton(const MySingleton &) = delete;
        method MySingleton (line 21) | MySingleton &operator=(const MySingleton &) = delete;
        method MySingleton (line 22) | MySingleton(MySingleton &&) = default;
        method MySingleton (line 23) | MySingleton &operator=(MySingleton &&) = default;
        method MySingleton (line 25) | static MySingleton &get_instance() {
        method init (line 53) | static void init() {
        method clear (line 62) | static void clear() {
      class MyClass (line 76) | class MyClass {
        method MyClass (line 78) | explicit MyClass(py::ssize_t v) : value(v) {}
        method get_value (line 79) | py::ssize_t get_value() const { return value; }
      class MyGlobalError (line 85) | class MyGlobalError : public std::runtime_error {
      class MyLocalError (line 90) | class MyLocalError : public std::runtime_error {
      type MyEnum (line 95) | enum class MyEnum : int {
  function PYBIND11_MODULE (line 103) | PYBIND11_MODULE(mod_per_interpreter_gil_with_singleton,

FILE: tests/mod_shared_interpreter_gil.cpp
  function PYBIND11_MODULE (line 9) | PYBIND11_MODULE(mod_shared_interpreter_gil, m, py::multiple_interpreters...

FILE: tests/object.h
  function class (line 9) | class Object {
  function class (line 54) | class ref_tag {}
  function explicit (line 76) | explicit ref(T *ptr) : m_ptr(ptr) {
  function m_ptr (line 86) | ref(const ref &r) : m_ptr(r.m_ptr) {
  function operator (line 169) | bool operator==(const ref &r) const { return m_ptr == r.m_ptr; }
  function operator (line 172) | bool operator!=(const ref &r) const { return m_ptr != r.m_ptr; }
  function T (line 184) | const T *operator->() const { return m_ptr; }

FILE: tests/pure_cpp/smart_holder_poc.h
  function PYBIND11_NAMESPACE_BEGIN (line 9) | PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)

FILE: tests/pure_cpp/smart_holder_poc_test.cpp
  type helpers (line 21) | namespace helpers {
    type movable_int (line 23) | struct movable_int {
      method movable_int (line 25) | explicit movable_int(int v) : valu{v} {}
      method movable_int (line 26) | movable_int(movable_int &&other) noexcept : valu(other.valu) { other...
    type functor_builtin_delete (line 30) | struct functor_builtin_delete {
      method functor_builtin_delete (line 37) | functor_builtin_delete() = default;
      method functor_builtin_delete (line 38) | functor_builtin_delete(const functor_builtin_delete &) {}
      method functor_builtin_delete (line 39) | functor_builtin_delete(functor_builtin_delete &&) {}
    type functor_other_delete (line 44) | struct functor_other_delete : functor_builtin_delete<T> {}
    type indestructible_int (line 46) | struct indestructible_int {
      method indestructible_int (line 48) | explicit indestructible_int(int v) : valu{v} {}
    type base (line 54) | struct base {
      method get (line 55) | virtual int get() { return 10; }
    type derived (line 59) | struct derived : public base {
      method get (line 60) | int get() override { return 100; }

FILE: tests/pybind11_cross_module_tests.cpp
  class CrossDSOClass (line 19) | class CrossDSOClass {
    method CrossDSOClass (line 21) | CrossDSOClass() = default;
    method CrossDSOClass (line 23) | CrossDSOClass(const CrossDSOClass &) = default;
  function PYBIND11_MODULE (line 28) | PYBIND11_MODULE(pybind11_cross_module_tests, m, py::mod_gil_not_used()) {

FILE: tests/pybind11_tests.cpp
  function bind_ConstructorStats (line 44) | void bind_ConstructorStats(py::module_ &m) {
  function PYBIND11_MODULE (line 78) | PYBIND11_MODULE(pybind11_tests, m, py::mod_gil_not_used()) {

FILE: tests/pybind11_tests.h
  function class (line 11) | class test_initializer {
  type UnregisteredType (line 25) | struct UnregisteredType {}
  function class (line 28) | class UserType {
  function class (line 41) | class IncType : public UserType {
  function class (line 57) | class UnusualOpRef {

FILE: tests/test_async.cpp
  function TEST_SUBMODULE (line 12) | TEST_SUBMODULE(async_module, m) {

FILE: tests/test_async.py
  function event_loop (line 15) | def event_loop():
  function get_await_result (line 21) | async def get_await_result(x):
  function test_await (line 25) | def test_await(event_loop):
  function test_await_missing (line 29) | def test_await_missing(event_loop):

FILE: tests/test_buffers.cpp
  function TEST_SUBMODULE (line 16) | TEST_SUBMODULE(buffers, m) {

FILE: tests/test_buffers.py
  function test_format_descriptor_format_buffer_info_equiv (line 54) | def test_format_descriptor_format_buffer_info_equiv(cpp_name, np_dtype):
  function test_from_python (line 73) | def test_from_python():
  function test_to_python (line 103) | def test_to_python():
  function test_inherited_protocol (line 140) | def test_inherited_protocol():
  function test_pointer_to_member_fn (line 148) | def test_pointer_to_member_fn():
  function test_readonly_buffer (line 156) | def test_readonly_buffer():
  function test_selective_readonly_buffer (line 165) | def test_selective_readonly_buffer():
  function test_ctypes_array_1d (line 181) | def test_ctypes_array_1d():
  function test_ctypes_array_2d (line 196) | def test_ctypes_array_2d():
  function test_ctypes_from_buffer (line 211) | def test_ctypes_from_buffer():
  function test_buffer_docstring (line 230) | def test_buffer_docstring(doc, backport_typehints):
  function test_buffer_exception (line 237) | def test_buffer_exception():
  function test_c_contiguous_to_pybuffer (line 245) | def test_c_contiguous_to_pybuffer(type):
  function test_fortran_contiguous_to_pybuffer (line 298) | def test_fortran_contiguous_to_pybuffer(type):
  function test_discontiguous_to_pybuffer (line 326) | def test_discontiguous_to_pybuffer(type):
  function test_to_pybuffer_contiguity (line 345) | def test_to_pybuffer_contiguity(type):

FILE: tests/test_builtin_casters.cpp
  type ConstRefCasted (line 14) | struct ConstRefCasted {
  class type_caster<ConstRefCasted> (line 21) | class type_caster<ConstRefCasted> {
    method load (line 27) | bool load(handle, bool) { return true; }
  function TEST_SUBMODULE (line 75) | TEST_SUBMODULE(builtin_casters, m) {

FILE: tests/test_builtin_casters.py
  function test_simple_string (line 12) | def test_simple_string():
  function test_unicode_conversion (line 16) | def test_unicode_conversion():
  function test_single_char_arguments (line 51) | def test_single_char_arguments():
  function test_bytes_to_string (line 124) | def test_bytes_to_string():
  function test_bytearray_to_string (line 138) | def test_bytearray_to_string():
  function test_string_view (line 148) | def test_string_view(capture):
  function test_integer_casting (line 227) | def test_integer_casting():
  function test_int_convert (line 250) | def test_int_convert(doc):
  function test_float_convert (line 372) | def test_float_convert(doc):
  function test_numpy_int_convert (line 408) | def test_numpy_int_convert():
  function test_tuple (line 432) | def test_tuple(doc):
  function test_builtins_cast_return_none (line 470) | def test_builtins_cast_return_none():
  function test_none_deferred (line 480) | def test_none_deferred():
  function test_void_caster (line 489) | def test_void_caster():
  function test_reference_wrapper (line 494) | def test_reference_wrapper():
  function test_complex_cast (line 529) | def test_complex_cast(doc):
  function test_complex_index_handling (line 590) | def test_complex_index_handling():
  function test_overload_resolution_float_int (line 641) | def test_overload_resolution_float_int():
  function test_bool_caster (line 703) | def test_bool_caster():
  function test_numpy_bool (line 746) | def test_numpy_bool():
  function test_int_long (line 762) | def test_int_long():
  function test_void_caster_2 (line 768) | def test_void_caster_2():
  function test_const_ref_caster (line 772) | def test_const_ref_caster():

FILE: tests/test_call_policies.cpp
  type CustomGuard (line 12) | struct CustomGuard {
    method CustomGuard (line 15) | CustomGuard() { enabled = true; }
  type DependentGuard (line 22) | struct DependentGuard {
    method DependentGuard (line 25) | DependentGuard() { enabled = CustomGuard::enabled; }
  function TEST_SUBMODULE (line 32) | TEST_SUBMODULE(call_policies, m) {

FILE: tests/test_call_policies.py
  function test_keep_alive_argument (line 12) | def test_keep_alive_argument(capture):
  function test_keep_alive_return_value (line 65) | def test_keep_alive_return_value(capture):
  function test_alive_gc (line 124) | def test_alive_gc(capture):
  function test_alive_gc_derived (line 144) | def test_alive_gc_derived(capture):
  function test_alive_gc_multi_derived (line 167) | def test_alive_gc_multi_derived(capture):
  function test_return_none (line 194) | def test_return_none(capture):
  function test_keep_alive_constructor (line 222) | def test_keep_alive_constructor(capture):
  function test_call_guard (line 247) | def test_call_guard():

FILE: tests/test_callbacks.cpp
  type test_callbacks (line 17) | namespace test_callbacks {
    type boost_histogram (line 18) | namespace boost_histogram { // See PR #5580
      function custom_transform_double (line 20) | double custom_transform_double(double value) { return value * 3; }
      function custom_transform_int (line 21) | int custom_transform_int(int value) { return value; }
      function apply_custom_transform (line 25) | double apply_custom_transform(const py::object &src, double value) {
  function dummy_function (line 43) | int dummy_function(int i) { return i + 1; }
  function TEST_SUBMODULE (line 45) | TEST_SUBMODULE(callbacks, m) {

FILE: tests/test_callbacks.py
  function test_callbacks (line 14) | def test_callbacks():
  function test_bound_method_callback (line 38) | def test_bound_method_callback():
  function test_keyword_args_and_generalized_unpacking (line 51) | def test_keyword_args_and_generalized_unpacking():
  function test_lambda_closure_cleanup (line 94) | def test_lambda_closure_cleanup():
  function test_cpp_callable_cleanup (line 103) | def test_cpp_callable_cleanup():
  function test_cpp_function_roundtrip (line 108) | def test_cpp_function_roundtrip():
  function test_function_signatures (line 140) | def test_function_signatures(doc):
  function test_movable_object (line 151) | def test_movable_object():
  function test_python_builtins (line 159) | def test_python_builtins():
  function test_async_callbacks (line 166) | def test_async_callbacks():
  function test_async_async_callbacks (line 191) | def test_async_async_callbacks():
  function test_callback_num_times (line 197) | def test_callback_num_times():
  function test_custom_func (line 222) | def test_custom_func():
  function test_custom_func2 (line 227) | def test_custom_func2():
  function test_callback_docstring (line 232) | def test_callback_docstring():
  function test_boost_histogram_apply_custom_transform (line 239) | def test_boost_histogram_apply_custom_transform():

FILE: tests/test_chrono.cpp
  type different_resolutions (line 17) | struct different_resolutions {
  function TEST_SUBMODULE (line 32) | TEST_SUBMODULE(chrono, m) {

FILE: tests/test_chrono.py
  function test_chrono_system_clock (line 11) | def test_chrono_system_clock():
  function test_chrono_system_clock_roundtrip (line 32) | def test_chrono_system_clock_roundtrip():
  function test_chrono_system_clock_roundtrip_date (line 46) | def test_chrono_system_clock_roundtrip_date():
  function test_chrono_system_clock_roundtrip_time (line 102) | def test_chrono_system_clock_roundtrip_time(time1, tz, monkeypatch):
  function test_chrono_duration_roundtrip (line 125) | def test_chrono_duration_roundtrip():
  function test_chrono_duration_subtraction_equivalence (line 145) | def test_chrono_duration_subtraction_equivalence():
  function test_chrono_duration_subtraction_equivalence_date (line 155) | def test_chrono_duration_subtraction_equivalence_date():
  function test_chrono_steady_clock (line 165) | def test_chrono_steady_clock():
  function test_chrono_steady_clock_roundtrip (line 170) | def test_chrono_steady_clock_roundtrip():
  function test_floating_point_duration (line 180) | def test_floating_point_duration():
  function test_nano_timepoint (line 194) | def test_nano_timepoint():
  function test_chrono_different_resolutions (line 200) | def test_chrono_different_resolutions():

FILE: tests/test_class.cpp
  type NoBraceInitialization (line 29) | struct NoBraceInitialization {
    method NoBraceInitialization (line 30) | explicit NoBraceInitialization(std::vector<int> v) : vec{std::move(v)} {}
    method NoBraceInitialization (line 32) | NoBraceInitialization(std::initializer_list<T> l) : vec(l) {}
  type test_class (line 37) | namespace test_class {
    type pr4220_tripped_over_this (line 38) | namespace pr4220_tripped_over_this { // PR #4227
      type SoEmpty (line 41) | struct SoEmpty {}
      function get_msg (line 44) | std::string get_msg(const T &) {
      function bind_empty0 (line 50) | void bind_empty0(py::module_ &m) {
    type pr5396_forward_declared_class (line 56) | namespace pr5396_forward_declared_class {
      class ForwardClass (line 57) | class ForwardClass
      class Args (line 58) | class Args : public py::args {}
    type ConvertibleFromAnything (line 61) | struct ConvertibleFromAnything {
      method ConvertibleFromAnything (line 62) | ConvertibleFromAnything() = default;
      method ConvertibleFromAnything (line 65) | ConvertibleFromAnything(T &&) {}
  type NoConstructor (line 84) | struct NoConstructor {
    method NoConstructor (line 85) | NoConstructor() = default;
    method NoConstructor (line 86) | NoConstructor(const NoConstructor &) = default;
    method NoConstructor (line 87) | NoConstructor(NoConstructor &&) = default;
    method NoConstructor (line 88) | static NoConstructor *new_instance() {
  type NoConstructorNew (line 95) | struct NoConstructorNew {
    method NoConstructorNew (line 96) | NoConstructorNew() = default;
    method NoConstructorNew (line 97) | NoConstructorNew(const NoConstructorNew &) = default;
    method NoConstructorNew (line 98) | NoConstructorNew(NoConstructorNew &&) = default;
    method NoConstructorNew (line 99) | static NoConstructorNew *new_instance() {
  type ToBeHeldByUniquePtr (line 116) | struct ToBeHeldByUniquePtr {}
  class Pet (line 122) | class Pet {
    method Pet (line 124) | Pet(const std::string &name, const std::string &species)
    method name (line 126) | std::string name() const { return m_name; }
    method species (line 127) | std::string species() const { return m_species; }
  class Dog (line 134) | class Dog : public Pet {
    method Dog (line 136) | explicit Dog(const std::string &name) : Pet(name, "dog") {}
    method bark (line 137) | std::string bark() const { return "Woof!"; }
  class Rabbit (line 140) | class Rabbit : public Pet {
    method Rabbit (line 142) | explicit Rabbit(const std::string &name) : Pet(name, "parrot") {}
  class Hamster (line 145) | class Hamster : public Pet {
    method Hamster (line 147) | explicit Hamster(const std::string &name) : Pet(name, "rodent") {}
  class Chimera (line 150) | class Chimera : public Pet {
    method Chimera (line 151) | Chimera() : Pet("Kimmy", "chimera") {}
  type BaseClass (line 176) | struct BaseClass {
    method BaseClass (line 177) | BaseClass() = default;
    method BaseClass (line 178) | BaseClass(const BaseClass &) = default;
    method BaseClass (line 179) | BaseClass(BaseClass &&) = default;
  type DerivedClass1 (line 182) | struct DerivedClass1 : BaseClass {}
  type DerivedClass2 (line 183) | struct DerivedClass2 : BaseClass {}
  type Invalid (line 213) | struct Invalid {}
  type MismatchBase1 (line 234) | struct MismatchBase1 {}
  type MismatchDerived1 (line 235) | struct MismatchDerived1 : MismatchBase1 {}
  type MismatchBase2 (line 237) | struct MismatchBase2 {}
  type MismatchDerived2 (line 238) | struct MismatchDerived2 : MismatchBase2 {}
  type MyBase (line 255) | struct MyBase {
    method make (line 256) | static std::unique_ptr<MyBase> make() { return std::unique_ptr<MyBase>...
  type MyDerived (line 259) | struct MyDerived : MyBase {
    method make (line 260) | static std::unique_ptr<MyDerived> make() {
  type ConvertibleFromUserType (line 272) | struct ConvertibleFromUserType {
    method ConvertibleFromUserType (line 275) | explicit ConvertibleFromUserType(UserType u) : i(u.value()) {}
  type HasOpNewDel (line 308) | struct HasOpNewDel {
  type HasOpNewDelSize (line 323) | struct HasOpNewDelSize {
  type AliasedHasOpNewDelSize (line 338) | struct AliasedHasOpNewDelSize {
    method AliasedHasOpNewDelSize (line 353) | AliasedHasOpNewDelSize() = default;
    method AliasedHasOpNewDelSize (line 354) | AliasedHasOpNewDelSize(const AliasedHasOpNewDelSize &) = delete;
  type PyAliasedHasOpNewDelSize (line 356) | struct PyAliasedHasOpNewDelSize : AliasedHasOpNewDelSize {
    method PyAliasedHasOpNewDelSize (line 357) | PyAliasedHasOpNewDelSize() = default;
    method PyAliasedHasOpNewDelSize (line 358) | explicit PyAliasedHasOpNewDelSize(int) {}
  type HasOpNewDelBoth (line 361) | struct HasOpNewDelBoth {
  class ProtectedA (line 394) | class ProtectedA {
    method foo (line 396) | int foo() const { return value; }
  class PublicistA (line 402) | class PublicistA : public ProtectedA {
  class ProtectedB (line 409) | class ProtectedB {
    method ProtectedB (line 412) | ProtectedB() = default;
    method ProtectedB (line 413) | ProtectedB(const ProtectedB &) = delete;
    method foo (line 416) | virtual int foo() const { return value; }
  function PYBIND11_OVERRIDE (line 427) | PYBIND11_OVERRIDE(void *, ProtectedB, void_foo, ); }
  class BreaksBase (line 596) | class BreaksBase {
    method BreaksBase (line 599) | BreaksBase() = default;
    method BreaksBase (line 600) | BreaksBase(const BreaksBase &) = delete;
  class BreaksTramp (line 603) | class BreaksTramp : public BreaksBase<N> {}
  type BreaksBase<-8> (line 691) | struct BreaksBase<-8> : BreaksBase<-6>, BreaksBase<-7> {}

FILE: tests/test_class.py
  function refcount_immortal (line 15) | def refcount_immortal(ob: object) -> int:
  function test_obj_class_name (line 21) | def test_obj_class_name():
  function test_repr (line 27) | def test_repr():
  function test_instance (line 32) | def test_instance(msg):
  function test_instance_new (line 48) | def test_instance_new():
  function test_pass_unique_ptr (line 60) | def test_pass_unique_ptr():
  function test_type (line 70) | def test_type():
  function test_type_of_py (line 85) | def test_type_of_py():
  function test_type_of_classic (line 91) | def test_type_of_classic():
  function test_type_of_py_nodelete (line 97) | def test_type_of_py_nodelete():
  function test_as_type_py (line 102) | def test_as_type_py():
  function test_docstrings (line 112) | def test_docstrings(doc):
  function test_qualname (line 139) | def test_qualname(doc):
  function test_inheritance (line 179) | def test_inheritance(msg):
  function test_inheritance_init (line 214) | def test_inheritance_init(msg):
  function test_mock_new (line 239) | def test_mock_new(mock_return_value):
  function test_automatic_upcasting (line 248) | def test_automatic_upcasting():
  function test_isinstance (line 262) | def test_isinstance():
  function test_mismatched_holder (line 268) | def test_mismatched_holder():
  function test_override_static (line 288) | def test_override_static():
  function test_implicit_conversion_life_support (line 299) | def test_implicit_conversion_life_support():
  function test_operator_new_delete (line 307) | def test_operator_new_delete(capture):
  function test_bind_protected_functions (line 356) | def test_bind_protected_functions():
  function test_brace_initialization (line 377) | def test_brace_initialization():
  function test_class_refcount (line 391) | def test_class_refcount():
  function test_reentrant_implicit_conversion_failure (line 413) | def test_reentrant_implicit_conversion_failure(msg):
  function test_error_after_conversions (line 428) | def test_error_after_conversions():
  function test_aligned (line 436) | def test_aligned():
  function test_final (line 444) | def test_final():
  function test_non_final_final (line 455) | def test_non_final_final():
  function test_exception_rvalue_abort (line 465) | def test_exception_rvalue_abort():
  function test_multiple_instances_with_same_pointer (line 471) | def test_multiple_instances_with_same_pointer():
  function test_base_and_derived_nested_scope (line 486) | def test_base_and_derived_nested_scope():
  function test_register_duplicate_class (line 493) | def test_register_duplicate_class():
  function test_pr4220_tripped_over_this (line 525) | def test_pr4220_tripped_over_this():
  function test_all_type_info_multithreaded (line 533) | def test_all_type_info_multithreaded():

FILE: tests/test_class_cross_module_use_after_one_module_dealloc.cpp
  class CrossDSOClass (line 5) | class CrossDSOClass {
    method CrossDSOClass (line 7) | CrossDSOClass() = default;
    method CrossDSOClass (line 9) | CrossDSOClass(const CrossDSOClass &) = default;
  type UnrelatedClass (line 14) | struct UnrelatedClass {}
  function TEST_SUBMODULE (line 16) | TEST_SUBMODULE(class_cross_module_use_after_one_module_dealloc, m) {

FILE: tests/test_class_cross_module_use_after_one_module_dealloc.py
  function test_cross_module_use_after_one_module_dealloc (line 14) | def test_cross_module_use_after_one_module_dealloc():

FILE: tests/test_class_release_gil_before_calling_cpp_dtor.cpp
  type pybind11_tests (line 8) | namespace pybind11_tests {
    type class_release_gil_before_calling_cpp_dtor (line 9) | namespace class_release_gil_before_calling_cpp_dtor {
      function RegistryType (line 13) | static RegistryType &PyGILState_Check_Results() {
      type ProbeType (line 19) | struct ProbeType {
        method ProbeType (line 24) | explicit ProbeType(const std::string &unique_key) : unique_key{uni...
        method ProbeType (line 25) | ProbeType(const ProbeType &) = default;
  function TEST_SUBMODULE (line 37) | TEST_SUBMODULE(class_release_gil_before_calling_cpp_dtor, m) {

FILE: tests/test_class_release_gil_before_calling_cpp_dtor.py
  function test_gil_state_check_results (line 17) | def test_gil_state_check_results(probe_type, unique_key, expected_result):

FILE: tests/test_class_sh_basic.cpp
  type pybind11_tests (line 7) | namespace pybind11_tests {
    type class_sh_basic (line 8) | namespace class_sh_basic {
      type atyp (line 10) | struct atyp { // Short for "any type".
        method atyp (line 12) | atyp() : mtxt("DefaultConstructor") {}
        method atyp (line 13) | explicit atyp(const std::string &mtxt_) : mtxt(mtxt_) {}
        method atyp (line 14) | atyp(const atyp &other) { mtxt = other.mtxt + "_CpCtor"; }
        method atyp (line 15) | atyp(atyp &&other) noexcept { mtxt = other.mtxt + "_MvCtor"; }
      type uconsumer (line 18) | struct uconsumer { // unique_ptr consumer
        method valid (line 20) | bool valid() const { return static_cast<bool>(held); }
        method pass_valu (line 22) | void pass_valu(std::unique_ptr<atyp> obj) { held = std::move(obj); }
        method pass_rref (line 23) | void pass_rref(std::unique_ptr<atyp> &&obj) { held = std::move(obj...
        method rtrn_valu (line 24) | std::unique_ptr<atyp> rtrn_valu() { return std::move(held); }
      type custom_deleter (line 30) | struct custom_deleter {
        method custom_deleter (line 33) | custom_deleter() = default;
        method custom_deleter (line 34) | explicit custom_deleter(const std::string &trace_txt_) : trace_txt...
        method custom_deleter (line 36) | custom_deleter(const custom_deleter &other) { trace_txt = other.tr...
        method custom_deleter (line 38) | custom_deleter &operator=(const custom_deleter &rhs) {
        method custom_deleter (line 43) | custom_deleter(custom_deleter &&other) noexcept {
        method custom_deleter (line 48) | custom_deleter &operator=(custom_deleter &&rhs) noexcept {
      type custom_deleter_nd (line 60) | struct custom_deleter_nd : custom_deleter {
        method custom_deleter_nd (line 61) | custom_deleter_nd() = delete;
        method custom_deleter_nd (line 62) | explicit custom_deleter_nd(const std::string &trace_txt_) : custom...
      function atyp (line 68) | atyp        rtrn_valu() { atyp obj{"rtrn_valu"}; return obj; }
        method atyp (line 12) | atyp() : mtxt("DefaultConstructor") {}
        method atyp (line 13) | explicit atyp(const std::string &mtxt_) : mtxt(mtxt_) {}
        method atyp (line 14) | atyp(const atyp &other) { mtxt = other.mtxt + "_CpCtor"; }
        method atyp (line 15) | atyp(atyp &&other) noexcept { mtxt = other.mtxt + "_MvCtor"; }
      function atyp (line 69) | atyp&&      rtrn_rref() { static atyp obj; obj.mtxt = "rtrn_rref"; r...
        method atyp (line 12) | atyp() : mtxt("DefaultConstructor") {}
        method atyp (line 13) | explicit atyp(const std::string &mtxt_) : mtxt(mtxt_) {}
        method atyp (line 14) | atyp(const atyp &other) { mtxt = other.mtxt + "_CpCtor"; }
        method atyp (line 15) | atyp(atyp &&other) noexcept { mtxt = other.mtxt + "_MvCtor"; }
      function atyp (line 70) | atyp const& rtrn_cref() { static atyp obj; obj.mtxt = "rtrn_cref"; r...
        method atyp (line 12) | atyp() : mtxt("DefaultConstructor") {}
        method atyp (line 13) | explicit atyp(const std::string &mtxt_) : mtxt(mtxt_) {}
        method atyp (line 14) | atyp(const atyp &other) { mtxt = other.mtxt + "_CpCtor"; }
        method atyp (line 15) | atyp(atyp &&other) noexcept { mtxt = other.mtxt + "_MvCtor"; }
      function atyp (line 71) | atyp&       rtrn_mref() { static atyp obj; obj.mtxt = "rtrn_mref"; r...
        method atyp (line 12) | atyp() : mtxt("DefaultConstructor") {}
        method atyp (line 13) | explicit atyp(const std::string &mtxt_) : mtxt(mtxt_) {}
        method atyp (line 14) | atyp(const atyp &other) { mtxt = other.mtxt + "_CpCtor"; }
        method atyp (line 15) | atyp(atyp &&other) noexcept { mtxt = other.mtxt + "_MvCtor"; }
      function atyp (line 72) | atyp const* rtrn_cptr() { return new atyp{"rtrn_cptr"}; }
        method atyp (line 12) | atyp() : mtxt("DefaultConstructor") {}
        method atyp (line 13) | explicit atyp(const std::string &mtxt_) : mtxt(mtxt_) {}
        method atyp (line 14) | atyp(const atyp &other) { mtxt = other.mtxt + "_CpCtor"; }
        method atyp (line 15) | atyp(atyp &&other) noexcept { mtxt = other.mtxt + "_MvCtor"; }
      function atyp (line 73) | atyp*       rtrn_mptr() { return new atyp{"rtrn_mptr"}; }
        method atyp (line 12) | atyp() : mtxt("DefaultConstructor") {}
        method atyp (line 13) | explicit atyp(const std::string &mtxt_) : mtxt(mtxt_) {}
        method atyp (line 14) | atyp(const atyp &other) { mtxt = other.mtxt + "_CpCtor"; }
        method atyp (line 15) | atyp(atyp &&other) noexcept { mtxt = other.mtxt + "_MvCtor"; }
      function pass_valu (line 75) | std::string pass_valu(atyp obj)        { return "pass_valu:" + obj.m...
      function pass_cref (line 76) | std::string pass_cref(atyp const& obj) { return "pass_cref:" + obj.m...
      function pass_mref (line 77) | std::string pass_mref(atyp& obj)       { return "pass_mref:" + obj.m...
      function pass_cptr (line 78) | std::string pass_cptr(atyp const* obj) { return "pass_cptr:" + obj->...
      function pass_mptr (line 79) | std::string pass_mptr(atyp* obj)       { return "pass_mptr:" + obj->...
      function rtrn_shmp (line 81) | std::shared_ptr<atyp>       rtrn_shmp() { return std::make_shared<at...
      function rtrn_shcp (line 82) | std::shared_ptr<atyp const> rtrn_shcp() { return std::shared_ptr<aty...
      function pass_shmp (line 84) | std::string pass_shmp(std::shared_ptr<atyp>       obj) { return "pas...
      function pass_shcp (line 85) | std::string pass_shcp(std::shared_ptr<atyp const> obj) { return "pas...
      function rtrn_uqmp (line 87) | std::unique_ptr<atyp>       rtrn_uqmp() { return std::unique_ptr<aty...
      function rtrn_uqcp (line 88) | std::unique_ptr<atyp const> rtrn_uqcp() { return std::unique_ptr<aty...
      function pass_uqmp (line 90) | std::string pass_uqmp(std::unique_ptr<atyp      > obj) { return "pas...
      function pass_uqcp (line 91) | std::string pass_uqcp(std::unique_ptr<atyp const> obj) { return "pas...
      type sddm (line 93) | struct sddm : std::default_delete<atyp      > {}
      type sddc (line 94) | struct sddc : std::default_delete<atyp const> {}
      function rtrn_udmp (line 96) | std::unique_ptr<atyp,       sddm> rtrn_udmp() { return std::unique_p...
      function rtrn_udcp (line 97) | std::unique_ptr<atyp const, sddc> rtrn_udcp() { return std::unique_p...
      function pass_udmp (line 99) | std::string pass_udmp(std::unique_ptr<atyp,       sddm> obj) { retur...
      function pass_udcp (line 100) | std::string pass_udcp(std::unique_ptr<atyp const, sddc> obj) { retur...
      function rtrn_udmp_del (line 102) | std::unique_ptr<atyp,       custom_deleter> rtrn_udmp_del() { return...
      function rtrn_udcp_del (line 103) | std::unique_ptr<atyp const, custom_deleter> rtrn_udcp_del() { return...
      function pass_udmp_del (line 105) | std::string pass_udmp_del(std::unique_ptr<atyp,       custom_deleter...
      function pass_udcp_del (line 106) | std::string pass_udcp_del(std::unique_ptr<atyp const, custom_deleter...
      function rtrn_udmp_del_nd (line 108) | std::unique_ptr<atyp,       custom_deleter_nd> rtrn_udmp_del_nd() { ...
      function rtrn_udcp_del_nd (line 109) | std::unique_ptr<atyp const, custom_deleter_nd> rtrn_udcp_del_nd() { ...
      function pass_udmp_del_nd (line 111) | std::string pass_udmp_del_nd(std::unique_ptr<atyp,       custom_dele...
      function pass_udcp_del_nd (line 112) | std::string pass_udcp_del_nd(std::unique_ptr<atyp const, custom_dele...
      function get_mtxt (line 117) | std::string get_mtxt(atyp const &obj) { return obj.mtxt; }
      function get_ptr (line 118) | std::ptrdiff_t get_ptr(atyp const &obj) { return reinterpret_cast<st...
      function unique_ptr_roundtrip (line 120) | std::unique_ptr<atyp> unique_ptr_roundtrip(std::unique_ptr<atyp> obj...
      function pass_unique_ptr_cref (line 122) | std::string pass_unique_ptr_cref(const std::unique_ptr<atyp> &obj) {...
      type SharedPtrStash (line 137) | struct SharedPtrStash {
        method Add (line 139) | void Add(const std::shared_ptr<const atyp> &obj) { stash.push_back...
      class LocalUnusualOpRef (line 142) | class LocalUnusualOpRef : UnusualOpRef {}
      function CastUnusualOpRefConstRef (line 143) | py::object CastUnusualOpRefConstRef(const LocalUnusualOpRef &cref) {...
      function CastUnusualOpRefMovable (line 144) | py::object CastUnusualOpRefMovable(LocalUnusualOpRef &&mvbl) { retur...
      function TEST_SUBMODULE (line 146) | TEST_SUBMODULE(class_sh_basic, m) {

FILE: tests/test_class_sh_basic.py
  function test_atyp_constructors (line 11) | def test_atyp_constructors():
  function test_cast (line 37) | def test_cast(rtrn_f, expected):
  function test_load_with_mtxt (line 55) | def test_load_with_mtxt(pass_f, mtxt, expected):
  function test_load_with_rtrn_f (line 66) | def test_load_with_rtrn_f(pass_f, rtrn_f, expected):
  function test_deleter_roundtrip (line 95) | def test_deleter_roundtrip(pass_f, rtrn_f, regex_expected):
  function test_pass_unique_ptr_disowns (line 108) | def test_pass_unique_ptr_disowns(pass_f, rtrn_f, expected):
  function test_cannot_disown_use_count_ne_1 (line 129) | def test_cannot_disown_use_count_ne_1(pass_f, rtrn_f):
  function test_unique_ptr_roundtrip (line 138) | def test_unique_ptr_roundtrip():
  function test_pass_unique_ptr_cref (line 152) | def test_pass_unique_ptr_cref():
  function test_rtrn_unique_ptr_cref (line 159) | def test_rtrn_unique_ptr_cref():
  function test_unique_ptr_cref_roundtrip (line 168) | def test_unique_ptr_cref_roundtrip():
  function test_unique_ptr_consumer_roundtrip (line 189) | def test_unique_ptr_consumer_roundtrip(pass_f, rtrn_f, moved_out, moved_...
  function test_py_type_handle_of_atyp (line 207) | def test_py_type_handle_of_atyp():
  function test_function_signatures (line 212) | def test_function_signatures(doc):
  function test_unique_ptr_return_value_policy_automatic_reference (line 231) | def test_unique_ptr_return_value_policy_automatic_reference():
  function test_pass_shared_ptr_ptr (line 235) | def test_pass_shared_ptr_ptr():
  function test_unusual_op_ref (line 245) | def test_unusual_op_ref():

FILE: tests/test_class_sh_disowning.cpp
  type pybind11_tests (line 5) | namespace pybind11_tests {
    type class_sh_disowning (line 6) | namespace class_sh_disowning {
      type Atype (line 9) | struct Atype {
        method Atype (line 11) | explicit Atype(int val_) : val{val_} {}
        method get (line 12) | int get() const { return val * 10 + SerNo; }
      function same_twice (line 15) | int same_twice(std::unique_ptr<Atype<1>> at1a, std::unique_ptr<Atype...
      function mixed (line 19) | int mixed(std::unique_ptr<Atype<1>> at1, std::unique_ptr<Atype<2>> a...
      function overloaded (line 23) | int overloaded(std::unique_ptr<Atype<1>> at1, int i) { return at1->g...
      function overloaded (line 24) | int overloaded(std::unique_ptr<Atype<2>> at2, int i) { return at2->g...
  function TEST_SUBMODULE (line 29) | TEST_SUBMODULE(class_sh_disowning, m) {

FILE: tests/test_class_sh_disowning.py
  function is_disowned (line 8) | def is_disowned(obj):
  function test_same_twice (line 16) | def test_same_twice():
  function test_mixed (line 31) | def test_mixed():
  function test_overloaded (line 66) | def test_overloaded():

FILE: tests/test_class_sh_disowning_mi.cpp
  type pybind11_tests (line 5) | namespace pybind11_tests {
    type class_sh_disowning_mi (line 6) | namespace class_sh_disowning_mi {
      type B (line 9) | struct B {
        method B (line 11) | B() = default;
        method B (line 12) | B(const B &) = default;
      type C0 (line 16) | struct C0 : public virtual B {
      type C1 (line 20) | struct C1 : public virtual B {
      type D (line 24) | struct D : public C0, public C1 {
      function disown_b (line 28) | void disown_b(std::unique_ptr<B>) {}
      type Base1 (line 31) | struct Base1 {
        method Base1 (line 32) | explicit Base1(int i) : i(i) {}
        method foo (line 33) | int foo() const { return i; }
      type Base2 (line 37) | struct Base2 {
        method Base2 (line 38) | explicit Base2(int j) : j(j) {}
        method bar (line 39) | int bar() const { return j; }
      function disown_base1 (line 43) | int disown_base1(std::unique_ptr<Base1> b1) { return b1->i * 2000 + ...
      function disown_base2 (line 44) | int disown_base2(std::unique_ptr<Base2> b2) { return b2->j * 2000 + ...
  function TEST_SUBMODULE (line 49) | TEST_SUBMODULE(class_sh_disowning_mi, m) {

FILE: tests/test_class_sh_disowning_mi.py
  function test_diamond_inheritance (line 9) | def test_diamond_inheritance():
  function is_disowned (line 21) | def is_disowned(callable_method):
  function test_disown_b (line 30) | def test_disown_b():
  function test_disown_c0 (line 38) | def test_disown_c0(var_to_disown):
  function test_disown_c1 (line 48) | def test_disown_c1(var_to_disown):
  function test_disown_d (line 58) | def test_disown_d(var_to_disown):
  class MI1 (line 72) | class MI1(m.Base1, m.Base2):
    method __init__ (line 73) | def __init__(self, i, j):
  class B1 (line 78) | class B1:
    method v (line 79) | def v(self):
  class MI2 (line 83) | class MI2(B1, m.Base1, m.Base2):
    method __init__ (line 84) | def __init__(self, i, j):
  class MI3 (line 90) | class MI3(MI2):
    method __init__ (line 91) | def __init__(self, i, j):
  class MI4 (line 95) | class MI4(MI3, m.Base2):
    method __init__ (line 96) | def __init__(self, i, j):
  class MI5 (line 102) | class MI5(m.Base2, B1, m.Base1):
    method __init__ (line 103) | def __init__(self, i, j):
  class MI6 (line 109) | class MI6(m.Base2, B1):
    method __init__ (line 110) | def __init__(self, i):
  class B2 (line 115) | class B2(B1):
    method v (line 116) | def v(self):
  class B3 (line 120) | class B3:
    method v (line 121) | def v(self):
  class B4 (line 125) | class B4(B3, B2):
    method v (line 126) | def v(self):
  class MI7 (line 130) | class MI7(B4, MI6):
    method __init__ (line 131) | def __init__(self, i):
  class MI8 (line 136) | class MI8(MI6, B3):
    method __init__ (line 137) | def __init__(self, i):
  class MI8b (line 142) | class MI8b(B3, MI6):
    method __init__ (line 143) | def __init__(self, i):
  function test_multiple_inheritance_python (line 149) | def test_multiple_inheritance_python():
  function test_disown_base1_first (line 205) | def test_disown_base1_first(cls, i, j, v):
  function test_disown_base2_first (line 219) | def test_disown_base2_first(cls, i, j, v):
  function test_disown_base2 (line 241) | def test_disown_base2(cls, j, v):

FILE: tests/test_class_sh_factory_constructors.cpp
  type pybind11_tests (line 6) | namespace pybind11_tests {
    type class_sh_factory_constructors (line 7) | namespace class_sh_factory_constructors {
      type atyp (line 10) | struct atyp {  // Short for "any type".
      function get_mtxt (line 15) | std::string get_mtxt(const T &obj) {
      function atyp_valu (line 34) | atyp_valu        rtrn_valu() { atyp_valu obj{"Valu"}; return obj; }
      function atyp_rref (line 35) | atyp_rref&&      rtrn_rref() { static atyp_rref obj; obj.mtxt = "Rre...
      function atyp_cref (line 36) | atyp_cref const& rtrn_cref() { static atyp_cref obj; obj.mtxt = "Cre...
      function atyp_mref (line 37) | atyp_mref&       rtrn_mref() { static atyp_mref obj; obj.mtxt = "Mre...
      function atyp_cptr (line 38) | atyp_cptr const* rtrn_cptr() { return new atyp_cptr{"Cptr"}; }
      function atyp_mptr (line 39) | atyp_mptr*       rtrn_mptr() { return new atyp_mptr{"Mptr"}; }
      function rtrn_shmp (line 41) | std::shared_ptr<atyp_shmp>       rtrn_shmp() { return std::make_shar...
      function rtrn_shcp (line 42) | std::shared_ptr<atyp_shcp const> rtrn_shcp() { return std::shared_pt...
      function rtrn_uqmp (line 44) | std::unique_ptr<atyp_uqmp>       rtrn_uqmp() { return std::unique_pt...
      function rtrn_uqcp (line 45) | std::unique_ptr<atyp_uqcp const> rtrn_uqcp() { return std::unique_pt...
      type sddm (line 47) | struct sddm : std::default_delete<atyp_udmp      > {}
      type sddc (line 48) | struct sddc : std::default_delete<atyp_udcp const> {}
      function rtrn_udmp (line 50) | std::unique_ptr<atyp_udmp,       sddm> rtrn_udmp() { return std::uni...
      function rtrn_udcp (line 51) | std::unique_ptr<atyp_udcp const, sddc> rtrn_udcp() { return std::uni...
      type with_alias (line 57) | struct with_alias {
        method with_alias (line 61) | with_alias() = default;
        method with_alias (line 62) | with_alias(const with_alias &) = default;
        method with_alias (line 63) | with_alias(with_alias &&) = default;
        method with_alias (line 64) | with_alias &operator=(const with_alias &) = default;
        method with_alias (line 65) | with_alias &operator=(with_alias &&) = default;
      type with_alias_alias (line 67) | struct with_alias_alias : with_alias, py::trampoline_self_life_suppo...
      type sddwaa (line 68) | struct sddwaa : std::default_delete<with_alias_alias> {}
  function TEST_SUBMODULE (line 73) | TEST_SUBMODULE(class_sh_factory_constructors, m) {

FILE: tests/test_class_sh_factory_constructors.py
  function test_atyp_factories (line 8) | def test_atyp_factories():
  function test_with_alias_success (line 31) | def test_with_alias_success(init_args, expected):
  function test_with_alias_invalid (line 42) | def test_with_alias_invalid(num_init_args, smart_ptr):

FILE: tests/test_class_sh_inheritance.cpp
  type pybind11_tests (line 5) | namespace pybind11_tests {
    type class_sh_inheritance (line 6) | namespace class_sh_inheritance {
      type base_template (line 9) | struct base_template {
        method base_template (line 10) | base_template() : base_id(Id) {}
        method id (line 12) | virtual int id() const { return base_id; }
        method base_template (line 16) | base_template(const base_template &) = default;
        method base_template (line 17) | base_template(base_template &&) noexcept = default;
        method base_template (line 18) | base_template &operator=(const base_template &) = default;
        method base_template (line 19) | base_template &operator=(base_template &&) noexcept = default;
      type drvd (line 24) | struct drvd : base {
        method id (line 25) | int id() const override { return 2 * base_id; }
      function drvd (line 29) | inline drvd *rtrn_mptr_drvd()         { return new drvd; }
        method id (line 25) | int id() const override { return 2 * base_id; }
      function base (line 30) | inline base *rtrn_mptr_drvd_up_cast() { return new drvd; }
      function pass_cptr_base (line 32) | inline int pass_cptr_base(base const *b) { return b->id() + 11; }
      function pass_cptr_drvd (line 33) | inline int pass_cptr_drvd(drvd const *d) { return d->id() + 12; }
      function rtrn_shmp_drvd (line 35) | inline std::shared_ptr<drvd> rtrn_shmp_drvd()         { return std::...
      function rtrn_shmp_drvd_up_cast (line 36) | inline std::shared_ptr<base> rtrn_shmp_drvd_up_cast() { return std::...
      function pass_shcp_base (line 38) | inline int pass_shcp_base(const std::shared_ptr<base const>& b) { re...
      function pass_shcp_drvd (line 39) | inline int pass_shcp_drvd(const std::shared_ptr<drvd const>& d) { re...
      type drvd2 (line 46) | struct drvd2 : base1, base2 {
        method id (line 47) | int id() const override { return 3 * base1::base_id + 4 * base2::b...
      function drvd2 (line 51) | inline drvd2 *rtrn_mptr_drvd2()          { return new drvd2; }
        method id (line 47) | int id() const override { return 3 * base1::base_id + 4 * base2::b...
      function base1 (line 52) | inline base1 *rtrn_mptr_drvd2_up_cast1() { return new drvd2; }
      function base2 (line 53) | inline base2 *rtrn_mptr_drvd2_up_cast2() { return new drvd2; }
      function pass_cptr_base1 (line 55) | inline int pass_cptr_base1(base1 const *b) { return b->id() + 21; }
      function pass_cptr_base2 (line 56) | inline int pass_cptr_base2(base2 const *b) { return b->id() + 22; }
      function pass_cptr_drvd2 (line 57) | inline int pass_cptr_drvd2(drvd2 const *d) { return d->id() + 23; }
      function TEST_SUBMODULE (line 60) | TEST_SUBMODULE(class_sh_inheritance, m) {

FILE: tests/test_class_sh_inheritance.py
  function test_rtrn_mptr_drvd_pass_cptr_base (line 6) | def test_rtrn_mptr_drvd_pass_cptr_base():
  function test_rtrn_shmp_drvd_pass_shcp_base (line 12) | def test_rtrn_shmp_drvd_pass_shcp_base():
  function test_rtrn_mptr_drvd_up_cast_pass_cptr_drvd (line 18) | def test_rtrn_mptr_drvd_up_cast_pass_cptr_drvd():
  function test_rtrn_shmp_drvd_up_cast_pass_shcp_drvd (line 26) | def test_rtrn_shmp_drvd_up_cast_pass_shcp_drvd():
  function test_rtrn_mptr_drvd2_pass_cptr_bases (line 34) | def test_rtrn_mptr_drvd2_pass_cptr_bases():
  function test_rtrn_mptr_drvd2_up_casts_pass_cptr_drvd2 (line 42) | def test_rtrn_mptr_drvd2_up_casts_pass_cptr_drvd2():
  function test_python_drvd2 (line 53) | def test_python_drvd2():

FILE: tests/test_class_sh_mi_thunks.cpp
  type test_class_sh_mi_thunks (line 7) | namespace test_class_sh_mi_thunks {
    type Base0 (line 15) | struct Base0 {
      method Base0 (line 17) | Base0() = default;
      method Base0 (line 18) | Base0(const Base0 &) = delete;
    type Base1 (line 21) | struct Base1 {
      method Base1 (line 25) | Base1() = default;
      method Base1 (line 26) | Base1(const Base1 &) = delete;
    type Derived (line 29) | struct Derived : Base1, Base0 {
      method Derived (line 31) | Derived() = default;
      method Derived (line 32) | Derived(const Derived &) = delete;
    type VBase (line 37) | struct VBase {
      method VBase (line 38) | VBase() = default;
      method VBase (line 39) | VBase(const VBase &) = default;
      method VBase (line 40) | VBase &operator=(const VBase &) = default;
      method VBase (line 41) | VBase(VBase &&) = default;
      method VBase (line 42) | VBase &operator=(VBase &&) = default;
      method ping (line 44) | virtual int ping() const { return 1; }
    type Left (line 52) | struct Left : virtual VBase {
    type Right (line 56) | struct Right : virtual VBase {
    type Diamond (line 61) | struct Diamond : Left, Right {
      method Diamond (line 62) | Diamond() = default;
      method Diamond (line 63) | Diamond(const Diamond &) = default;
      method ping (line 65) | int ping() const override { return 7; }
    function VBase (line 69) | VBase *make_diamond_as_vbase_raw_ptr() {
      method VBase (line 38) | VBase() = default;
      method VBase (line 39) | VBase(const VBase &) = default;
      method VBase (line 40) | VBase &operator=(const VBase &) = default;
      method VBase (line 41) | VBase(VBase &&) = default;
      method VBase (line 42) | VBase &operator=(VBase &&) = default;
      method ping (line 44) | virtual int ping() const { return 1; }
    function make_diamond_as_vbase_shared_ptr (line 74) | std::shared_ptr<VBase> make_diamond_as_vbase_shared_ptr() {
    function make_diamond_as_vbase_unique_ptr (line 79) | std::unique_ptr<VBase> make_diamond_as_vbase_unique_ptr() {
    type DiamondAddrs (line 85) | struct DiamondAddrs {
    function DiamondAddrs (line 92) | DiamondAddrs diamond_addrs() {
    class Animal (line 103) | class Animal {
      method Animal (line 105) | Animal() = default;
      method Animal (line 106) | Animal(const Animal &) = default;
      method Animal (line 107) | Animal &operator=(const Animal &) = default;
    class Cat (line 114) | class Cat : virtual public Animal {
      method Cat (line 116) | Cat() = default;
      method Cat (line 117) | Cat(const Cat &) = default;
      method Cat (line 118) | Cat &operator=(const Cat &) = default;
    class Tiger (line 122) | class Tiger : virtual public Cat {
      method Tiger (line 124) | Tiger() = default;
      method Tiger (line 125) | Tiger(const Tiger &) = default;
      method Tiger (line 126) | Tiger &operator=(const Tiger &) = default;
      method Animal (line 128) | Animal *clone_raw_ptr() const override {
      method clone_shared_ptr (line 131) | std::shared_ptr<Animal> clone_shared_ptr() const override {
      method clone_unique_ptr (line 134) | std::unique_ptr<Animal> clone_unique_ptr() const override {
  function TEST_SUBMODULE (line 141) | TEST_SUBMODULE(class_sh_mi_thunks, m) {

FILE: tests/test_class_sh_mi_thunks.py
  function test_ptrdiff_drvd_base0 (line 8) | def test_ptrdiff_drvd_base0():
  function test_get_vec_size_raw_shared (line 32) | def test_get_vec_size_raw_shared(get_fn, vec_size_fn):
  function test_get_vec_size_unique (line 40) | def test_get_vec_size_unique(get_fn):
  function test_get_shared_vec_size_unique (line 47) | def test_get_shared_vec_size_unique():
  function test_virtual_base_not_at_offset_0 (line 56) | def test_virtual_base_not_at_offset_0():
  function test_make_diamond_as_vbase (line 86) | def test_make_diamond_as_vbase(make_fn):
  function test_animal_cat_tiger (line 100) | def test_animal_cat_tiger(clone_fn):

FILE: tests/test_class_sh_property.cpp
  type test_class_sh_property (line 10) | namespace test_class_sh_property {
    type ClassicField (line 12) | struct ClassicField {
    type ClassicOuter (line 16) | struct ClassicOuter {
    type Field (line 21) | struct Field {
    type Outer (line 25) | struct Outer {
    function DisownOuter (line 35) | inline void DisownOuter(std::unique_ptr<Outer>) {}
    type WithCharArrayMember (line 37) | struct WithCharArrayMember {
      method WithCharArrayMember (line 38) | WithCharArrayMember() { std::memcpy(char6_member, "Char6", 6); }
    type WithConstCharPtrMember (line 42) | struct WithConstCharPtrMember {
  function TEST_SUBMODULE (line 48) | TEST_SUBMODULE(class_sh_property, m) {

FILE: tests/test_class_sh_property.py
  function test_valu_getter (line 15) | def test_valu_getter(m_attr):
  function test_valu_setter (line 30) | def test_valu_setter():
  function test_shp (line 42) | def test_shp(m_attr):
  function test_ptr (line 70) | def test_ptr(field_type, num_default, outer_type, m_attr, r_kind):
  function test_uqp (line 87) | def test_uqp(m_attr_readwrite):
  class unique_ptr_field_proxy_poc (line 111) | class unique_ptr_field_proxy_poc:
    method __init__ (line 112) | def __init__(self, obj, field_name):
    method __getattr__ (line 116) | def __getattr__(self, *args, **kwargs):
    method __setattr__ (line 119) | def __setattr__(self, *args, **kwargs):
    method __delattr__ (line 122) | def __delattr__(self, *args, **kwargs):
  function _proxy_dereference (line 126) | def _proxy_dereference(proxy, xxxattr, *args, **kwargs):
  function test_unique_ptr_field_proxy_poc (line 138) | def test_unique_ptr_field_proxy_poc(m_attr):
  function test_readonly_char6_member (line 159) | def test_readonly_char6_member():
  function test_readonly_const_char_ptr_member (line 164) | def test_readonly_const_char_ptr_member():

FILE: tests/test_class_sh_property_non_owning.cpp
  type test_class_sh_property_non_owning (line 6) | namespace test_class_sh_property_non_owning {
    type CoreField (line 8) | struct CoreField {
      method CoreField (line 9) | explicit CoreField(int int_value = -99) : int_value{int_value} {}
    type DataField (line 13) | struct DataField {
      method DataField (line 14) | DataField(int i_value, int i_shared, int i_unique)
    type DataFieldsHolder (line 24) | struct DataFieldsHolder {
      method DataFieldsHolder (line 29) | explicit DataFieldsHolder(std::size_t vec_size) {
      method DataFieldsHolder (line 36) | DataFieldsHolder(DataFieldsHolder &&) noexcept = default;
      method DataField (line 38) | DataField *vec_at(std::size_t index) {
  function TEST_SUBMODULE (line 50) | TEST_SUBMODULE(class_sh_property_non_owning, m) {

FILE: tests/test_class_sh_property_non_owning.py
  function test_core_fld_common (line 21) | def test_core_fld_common(core_fld, expected, persistent_holder):

FILE: tests/test_class_sh_shared_ptr_copy_move.cpp
  type pybind11_tests (line 7) | namespace pybind11_tests {
    type Foo (line 13) | struct Foo {
      method Foo (line 15) | explicit Foo(const std::string &history_) : history(history_) {}
      method Foo (line 16) | Foo(const Foo &other) : history(other.history + "_CpCtor") {}
      method Foo (line 17) | Foo(Foo &&other) noexcept : history(other.history + "_MvCtor") {}
      method Foo (line 18) | Foo &operator=(const Foo &other) {
      method Foo (line 22) | Foo &operator=(Foo &&other) noexcept {
      method get_history (line 26) | std::string get_history() const { return "Foo" + fooNames[SerNo] + h...
    type Outer (line 32) | struct Outer {
      method Outer (line 35) | Outer()
      method getShPtr (line 37) | std::shared_ptr<FooShPtr> getShPtr() const { return ShPtr; }
      method getSmHld (line 38) | std::shared_ptr<FooSmHld> getSmHld() const { return SmHld; }
    function TEST_SUBMODULE (line 43) | TEST_SUBMODULE(class_sh_shared_ptr_copy_move, m) {

FILE: tests/test_class_sh_shared_ptr_copy_move.py
  function test_shptr_copy (line 6) | def test_shptr_copy():
  function test_smhld_copy (line 11) | def test_smhld_copy():
  function test_shptr_move (line 16) | def test_shptr_move():
  function test_smhld_move (line 21) | def test_smhld_move():
  function _check_property (line 26) | def _check_property(foo_typ, prop_typ, policy):
  function test_properties (line 37) | def test_properties():

FILE: tests/test_class_sh_trampoline_basic.cpp
  type pybind11_tests (line 5) | namespace pybind11_tests {
    type class_sh_trampoline_basic (line 6) | namespace class_sh_trampoline_basic {
      type Abase (line 8) | struct Abase {
        method Abase (line 11) | explicit Abase(int val_) : val{val_} {}
        method Get (line 12) | int Get() const { return val * 10 + 3; }
        method Abase (line 16) | Abase(const Abase &) = default;
        method Abase (line 17) | Abase(Abase &&) noexcept = default;
        method Abase (line 18) | Abase &operator=(const Abase &) = default;
        method Abase (line 19) | Abase &operator=(Abase &&) noexcept = default;
      type AbaseAlias (line 22) | struct AbaseAlias : Abase, py::trampoline_self_life_support {
        method Add (line 25) | int Add(int other_val) const override {
      function AddInCppRawPtr (line 33) | int AddInCppRawPtr(const Abase *obj, int other_val) { return obj->Ad...
      function AddInCppSharedPtr (line 35) | int AddInCppSharedPtr(const std::shared_ptr<Abase> &obj, int other_v...
      function AddInCppUniquePtr (line 39) | int AddInCppUniquePtr(std::unique_ptr<Abase> obj, int other_val) {
  function TEST_SUBMODULE (line 48) | TEST_SUBMODULE(class_sh_trampoline_basic, m) {

FILE: tests/test_class_sh_trampoline_basic.py
  class PyDrvd (line 6) | class PyDrvd(m.Abase):
    method __init__ (line 7) | def __init__(self, val):
    method Add (line 10) | def Add(self, other_val):
  function test_drvd_add (line 14) | def test_drvd_add():
  function test_drvd_add_in_cpp_raw_ptr (line 19) | def test_drvd_add_in_cpp_raw_ptr():
  function test_drvd_add_in_cpp_shared_ptr (line 24) | def test_drvd_add_in_cpp_shared_ptr():
  function test_drvd_add_in_cpp_unique_ptr (line 31) | def test_drvd_add_in_cpp_unique_ptr():

FILE: tests/test_class_sh_trampoline_self_life_support.cpp
  type pybind11_tests (line 12) | namespace pybind11_tests {
    type class_sh_trampoline_self_life_support (line 13) | namespace class_sh_trampoline_self_life_support {
      type Big5 (line 15) | struct Big5 { // Also known as "rule of five".
        method Big5 (line 18) | explicit Big5(std::string history_start) : history{std::move(histo...
        method Big5 (line 20) | Big5(const Big5 &other) { history = other.history + "_CpCtor"; }
        method Big5 (line 22) | Big5(Big5 &&other) noexcept { history = other.history + "_MvCtor"; }
        method Big5 (line 24) | Big5 &operator=(const Big5 &other) {
        method Big5 (line 29) | Big5 &operator=(Big5 &&other) noexcept {
        method Big5 (line 37) | Big5() : history{"DefaultConstructor"} {}
      type Big5Trampoline (line 40) | struct Big5Trampoline : Big5, py::trampoline_self_life_support {
  function TEST_SUBMODULE (line 49) | TEST_SUBMODULE(class_sh_trampoline_self_life_support, m) {

FILE: tests/test_class_sh_trampoline_self_life_support.py
  class PyBig5 (line 8) | class PyBig5(m.Big5):
  function test_m_big5 (line 12) | def test_m_big5():
  function test_py_big5 (line 33) | def test_py_big5(action_id, expected_history):

FILE: tests/test_class_sh_trampoline_shared_from_this.cpp
  type pybind11_tests (line 10) | namespace pybind11_tests {
    type class_sh_trampoline_shared_from_this (line 11) | namespace class_sh_trampoline_shared_from_this {
      type Sft (line 13) | struct Sft : std::enable_shared_from_this<Sft> {
        method Sft (line 15) | explicit Sft(const std::string &history_seed) : history{history_se...
        method Sft (line 24) | Sft(const Sft &other) : enable_shared_from_this(other) { history =...
        method Sft (line 26) | Sft(Sft &&other) noexcept { history = other.history + "_MvCtor"; }
        method Sft (line 28) | Sft &operator=(const Sft &other) {
        method Sft (line 33) | Sft &operator=(Sft &&other) noexcept {
      type SftSharedPtrStash (line 41) | struct SftSharedPtrStash {
        method SftSharedPtrStash (line 44) | explicit SftSharedPtrStash(int ser_no) : ser_no{ser_no} {}
        method Clear (line 45) | void Clear() { stash.clear(); }
        method Add (line 46) | void Add(const std::shared_ptr<Sft> &obj) {
        method AddSharedFromThis (line 52) | void AddSharedFromThis(Sft *obj) {
        method history (line 59) | std::string history(unsigned i) {
        method use_count (line 65) | long use_count(unsigned i) {
      type SftTrampoline (line 73) | struct SftTrampoline : Sft, py::trampoline_self_life_support {
      function use_count (line 77) | long use_count(const std::shared_ptr<Sft> &obj) { return obj.use_cou...
      function pass_shared_ptr (line 79) | long pass_shared_ptr(const std::shared_ptr<Sft> &obj) {
      function pass_unique_ptr_cref (line 87) | std::string pass_unique_ptr_cref(const std::unique_ptr<Sft> &obj) {
      function pass_unique_ptr_rref (line 90) | void pass_unique_ptr_rref(std::unique_ptr<Sft> &&) {
      function Sft (line 94) | Sft *make_pure_cpp_sft_raw_ptr(const std::string &history_seed) { re...
        method Sft (line 15) | explicit Sft(const std::string &history_seed) : history{history_se...
        method Sft (line 24) | Sft(const Sft &other) : enable_shared_from_this(other) { history =...
        method Sft (line 26) | Sft(Sft &&other) noexcept { history = other.history + "_MvCtor"; }
        method Sft (line 28) | Sft &operator=(const Sft &other) {
        method Sft (line 33) | Sft &operator=(Sft &&other) noexcept {
      function make_pure_cpp_sft_unq_ptr (line 96) | std::unique_ptr<Sft> make_pure_cpp_sft_unq_ptr(const std::string &hi...
      function make_pure_cpp_sft_shd_ptr (line 100) | std::shared_ptr<Sft> make_pure_cpp_sft_shd_ptr(const std::string &hi...
      function pass_through_shd_ptr (line 104) | std::shared_ptr<Sft> pass_through_shd_ptr(const std::shared_ptr<Sft>...
  function TEST_SUBMODULE (line 111) | TEST_SUBMODULE(class_sh_trampoline_shared_from_this, m) {

FILE: tests/test_class_sh_trampoline_shared_from_this.py
  class PySft (line 12) | class PySft(m.Sft):
  function test_release_and_shared_from_this (line 16) | def test_release_and_shared_from_this():
  function test_release_and_shared_from_this_leak (line 30) | def test_release_and_shared_from_this_leak():
  function test_release_and_stash (line 39) | def test_release_and_stash():
  function test_release_and_stash_leak (line 82) | def test_release_and_stash_leak():
  function test_release_and_stash_via_shared_from_this (line 98) | def test_release_and_stash_via_shared_from_this():
  function test_release_and_stash_via_shared_from_this_leak (line 114) | def test_release_and_stash_via_shared_from_this_leak():
  function test_pass_released_shared_ptr_as_unique_ptr (line 131) | def test_pass_released_shared_ptr_as_unique_ptr():
  function test_pure_cpp_sft_raw_ptr (line 155) | def test_pure_cpp_sft_raw_ptr(make_f):
  function test_multiple_registered_instances_for_same_pointee (line 166) | def test_multiple_registered_instances_for_same_pointee():
  function test_multiple_registered_instances_for_same_pointee_leak (line 185) | def test_multiple_registered_instances_for_same_pointee_leak():
  function test_multiple_registered_instances_for_same_pointee_recursive (line 198) | def test_multiple_registered_instances_for_same_pointee_recursive():
  function test_std_make_shared_factory (line 224) | def test_std_make_shared_factory():

FILE: tests/test_class_sh_trampoline_shared_ptr_cpp_arg.cpp
  type pybind11_tests (line 9) | namespace pybind11_tests {
    type class_sh_trampoline_shared_ptr_cpp_arg (line 10) | namespace class_sh_trampoline_shared_ptr_cpp_arg {
      type SpBase (line 14) | struct SpBase {
        method is_base_used (line 16) | virtual bool is_base_used() { return true; }
        method has_python_instance (line 19) | bool has_python_instance() {
        method SpBase (line 24) | SpBase() = default;
        method SpBase (line 25) | SpBase(const SpBase &) = delete;
      function pass_through_shd_ptr (line 29) | std::shared_ptr<SpBase> pass_through_shd_ptr(const std::shared_ptr<S...
      type PySpBase (line 31) | struct PySpBase : SpBase, py::trampoline_self_life_support {
        method is_base_used (line 33) | bool is_base_used() override { PYBIND11_OVERRIDE(bool, SpBase, is_...
      type SpBaseTester (line 36) | struct SpBaseTester {
        method get_object (line 37) | std::shared_ptr<SpBase> get_object() const { return m_obj; }
        method set_object (line 38) | void set_object(std::shared_ptr<SpBase> obj) { m_obj = std::move(o...
        method is_base_used (line 39) | bool is_base_used() const { return m_obj->is_base_used(); }
        method has_instance (line 40) | bool has_instance() const { return (bool) m_obj; }
        method has_python_instance (line 41) | bool has_python_instance() const { return m_obj && m_obj->has_pyth...
        method set_nonpython_instance (line 42) | void set_nonpython_instance() { m_obj = std::make_shared<SpBase>(); }
      type SpGoAway (line 48) | struct SpGoAway {}
      type SpGoAwayTester (line 50) | struct SpGoAwayTester {
  function TEST_SUBMODULE (line 59) | TEST_SUBMODULE(class_sh_trampoline_shared_ptr_cpp_arg, m) {

FILE: tests/test_class_sh_trampoline_shared_ptr_cpp_arg.py
  function test_shared_ptr_cpp_arg (line 10) | def test_shared_ptr_cpp_arg():
  function test_shared_ptr_cpp_prop (line 35) | def test_shared_ptr_cpp_prop():
  function test_shared_ptr_arg_identity (line 54) | def test_shared_ptr_arg_identity():
  function test_shared_ptr_alias_nonpython (line 73) | def test_shared_ptr_alias_nonpython():
  function test_shared_ptr_goaway (line 116) | def test_shared_ptr_goaway():
  function test_infinite (line 136) | def test_infinite():
  function test_std_make_shared_factory (line 146) | def test_std_make_shared_factory(pass_through_func):

FILE: tests/test_class_sh_trampoline_unique_ptr.cpp
  type pybind11_tests (line 10) | namespace pybind11_tests {
    type class_sh_trampoline_unique_ptr (line 11) | namespace class_sh_trampoline_unique_ptr {
      class Class (line 13) | class Class {
        method setVal (line 17) | void setVal(std::uint64_t val) { val_ = val; }
        method getVal (line 18) | std::uint64_t getVal() const { return val_; }
        method Class (line 24) | Class() = default;
        method Class (line 27) | Class(const Class &) = default;
      class PyClass (line 39) | class PyClass : public Class, public py::trampoline_self_life_support {
        method clone (line 41) | std::unique_ptr<Class> clone() const override {
        method foo (line 45) | int foo() const override { PYBIND11_OVERRIDE_PURE(int, Class, foo); }
    type class_sh_trampoline_unique_ptr (line 37) | namespace class_sh_trampoline_unique_ptr {
      class Class (line 13) | class Class {
        method setVal (line 17) | void setVal(std::uint64_t val) { val_ = val; }
        method getVal (line 18) | std::uint64_t getVal() const { return val_; }
        method Class (line 24) | Class() = default;
        method Class (line 27) | Class(const Class &) = default;
      class PyClass (line 39) | class PyClass : public Class, public py::trampoline_self_life_support {
        method clone (line 41) | std::unique_ptr<Class> clone() const override {
        method foo (line 45) | int foo() const override { PYBIND11_OVERRIDE_PURE(int, Class, foo); }
  type pybind11_tests (line 36) | namespace pybind11_tests {
    type class_sh_trampoline_unique_ptr (line 11) | namespace class_sh_trampoline_unique_ptr {
      class Class (line 13) | class Class {
        method setVal (line 17) | void setVal(std::uint64_t val) { val_ = val; }
        method getVal (line 18) | std::uint64_t getVal() const { return val_; }
        method Class (line 24) | Class() = default;
        method Class (line 27) | Class(const Class &) = default;
      class PyClass (line 39) | class PyClass : public Class, public py::trampoline_self_life_support {
        method clone (line 41) | std::unique_ptr<Class> clone() const override {
        method foo (line 45) | int foo() const override { PYBIND11_OVERRIDE_PURE(int, Class, foo); }
    type class_sh_trampoline_unique_ptr (line 37) | namespace class_sh_trampoline_unique_ptr {
      class Class (line 13) | class Class {
        method setVal (line 17) | void setVal(std::uint64_t val) { val_ = val; }
        method getVal (line 18) | std::uint64_t getVal() const { return val_; }
        method Class (line 24) | Class() = default;
        method Class (line 27) | Class(const Class &) = default;
      class PyClass (line 39) | class PyClass : public Class, public py::trampoline_self_life_support {
        method clone (line 41) | std::unique_ptr<Class> clone() const override {
        method foo (line 45) | int foo() const override { PYBIND11_OVERRIDE_PURE(int, Class, foo); }
  function TEST_SUBMODULE (line 51) | TEST_SUBMODULE(class_sh_trampoline_unique_ptr, m) {

FILE: tests/test_class_sh_trampoline_unique_ptr.py
  class MyClass (line 6) | class MyClass(m.Class):
    method foo (line 7) | def foo(self):
    method clone (line 10) | def clone(self):
  function test_m_clone (line 16) | def test_m_clone():
  function test_m_clone_and_foo (line 26) | def test_m_clone_and_foo():

FILE: tests/test_class_sh_unique_ptr_custom_deleter.cpp
  type pybind11_tests (line 5) | namespace pybind11_tests {
    type class_sh_unique_ptr_custom_deleter (line 6) | namespace class_sh_unique_ptr_custom_deleter {
      class Pet (line 9) | class Pet {
        method Ptr (line 15) | static Ptr New(const std::string &name) {
        method Pet (line 20) | explicit Pet(const std::string &name) : name(name) {}
      function TEST_SUBMODULE (line 23) | TEST_SUBMODULE(class_sh_unique_ptr_custom_deleter, m) {

FILE: tests/test_class_sh_unique_ptr_custom_deleter.py
  function test_create (line 6) | def test_create():

FILE: tests/test_class_sh_unique_ptr_member.cpp
  type pybind11_tests (line 5) | namespace pybind11_tests {
    type class_sh_unique_ptr_member (line 6) | namespace class_sh_unique_ptr_member {
      class pointee (line 8) | class pointee { // NOT copyable.
        method pointee (line 10) | pointee() = default;
        method get_int (line 12) | int get_int() const { return 213; }
        method pointee (line 14) | pointee(const pointee &) = delete;
        method pointee (line 15) | pointee(pointee &&) = delete;
        method pointee (line 16) | pointee &operator=(const pointee &) = delete;
        method pointee (line 17) | pointee &operator=(pointee &&) = delete;
      function make_unique_pointee (line 20) | inline std::unique_ptr<pointee> make_unique_pointee() {
      class ptr_owner (line 24) | class ptr_owner {
        method ptr_owner (line 26) | explicit ptr_owner(std::unique_ptr<pointee> ptr) : ptr_(std::move(...
        method is_owner (line 28) | bool is_owner() const { return bool(ptr_); }
        method give_up_ownership_via_unique_ptr (line 30) | std::unique_ptr<pointee> give_up_ownership_via_unique_ptr() { retu...
        method give_up_ownership_via_shared_ptr (line 31) | std::shared_ptr<pointee> give_up_ownership_via_shared_ptr() { retu...
      function TEST_SUBMODULE (line 37) | TEST_SUBMODULE(class_sh_unique_ptr_member, m) {

FILE: tests/test_class_sh_unique_ptr_member.py
  function test_make_unique_pointee (line 8) | def test_make_unique_pointee():
  function test_pointee_and_ptr_owner (line 17) | def test_pointee_and_ptr_owner(give_up_ownership_via):

FILE: tests/test_class_sh_virtual_py_cpp_mix.cpp
  type pybind11_tests (line 5) | namespace pybind11_tests {
    type class_sh_virtual_py_cpp_mix (line 6) | namespace class_sh_virtual_py_cpp_mix {
      class Base (line 8) | class Base {
        method get (line 11) | virtual int get() const { return 101; }
        method Base (line 14) | Base() = default;
        method Base (line 15) | Base(const Base &) = default;
      class CppDerivedPlain (line 18) | class CppDerivedPlain : public Base {
        method get (line 20) | int get() const override { return 202; }
      class CppDerived (line 23) | class CppDerived : public Base {
        method get (line 25) | int get() const override { return 212; }
      function get_from_cpp_plainc_ptr (line 28) | int get_from_cpp_plainc_ptr(const Base *b) { return b->get() + 4000; }
      function get_from_cpp_unique_ptr (line 30) | int get_from_cpp_unique_ptr(std::unique_ptr<Base> b) { return b->get...
      type BaseVirtualOverrider (line 32) | struct BaseVirtualOverrider : Base, py::trampoline_self_life_support {
        method get (line 35) | int get() const override { PYBIND11_OVERRIDE(int, Base, get); }
      type CppDerivedVirtualOverrider (line 38) | struct CppDerivedVirtualOverrider : CppDerived, py::trampoline_self_...
        method get (line 41) | int get() const override { PYBIND11_OVERRIDE(int, CppDerived, get); }
  function TEST_SUBMODULE (line 49) | TEST_SUBMODULE(class_sh_virtual_py_cpp_mix, m) {

FILE: tests/test_class_sh_virtual_py_cpp_mix.py
  class PyBase (line 8) | class PyBase(m.Base):  # Avoiding name PyDerived, for more systematic na...
    method __init__ (line 9) | def __init__(self):
    method get (line 12) | def get(self):
  class PyCppDerived (line 16) | class PyCppDerived(m.CppDerived):
    method __init__ (line 17) | def __init__(self):
    method get (line 20) | def get(self):
  function test_base_get (line 34) | def test_base_get(ctor, expected):
  function test_get_from_cpp_plainc_ptr (line 49) | def test_get_from_cpp_plainc_ptr(ctor, expected):
  function test_get_from_cpp_unique_ptr (line 64) | def test_get_from_cpp_unique_ptr(ctor, expected):

FILE: tests/test_cmake_build/embed.cpp
  function PYBIND11_EMBEDDED_MODULE (line 4) | PYBIND11_EMBEDDED_MODULE(test_cmake_build, m) {
  function main (line 8) | int main(int argc, char *argv[]) {

FILE: tests/test_cmake_build/main.cpp
  function PYBIND11_MODULE (line 4) | PYBIND11_MODULE(test_cmake_build, m, py::mod_gil_not_used()) {

FILE: tests/test_const_name.cpp
  function TEST_SUBMODULE (line 47) | TEST_SUBMODULE(const_name, m) {

FILE: tests/test_const_name.py
  function test_const_name (line 27) | def test_const_name(func, selector, expected):

FILE: tests/test_constants_and_functions.cpp
  type MyEnum (line 13) | enum MyEnum { EFirstEntry = 1, ESecondEntry }
  function test_function1 (line 15) | std::string test_function1() { return "test_function()"; }
  function test_function2 (line 17) | std::string test_function2(MyEnum k) { return "test_function(enum=" + st...
  function test_function3 (line 19) | std::string test_function3(int i) { return "test_function(" + std::to_st...
  function test_function4 (line 21) | py::str test_function4() { return "test_function()"; }
  function test_function4 (line 22) | py::str test_function4(char *) { return "test_function(char *)"; }
  function test_function4 (line 23) | py::str test_function4(int, float) { return "test_function(int, float)"; }
  function test_function4 (line 24) | py::str test_function4(float, int) { return "test_function(float, int)"; }
  function return_bytes (line 26) | py::bytes return_bytes() {
  function print_bytes (line 31) | std::string print_bytes(const py::bytes &bytes) {
  type test_exc_sp (line 44) | namespace test_exc_sp {
    function f1 (line 49) | int f1(int x) noexcept(true) { return x + 1; }
    function f1 (line 51) | int f1(int x) noexcept { return x + 1; }
    function f2 (line 53) | int f2(int x) noexcept(true) { return x + 2; }
    function f3 (line 54) | int f3(int x) noexcept(false) { return x + 3; }
    function f4 (line 63) | int f4(int x) throw() { return x + 4; }
    function PYBIND11_WARNING_POP (line 64) | PYBIND11_WARNING_POP
    function TEST_SUBMODULE (line 83) | TEST_SUBMODULE(constants_and_functions, m) {

FILE: tests/test_constants_and_functions.py
  function test_constants (line 8) | def test_constants():
  function test_function_overloading (line 12) | def test_function_overloading():
  function test_bytes (line 25) | def test_bytes():
  function test_exception_specifiers (line 29) | def test_exception_specifiers():
  function test_function_record_leaks (line 46) | def test_function_record_leaks():
  function test_noexcept_lambda (line 57) | def test_noexcept_lambda():

FILE: tests/test_copy_move.cpp
  type empty (line 19) | struct empty {
    method derived (line 20) | static const derived &get_one() { return instance_; }
    method empty (line 24) | empty() = default;
  type lacking_copy_ctor (line 28) | struct lacking_copy_ctor : public empty<lacking_copy_ctor> {
    method lacking_copy_ctor (line 29) | lacking_copy_ctor() = default;
    method lacking_copy_ctor (line 30) | lacking_copy_ctor(const lacking_copy_ctor &other) = delete;
  type lacking_move_ctor (line 36) | struct lacking_move_ctor : public empty<lacking_move_ctor> {
    method lacking_move_ctor (line 37) | lacking_move_ctor() = default;
    method lacking_move_ctor (line 38) | lacking_move_ctor(const lacking_move_ctor &other) = delete;
    method lacking_move_ctor (line 39) | lacking_move_ctor(lacking_move_ctor &&other) = delete;
  class MoveOnlyInt (line 46) | class MoveOnlyInt {
    method MoveOnlyInt (line 48) | MoveOnlyInt() { print_default_created(this); }
    method MoveOnlyInt (line 49) | explicit MoveOnlyInt(int v) : value{v} { print_created(this, value); }
    method MoveOnlyInt (line 50) | MoveOnlyInt(MoveOnlyInt &&m) noexcept {
    method MoveOnlyInt (line 54) | MoveOnlyInt &operator=(MoveOnlyInt &&m) noexcept {
    method MoveOnlyInt (line 59) | MoveOnlyInt(const MoveOnlyInt &) = delete;
    method MoveOnlyInt (line 60) | MoveOnlyInt &operator=(const MoveOnlyInt &) = delete;
  class MoveOrCopyInt (line 65) | class MoveOrCopyInt {
    method MoveOrCopyInt (line 67) | MoveOrCopyInt() { print_default_created(this); }
    method MoveOrCopyInt (line 68) | explicit MoveOrCopyInt(int v) : value{v} { print_created(this, value); }
    method MoveOrCopyInt (line 69) | MoveOrCopyInt(MoveOrCopyInt &&m) noexcept {
    method MoveOrCopyInt (line 73) | MoveOrCopyInt &operator=(MoveOrCopyInt &&m) noexcept {
    method MoveOrCopyInt (line 78) | MoveOrCopyInt(const MoveOrCopyInt &c) {
    method MoveOrCopyInt (line 83) | MoveOrCopyInt &operator=(const MoveOrCopyInt &c) {
  class CopyOnlyInt (line 92) | class CopyOnlyInt {
    method CopyOnlyInt (line 94) | CopyOnlyInt() { print_default_created(this); }
    method CopyOnlyInt (line 95) | explicit CopyOnlyInt(int v) : value{v} { print_created(this, value); }
    method CopyOnlyInt (line 96) | CopyOnlyInt(const CopyOnlyInt &c) {
    method CopyOnlyInt (line 101) | CopyOnlyInt &operator=(const CopyOnlyInt &c) {
  type type_caster<MoveOnlyInt> (line 113) | struct type_caster<MoveOnlyInt> {
    method load (line 115) | bool load(handle src, bool) {
    method handle (line 119) | static handle cast(const MoveOnlyInt &m, return_value_policy r, handle...
  type type_caster<MoveOrCopyInt> (line 125) | struct type_caster<MoveOrCopyInt> {
    method load (line 127) | bool load(handle src, bool) {
    method handle (line 131) | static handle cast(const MoveOrCopyInt &m, return_value_policy r, hand...
  type type_caster<CopyOnlyInt> (line 137) | struct type_caster<CopyOnlyInt> {
    method load (line 143) | bool load(handle src, bool) {
    method handle (line 147) | static handle cast(const CopyOnlyInt &m, return_value_policy r, handle...
    method handle (line 150) | static handle cast(const CopyOnlyInt *src, return_value_policy policy,...
  function CastUnusualOpRefConstRef (line 166) | py::object CastUnusualOpRefConstRef(const UnusualOpRef &cref) { return p...
  function CastUnusualOpRefMovable (line 167) | py::object CastUnusualOpRefMovable(UnusualOpRef &&mvbl) { return py::cas...
  function TEST_SUBMODULE (line 171) | TEST_SUBMODULE(copy_move_policies, m) {
  type NotMovable (line 321) | struct NotMovable {
    method NotMovable (line 322) | NotMovable() = default;
    method NotMovable (line 323) | NotMovable(NotMovable const &) = default;
    method NotMovable (line 324) | NotMovable(NotMovable &&) = delete;
    method NotMovable (line 325) | NotMovable &operator=(NotMovable const &) = default;
    method NotMovable (line 326) | NotMovable &operator=(NotMovable &&) = delete;
  type NotCopyable (line 346) | struct NotCopyable {
    method NotCopyable (line 347) | NotCopyable() = default;
    method NotCopyable (line 348) | NotCopyable(NotCopyable const &) = delete;
    method NotCopyable (line 349) | NotCopyable(NotCopyable &&) = default;
    method NotCopyable (line 350) | NotCopyable &operator=(NotCopyable const &) = delete;
    method NotCopyable (line 351) | NotCopyable &operator=(NotCopyable &&) = default;
  type NotCopyableNotMovable (line 371) | struct NotCopyableNotMovable {
    method NotCopyableNotMovable (line 372) | NotCopyableNotMovable() = default;
    method NotCopyableNotMovable (line 373) | NotCopyableNotMovable(NotCopyableNotMovable const &) = delete;
    method NotCopyableNotMovable (line 374) | NotCopyableNotMovable(NotCopyableNotMovable &&) = delete;
    method NotCopyableNotMovable (line 375) | NotCopyableNotMovable &operator=(NotCopyableNotMovable const &) = delete;
    method NotCopyableNotMovable (line 376) | NotCopyableNotMovable &operator=(NotCopyableNotMovable &&) = delete;
  type NotMovableVector (line 396) | struct NotMovableVector : std::vector<NotMovable> {}
  type NotCopyableVector (line 415) | struct NotCopyableVector : std::vector<NotCopyable> {}
  type NotCopyableNotMovableVector (line 434) | struct NotCopyableNotMovableVector : std::vector<NotCopyableNotMovable> {}
  type NotMovableMap (line 453) | struct NotMovableMap : std::map<int, NotMovable> {}
  type NotCopyableMap (line 472) | struct NotCopyableMap : std::map<int, NotCopyable> {}
  type NotCopyableNotMovableMap (line 491) | struct NotCopyableNotMovableMap : std::map<int, NotCopyableNotMovable> {}
  type RecursiveVector (line 510) | struct RecursiveVector : std::vector<RecursiveVector> {}
  type RecursiveMap (line 529) | struct RecursiveMap : std::map<int, RecursiveMap> {}

FILE: tests/test_copy_move.py
  function test_lacking_copy_ctor (line 9) | def test_lacking_copy_ctor():
  function test_lacking_move_ctor (line 15) | def test_lacking_move_ctor():
  function test_move_and_copy_casts (line 22) | def test_move_and_copy_casts():
  function test_move_and_copy_loads (line 50) | def test_move_and_copy_loads():
  function test_move_and_copy_load_optional (line 84) | def test_move_and_copy_load_optional():
  function test_private_op_new (line 115) | def test_private_op_new():
  function test_move_fallback (line 125) | def test_move_fallback():
  function test_pytype_rvalue_cast (line 134) | def test_pytype_rvalue_cast():
  function test_unusual_op_ref (line 141) | def test_unusual_op_ref():

FILE: tests/test_cpp_conduit.cpp
  type pybind11_tests (line 8) | namespace pybind11_tests {
    type test_cpp_conduit (line 9) | namespace test_cpp_conduit {
      function TEST_SUBMODULE (line 11) | TEST_SUBMODULE(cpp_conduit, m) {

FILE: tests/test_cpp_conduit.py
  function import_warns_freethreaded (line 14) | def import_warns_freethreaded(name):
  function test_traveler_getattr_actually_exists (line 31) | def test_traveler_getattr_actually_exists():
  function test_premium_traveler_getattr_actually_exists (line 36) | def test_premium_traveler_getattr_actually_exists():
  function test_call_cpp_conduit_success (line 41) | def test_call_cpp_conduit_success():
  function test_call_cpp_conduit_platform_abi_id_mismatch (line 54) | def test_call_cpp_conduit_platform_abi_id_mismatch():
  function test_call_cpp_conduit_cpp_type_info_capsule_mismatch (line 64) | def test_call_cpp_conduit_cpp_type_info_capsule_mismatch():
  function test_call_cpp_conduit_pointer_kind_invalid (line 74) | def test_call_cpp_conduit_pointer_kind_invalid():
  function test_home_only_basic (line 86) | def test_home_only_basic():
  function test_home_only_premium (line 92) | def test_home_only_premium():
  function test_exo_only_basic (line 99) | def test_exo_only_basic():
  function test_exo_only_premium (line 105) | def test_exo_only_premium():
  function test_home_passed_to_exo_basic (line 112) | def test_home_passed_to_exo_basic():
  function test_exo_passed_to_home_basic (line 117) | def test_exo_passed_to_home_basic():
  function test_home_passed_to_exo_premium (line 122) | def test_home_passed_to_exo_premium():
  function test_exo_passed_to_home_premium (line 128) | def test_exo_passed_to_home_premium():
  function test_exo_planet_c_api_traveler (line 137) | def test_exo_planet_c_api_traveler(traveler_type):
  function test_exo_planet_c_api_premium_traveler (line 146) | def test_exo_planet_c_api_premium_traveler(premium_traveler_type):
  function test_home_planet_wrap_very_lonely_traveler (line 152) | def test_home_planet_wrap_very_lonely_traveler():
  function test_exo_planet_pybind11_wrap_very_lonely_traveler (line 170) | def test_exo_planet_pybind11_wrap_very_lonely_traveler():

FILE: tests/test_cpp_conduit_traveler_bindings.h
  function namespace (line 11) | namespace pybind11_tests {
  function wrap_lonely_traveler (line 38) | inline void wrap_lonely_traveler(py::module_ m) {
  function wrap_very_lonely_traveler (line 42) | inline void wrap_very_lonely_traveler(py::module_ m) {

FILE: tests/test_cpp_conduit_traveler_types.h
  function namespace (line 7) | namespace pybind11_tests {

FILE: tests/test_cross_module_rtti/bindings.cpp
  class BaseTrampoline (line 5) | class BaseTrampoline : public lib::Base, public pybind11::trampoline_sel...
    method get (line 8) | int get() const override { PYBIND11_OVERLOAD(int, lib::Base, get); }
  function PYBIND11_MODULE (line 11) | PYBIND11_MODULE(test_cross_module_rtti_bindings, m) {

FILE: tests/test_cross_module_rtti/catch.cpp
  function main (line 18) | int main(int argc, char *argv[]) {

FILE: tests/test_cross_module_rtti/lib.cpp
  type lib (line 3) | namespace lib {

FILE: tests/test_cross_module_rtti/lib.h
  function namespace (line 10) | namespace lib {

FILE: tests/test_custom_type_casters.cpp
  class ArgInspector1 (line 14) | class ArgInspector1 {
  class ArgInspector2 (line 18) | class ArgInspector2 {
  class ArgAlwaysConverts (line 22) | class ArgAlwaysConverts {}
  type PYBIND11_NAMESPACE (line 24) | namespace PYBIND11_NAMESPACE {
    type detail (line 25) | namespace detail {
      type type_caster<ArgInspector1> (line 27) | struct type_caster<ArgInspector1> {
        method load (line 36) | bool load(handle src, bool convert) {
        method handle (line 44) | static handle cast(const ArgInspector1 &src, return_value_policy, ...
      type type_caster<ArgInspector2> (line 49) | struct type_caster<ArgInspector2> {
        method load (line 53) | bool load(handle src, bool convert) {
        method handle (line 61) | static handle cast(const ArgInspector2 &src, return_value_policy, ...
      type type_caster<ArgAlwaysConverts> (line 66) | struct type_caster<ArgAlwaysConverts> {
        method load (line 70) | bool load(handle, bool convert) { return convert; }
        method handle (line 72) | static handle cast(const ArgAlwaysConverts &, return_value_policy,...
      type type_caster<DestructionTester> (line 98) | struct type_caster<DestructionTester> {
        method load (line 100) | bool load(handle, bool) { return true; }
        method handle (line 102) | static handle cast(const DestructionTester &, return_value_policy,...
      type type_caster<other_lib::MyType> (line 133) | struct type_caster<other_lib::MyType> : public other_lib::my_caster {}
    type detail (line 96) | namespace detail {
      type type_caster<ArgInspector1> (line 27) | struct type_caster<ArgInspector1> {
        method load (line 36) | bool load(handle src, bool convert) {
        method handle (line 44) | static handle cast(const ArgInspector1 &src, return_value_policy, ...
      type type_caster<ArgInspector2> (line 49) | struct type_caster<ArgInspector2> {
        method load (line 53) | bool load(handle src, bool convert) {
        method handle (line 61) | static handle cast(const ArgInspector2 &src, return_value_policy, ...
      type type_caster<ArgAlwaysConverts> (line 66) | struct type_caster<ArgAlwaysConverts> {
        method load (line 70) | bool load(handle, bool convert) { return convert; }
        method handle (line 72) | static handle cast(const ArgAlwaysConverts &, return_value_policy,...
      type type_caster<DestructionTester> (line 98) | struct type_caster<DestructionTester> {
        method load (line 100) | bool load(handle, bool) { return true; }
        method handle (line 102) | static handle cast(const DestructionTester &, return_value_policy,...
      type type_caster<other_lib::MyType> (line 133) | struct type_caster<other_lib::MyType> : public other_lib::my_caster {}
    type detail (line 131) | namespace detail {
      type type_caster<ArgInspector1> (line 27) | struct type_caster<ArgInspector1> {
        method load (line 36) | bool load(handle src, bool convert) {
        method handle (line 44) | static handle cast(const ArgInspector1 &src, return_value_policy, ...
      type type_caster<ArgInspector2> (line 49) | struct type_caster<ArgInspector2> {
        method load (line 53) | bool load(handle src, bool convert) {
        method handle (line 61) | static handle cast(const ArgInspector2 &src, return_value_policy, ...
      type type_caster<ArgAlwaysConverts> (line 66) | struct type_caster<ArgAlwaysConverts> {
        method load (line 70) | bool load(handle, bool convert) { return convert; }
        method handle (line 72) | static handle cast(const ArgAlwaysConverts &, return_value_policy,...
      type type_caster<DestructionTester> (line 98) | struct type_caster<DestructionTester> {
        method load (line 100) | bool load(handle, bool) { return true; }
        method handle (line 102) | static handle cast(const DestructionTester &, return_value_policy,...
      type type_caster<other_lib::MyType> (line 133) | struct type_caster<other_lib::MyType> : public other_lib::my_caster {}
  class DestructionTester (line 80) | class DestructionTester {
    method DestructionTester (line 82) | DestructionTester() { print_default_created(this); }
    method DestructionTester (line 84) | DestructionTester(const DestructionTester &) { print_copy_created(this...
    method DestructionTester (line 85) | DestructionTester(DestructionTester &&) noexcept { print_move_created(...
    method DestructionTester (line 86) | DestructionTester &operator=(const DestructionTester &) {
    method DestructionTester (line 90) | DestructionTester &operator=(DestructionTester &&) noexcept {
  type PYBIND11_NAMESPACE (line 95) | namespace PYBIND11_NAMESPACE {
    type detail (line 25) | namespace detail {
      type type_caster<ArgInspector1> (line 27) | struct type_caster<ArgInspector1> {
        method load (line 36) | bool load(handle src, bool convert) {
        method handle (line 44) | static handle cast(const ArgInspector1 &src, return_value_policy, ...
      type type_caster<ArgInspector2> (line 49) | struct type_caster<ArgInspector2> {
        method load (line 53) | bool load(handle src, bool convert) {
        method handle (line 61) | static handle cast(const ArgInspector2 &src, return_value_policy, ...
      type type_caster<ArgAlwaysConverts> (line 66) | struct type_caster<ArgAlwaysConverts> {
        method load (line 70) | bool load(handle, bool convert) { return convert; }
        method handle (line 72) | static handle cast(const ArgAlwaysConverts &, return_value_policy,...
      type type_caster<DestructionTester> (line 98) | struct type_caster<DestructionTester> {
        method load (line 100) | bool load(handle, bool) { return true; }
        method handle (line 102) | static handle cast(const DestructionTester &, return_value_policy,...
      type type_caster<other_lib::MyType> (line 133) | struct type_caster<other_lib::MyType> : public other_lib::my_caster {}
    type detail (line 96) | namespace detail {
      type type_caster<ArgInspector1> (line 27) | struct type_caster<ArgInspector1> {
        method load (line 36) | bool load(handle src, bool convert) {
        method handle (line 44) | static handle cast(const ArgInspector1 &src, return_value_policy, ...
      type type_caster<ArgInspector2> (line 49) | struct type_caster<ArgInspector2> {
        method load (line 53) | bool load(handle src, bool convert) {
        method handle (line 61) | static handle cast(const ArgInspector2 &src, return_value_policy, ...
      type type_caster<ArgAlwaysConverts> (line 66) | struct type_caster<ArgAlwaysConverts> {
        method load (line 70) | bool load(handle, bool convert) { return convert; }
        method handle (line 72) | static handle cast(const ArgAlwaysConverts &, return_value_policy,...
      type type_caster<DestructionTester> (line 98) | struct type_caster<DestructionTester> {
        method load (line 100) | bool load(handle, bool) { return true; }
        method handle (line 102) | static handle cast(const DestructionTester &, return_value_policy,...
      type type_caster<other_lib::MyType> (line 133) | struct type_caster<other_lib::MyType> : public other_lib::my_caster {}
    type detail (line 131) | namespace detail {
      type type_caster<ArgInspector1> (line 27) | struct type_caster<ArgInspector1> {
        method load (line 36) | bool load(handle src, bool convert) {
        method handle (line 44) | static handle cast(const ArgInspector1 &src, return_value_policy, ...
      type type_caster<ArgInspector2> (line 49) | struct type_caster<ArgInspector2> {
        method load (line 53) | bool load(handle src, bool convert) {
        method handle (line 61) | static handle cast(const ArgInspector2 &src, return_value_policy, ...
      type type_caster<ArgAlwaysConverts> (line 66) | struct type_caster<ArgAlwaysConverts> {
        method load (line 70) | bool load(handle, bool convert) { return convert; }
        method handle (line 72) | static handle cast(const ArgAlwaysConverts &, return_value_policy,...
      type type_caster<DestructionTester> (line 98) | struct type_caster<DestructionTester> {
        method load (line 100) | bool load(handle, bool) { return true; }
        method handle (line 102) | static handle cast(const DestructionTester &, return_value_policy,...
      type type_caster<other_lib::MyType> (line 133) | struct type_caster<other_lib::MyType> : public other_lib::my_caster {}
  type other_lib (line 110) | namespace other_lib {
    type MyType (line 111) | struct MyType {}
    type py (line 113) | namespace py {}
    type PYBIND11_NAMESPACE (line 115) | namespace PYBIND11_NAMESPACE {}
    type my_caster (line 120) | struct my_caster {
      method load (line 122) | bool load(py_::handle, bool) { return true; }
      method cast (line 124) | static py_::handle cast(const MyType &, py_::return_value_policy, py...
  type PYBIND11_NAMESPACE (line 130) | namespace PYBIND11_NAMESPACE {
    type detail (line 25) | namespace detail {
      type type_caster<ArgInspector1> (line 27) | struct type_caster<ArgInspector1> {
        method load (line 36) | bool load(handle src, bool convert) {
        method handle (line 44) | static handle cast(const ArgInspector1 &src, return_value_policy, ...
      type type_caster<ArgInspector2> (line 49) | struct type_caster<ArgInspector2> {
        method load (line 53) | bool load(handle src, bool convert) {
        method handle (line 61) | static handle cast(const ArgInspector2 &src, return_value_policy, ...
      type type_caster<ArgAlwaysConverts> (line 66) | struct type_caster<ArgAlwaysConverts> {
        method load (line 70) | bool load(handle, bool convert) { return convert; }
        method handle (line 72) | static handle cast(const ArgAlwaysConverts &, return_value_policy,...
      type type_caster<DestructionTester> (line 98) | struct type_caster<DestructionTester> {
        method load (line 100) | bool load(handle, bool) { return true; }
        method handle (line 102) | static handle cast(const DestructionTester &, return_value_policy,...
      type type_caster<other_lib::MyType> (line 133) | struct type_caster<other_lib::MyType> : public other_lib::my_caster {}
    type detail (line 96) | namespace detail {
      type type_caster<ArgInspector1> (line 27) | struct type_caster<ArgInspector1> {
        method load (line 36) | bool load(handle src, bool convert) {
        method handle (line 44) | static handle cast(const ArgInspector1 &src, return_value_policy, ...
      type type_caster<ArgInspector2> (line 49) | struct type_caster<ArgInspector2> {
        method load (line 53) | bool load(handle src, bool convert) {
        method handle (line 61) | static handle cast(const ArgInspector2 &src, return_value_policy, ...
      type type_caster<ArgAlwaysConverts> (line 66) | struct type_caster<ArgAlwaysConverts> {
        method load (line 70) | bool load(handle, bool convert) { return convert; }
        method handle (line 72) | static handle cast(const ArgAlwaysConverts &, return_value_policy,...
      type type_caster<DestructionTester> (line 98) | struct type_caster<DestructionTester> {
        method load (line 100) | bool load(handle, bool) { return true; }
        method handle (line 102) | static handle cast(const DestructionTester &, return_value_policy,...
      type type_caster<other_lib::MyType> (line 133) | struct type_caster<other_lib::MyType> : public other_lib::my_caster {}
    type detail (line 131) | namespace detail {
      type type_caster<ArgInspector1> (line 27) | struct type_caster<ArgInspector1> {
        method load (line 36) | bool load(handle src, bool convert) {
        method handle (line 44) | static handle cast(const ArgInspector1 &src, return_value_policy, ...
      type type_caster<ArgInspector2> (line 49) | struct type_caster<ArgInspector2> {
        method load (line 53) | bool load(handle src, bool convert) {
        method handle (line 61) | static handle cast(const ArgInspector2 &src, return_value_policy, ...
      type type_caster<ArgAlwaysConverts> (line 66) | struct type_caster<ArgAlwaysConverts> {
        method load (line 70) | bool load(handle, bool convert) { return convert; }
        method handle (line 72) | static handle cast(const ArgAlwaysConverts &, return_value_policy,...
      type type_caster<DestructionTester> (line 98) | struct type_caster<DestructionTester> {
        method load (line 100) | bool load(handle, bool) { return true; }
        method handle (line 102) | static handle cast(const DestructionTester &, return_value_policy,...
      type type_caster<other_lib::MyType> (line 133) | struct type_caster<other_lib::MyType> : public other_lib::my_caster {}
  type ADL_issue (line 138) | namespace ADL_issue {
    function OutStringType (line 140) | OutStringType concat(Args &&...) {
    type test (line 144) | struct test {}
  function TEST_SUBMODULE (line 147) | TEST_SUBMODULE(custom_type_casters, m) {

FILE: tests/test_custom_type_casters.py
  function test_noconvert_args (line 9) | def test_noconvert_args(msg):
  function test_custom_caster_destruction (line 89) | def test_custom_caster_destruction():
  function test_custom_caster_other_lib (line 115) | def test_custom_caster_other_lib():

FILE: tests/test_custom_type_setup.cpp
  type ContainerOwnsPythonObjects (line 20) | struct ContainerOwnsPythonObjects {
    method append (line 23) | void append(const py::object &obj) { list.emplace_back(obj); }
    method at (line 24) | py::object at(py::ssize_t index) const {
    method size (line 30) | py::ssize_t size() const { return py::ssize_t_cast(list.size()); }
    method clear (line 31) | void clear() { list.clear(); }
  function add_gc_checkers_with_weakrefs (line 34) | void add_gc_checkers_with_weakrefs(const py::object &obj) {
  function TEST_SUBMODULE (line 65) | TEST_SUBMODULE(custom_type_setup, m) {

FILE: tests/test_custom_type_setup.py
  function gc_tester (line 15) | def gc_tester():
  function test_self_cycle (line 40) | def test_self_cycle(gc_tester):
  function test_indirect_cycle (line 48) | def test_indirect_cycle(gc_tester):
  function test_py_cast_useable_on_shutdown (line 55) | def test_py_cast_useable_on_shutdown():

FILE: tests/test_docs_advanced_cast_custom.cpp
  type user_space (line 7) | namespace user_space {
    type Point2D (line 9) | struct Point2D {
    function Point2D (line 14) | Point2D negate(const Point2D &point) { return Point2D{-point.x, -point...
  type pybind11 (line 18) | namespace pybind11 {
    type detail (line 19) | namespace detail {
      function handle (line 34) | static handle
      function load (line 43) | bool load(handle src, bool /*convert*/) {
  function TEST_SUBMODULE (line 69) | TEST_SUBMODULE(docs_advanced_cast_custom, m) { m.def("negate", user_spac...

FILE: tests/test_docs_advanced_cast_custom.py
  function assert_negate_function (line 11) | def assert_negate_function(
  function test_negate (line 23) | def test_negate(doc: SanitizedString) -> None:
  function test_docs (line 34) | def test_docs() -> None:

FILE: tests/test_docstring_options.cpp
  function TEST_SUBMODULE (line 12) | TEST_SUBMODULE(docstring_options, m) {

FILE: tests/test_docstring_options.py
  function test_docstring_options (line 6) | def test_docstring_options():

FILE: tests/test_eigen_matrix.cpp
  function reset_ref (line 25) | void reset_ref(M &x) {
  function MatrixXdR (line 43) | MatrixXdR &get_rm() {
  function reset_refs (line 52) | void reset_refs() {
  function get_elem (line 58) | double get_elem(const Eigen::Ref<const Eigen::MatrixXd> &m) { return m(2...
  function adjust_matrix (line 63) | Eigen::MatrixXd adjust_matrix(MatrixArgType m) {
  function CustomOperatorNew (line 74) | CustomOperatorNew() = default;
  function TEST_SUBMODULE (line 82) | TEST_SUBMODULE(eigen_matrix, m) {

FILE: tests/test_eigen_matrix.py
  function assert_equal_ref (line 23) | def assert_equal_ref(mat):
  function assert_sparse_equal_ref (line 27) | def assert_sparse_equal_ref(sparse_mat):
  function test_fixed (line 31) | def test_fixed():
  function test_dense (line 40) | def test_dense():
  function test_partially_fixed (line 49) | def test_partially_fixed():
  function test_mutator_descriptors (line 87) | def test_mutator_descriptors():
  function test_cpp_casting (line 120) | def test_cpp_casting():
  function test_pass_readonly_array (line 143) | def test_pass_readonly_array():
  function test_nonunit_stride_from_python (line 152) | def test_nonunit_stride_from_python():
  function test_negative_stride_from_python (line 175) | def test_negative_stride_from_python(msg):
  function test_block_runtime_error_type_caster_eigen_ref_made_a_copy (line 224) | def test_block_runtime_error_type_caster_eigen_ref_made_a_copy():
  function test_nonunit_stride_to_python (line 230) | def test_nonunit_stride_to_python():
  function test_eigen_ref_to_python (line 244) | def test_eigen_ref_to_python():
  function assign_both (line 253) | def assign_both(a1, a2, r, c, v):
  function array_copy_but_one (line 258) | def array_copy_but_one(a, r, c, v):
  function test_eigen_return_references (line 264) | def test_eigen_return_references():
  function assert_keeps_alive (line 400) | def assert_keeps_alive(cl, method, *args):
  function test_eigen_keepalive (line 416) | def test_eigen_keepalive():
  function test_eigen_ref_mutators (line 449) | def test_eigen_ref_mutators():
  function test_numpy_ref_mutators (line 518) | def test_numpy_ref_mutators():
  function test_both_ref_mutators (line 570) | def test_both_ref_mutators():
  function test_nocopy_wrapper (line 614) | def test_nocopy_wrapper():
  function test_eigen_ref_life_support (line 671) | def test_eigen_ref_life_support():
  function test_special_matrix_objects (line 685) | def test_special_matrix_objects():
  function test_dense_signature (line 700) | def test_dense_signature(doc):
  function test_defaults (line 727) | def test_defaults(doc):
  function test_named_arguments (line 732) | def test_named_arguments():
  function test_sparse (line 753) | def test_sparse():
  function test_sparse_signature (line 763) | def test_sparse_signature(doc):
  function test_issue738 (line 779) | def test_issue738():
  function test_zero_length (line 794) | def test_zero_length(func, sizes):
  function test_issue1105 (line 799) | def test_issue1105():
  function test_custom_operator_new (line 814) | def test_custom_operator_new():
  function test_arraylike_signature (line 823) | def test_arraylike_signature(doc):

FILE: tests/test_eigen_tensor.py
  function cleanup (line 39) | def cleanup():
  function test_import_avoid_stl_array (line 49) | def test_import_avoid_stl_array():
  function assert_equal_tensor_ref (line 54) | def assert_equal_tensor_ref(mat, writeable=True, modified=None):
  function test_reference_internal (line 67) | def test_reference_internal(m, member_name):
  function test_convert_tensor_to_py (line 109) | def test_convert_tensor_to_py(m, func_name):
  function test_bad_cpp_to_python_casts (line 115) | def test_bad_cpp_to_python_casts(m):
  function test_bad_python_to_cpp_casts (line 137) | def test_bad_python_to_cpp_casts(m):
  function test_references_actually_refer (line 196) | def test_references_actually_refer(m):
  function test_round_trip (line 212) | def test_round_trip(m):
  function test_round_trip_references_actually_refer (line 260) | def test_round_trip_references_actually_refer(m):
  function test_doc_string (line 272) | def test_doc_string(m, doc):
  function test_arraylike_signature (line 298) | def test_arraylike_signature(m, doc):

FILE: tests/test_enum.cpp
  function TEST_SUBMODULE (line 12) | TEST_SUBMODULE(enums, m) {

FILE: tests/test_enum.py
  function test_unscoped_enum (line 15) | def test_unscoped_enum():
  function test_scoped_enum (line 133) | def test_scoped_enum():
  function test_implicit_conversion (line 168) | def test_implicit_conversion():
  function test_binary_operators (line 203) | def test_binary_operators():
  function test_enum_to_int (line 225) | def test_enum_to_int():
  function test_duplicate_enum_name (line 240) | def test_duplicate_enum_name():
  function test_char_underlying_enum (line 246) | def test_char_underlying_enum():  # Issue #1331/PR #1334:
  function test_bool_underlying_enum (line 257) | def test_bool_underlying_enum():
  function test_docstring_signatures (line 268) | def test_docstring_signatures():
  function test_str_signature (line 275) | def test_str_signature():
  function test_generated_dunder_methods_pos_only (line 280) | def test_generated_dunder_methods_pos_only():
  function test_obj_cast_unscoped_enum_ptr (line 351) | def test_obj_cast_unscoped_enum_ptr():

FILE: tests/test_eval.cpp
  function TEST_SUBMODULE (line 16) | TEST_SUBMODULE(eval_, m) {

FILE: tests/test_eval.py
  function test_evals (line 11) | def test_evals(capture):
  function test_eval_file (line 23) | def test_eval_file():
  function test_eval_empty_globals (line 30) | def test_eval_empty_globals():
  function test_eval_closure (line 38) | def test_eval_closure():

FILE: tests/test_exceptions.cpp
  class MyException (line 21) | class MyException : public std::exception {
    method MyException (line 23) | explicit MyException(const char *m) : message{m} {}
  class MyExceptionUseDeprecatedOperatorCall (line 30) | class MyExceptionUseDeprecatedOperatorCall : public MyException {
  class MyException2 (line 35) | class MyException2 : public std::exception {
    method MyException2 (line 37) | explicit MyException2(const char *m) : message{m} {}
  class MyException3 (line 45) | class MyException3 {
    method MyException3 (line 47) | explicit MyException3(const char *m) : message{m} {}
    method MyException3 (line 50) | MyException3(const MyException3 &) = default;
    method MyException3 (line 51) | MyException3(MyException3 &&) = default;
    method MyException3 (line 52) | MyException3 &operator=(const MyException3 &) = default;
    method MyException3 (line 53) | MyException3 &operator=(MyException3 &&) = default;
  class MyException4 (line 62) | class MyException4 : public std::exception {
    method MyException4 (line 64) | explicit MyException4(const char *m) : message{m} {}
  class MyException5 (line 72) | class MyException5 : public std::logic_error {
    method MyException5 (line 74) | explicit MyException5(const std::string &what) : std::logic_error(what...
  class MyException5_1 (line 78) | class MyException5_1 : public MyException5 {
  class MyException6 (line 83) | class MyException6 : public std::exception {
    method MyException6 (line 85) | explicit MyException6(const char *m) : message{m} {}
  type PythonCallInDestructor (line 92) | struct PythonCallInDestructor {
    method PythonCallInDestructor (line 93) | explicit PythonCallInDestructor(const py::dict &d) : d(d) {}
  type PythonAlreadySetInDestructor (line 99) | struct PythonAlreadySetInDestructor {
    method PythonAlreadySetInDestructor (line 100) | explicit PythonAlreadySetInDestructor(const py::str &s) : s(s) {}
  type CustomData (line 114) | struct CustomData {
    method CustomData (line 115) | explicit CustomData(const std::string &a) : a(a) {}
  type MyException7 (line 119) | struct MyException7 {
    method MyException7 (line 120) | explicit MyException7(const CustomData &message) : message(message) {}
  function TEST_SUBMODULE (line 124) | TEST_SUBMODULE(exceptions, m) {

FILE: tests/test_exceptions.py
  function test_std_exception (line 14) | def test_std_exception(msg):
  function test_error_already_set (line 20) | def test_error_already_set(msg):
  function test_raise_from (line 33) | def test_raise_from(msg):
  function test_raise_from_already_set (line 40) | def test_raise_from_already_set(msg):
  function test_cross_module_exceptions (line 47) | def test_cross_module_exceptions(msg):
  function test_cross_module_exception_translator (line 84) | def test_cross_module_exception_translator():
  function test_python_call_in_catch (line 90) | def test_python_call_in_catch():
  function ignore_pytest_unraisable_warning (line 96) | def ignore_pytest_unraisable_warning(f):
  function test_python_alreadyset_in_destructor (line 107) | def test_python_alreadyset_in_destructor(monkeypatch, capsys):
  function test_exception_matches (line 132) | def test_exception_matches():
  function test_custom (line 138) | def test_custom(msg):
  function test_nested_throws (line 206) | def test_nested_throws(capture):
  function test_throw_nested_exception (line 261) | def test_throw_nested_exception():
  function test_invalid_repr (line 269) | def test_invalid_repr():
  function test_local_translator (line 278) | def test_local_translator(msg):
  function test_error_already_set_message_with_unicode_surrogate (line 296) | def test_error_already_set_message_with_unicode_surrogate():  # Issue #4288
  function test_error_already_set_message_with_malformed_utf8 (line 303) | def test_error_already_set_message_with_malformed_utf8():
  class FlakyException (line 310) | class FlakyException(Exception):
    method __init__ (line 311) | def __init__(self, failure_point):
    method __str__ (line 316) | def __str__(self):
  function test_error_already_set_what_with_happy_exceptions (line 330) | def test_error_already_set_what_with_happy_exceptions(
  function _test_flaky_exception_failure_point_init_before_py_3_12 (line 338) | def _test_flaky_exception_failure_point_init_before_py_3_12():
  function _test_flaky_exception_failure_point_init_py_3_12 (line 357) | def _test_flaky_exception_failure_point_init_py_3_12():
  function test_flaky_exception_failure_point_init (line 375) | def test_flaky_exception_failure_point_init():
  function test_flaky_exception_failure_point_str (line 383) | def test_flaky_exception_failure_point_str():
  function test_cross_module_interleaved_error_already_set (line 402) | def test_cross_module_interleaved_error_already_set():
  function test_error_already_set_double_restore (line 411) | def test_error_already_set_double_restore():
  function test_pypy_oserror_normalization (line 421) | def test_pypy_oserror_normalization():
  function test_fn_cast_int_exception (line 427) | def test_fn_cast_int_exception():
  function test_return_exception_void (line 436) | def test_return_exception_void():

FILE: tests/test_factory_constructors.cpp
  class TestFactory1 (line 20) | class TestFactory1 {
    method TestFactory1 (line 22) | TestFactory1() : value("(empty)") { print_default_created(this); }
    method TestFactory1 (line 23) | explicit TestFactory1(int v) : value(std::to_string(v)) { print_create...
    method TestFactory1 (line 24) | explicit TestFactory1(std::string v) : value(std::move(v)) { print_cre...
    method TestFactory1 (line 28) | TestFactory1(TestFactory1 &&) = delete;
    method TestFactory1 (line 29) | TestFactory1(const TestFactory1 &) = delete;
    method TestFactory1 (line 30) | TestFactory1 &operator=(TestFactory1 &&) = delete;
    method TestFactory1 (line 31) | TestFactory1 &operator=(const TestFactory1 &) = delete;
  class TestFactory2 (line 35) | class TestFactory2 {
    method TestFactory2 (line 37) | TestFactory2() : value("(empty2)") { print_default_created(this); }
    method TestFactory2 (line 38) | explicit TestFactory2(int v) : value(std::to_string(v)) { print_create...
    method TestFactory2 (line 39) | explicit TestFactory2(std::string v) : value(std::move(v)) { print_cre...
    method TestFactory2 (line 42) | TestFactory2(TestFactory2 &&m) noexcept : value{std::move(m.value)} {
    method TestFactory2 (line 45) | TestFactory2 &operator=(TestFactory2 &&m) noexcept {
  class TestFactory3 (line 54) | class TestFactory3 {
    method TestFactory3 (line 57) | TestFactory3() : value("(empty3)") { print_default_created(this); }
    method TestFactory3 (line 58) | explicit TestFactory3(int v) : value(std::to_string(v)) { print_create...
    method TestFactory3 (line 61) | explicit TestFactory3(std::string v) : value(std::move(v)) { print_cre...
    method TestFactory3 (line 62) | TestFactory3(TestFactory3 &&m) noexcept : value{std::move(m.value)} {
    method TestFactory3 (line 65) | TestFactory3 &operator=(TestFactory3 &&m) noexcept {
  class TestFactory4 (line 74) | class TestFactory4 : public TestFactory3 {
    method TestFactory4 (line 76) | TestFactory4() { print_default_created(this); }
    method TestFactory4 (line 77) | explicit TestFactory4(int v) : TestFactory3(v) { print_created(this, v...
  class TestFactory5 (line 81) | class TestFactory5 : public TestFactory3 {
    method TestFactory5 (line 83) | explicit TestFactory5(int i) : TestFactory3(i) { print_created(this, i...
  class TestFactory6 (line 87) | class TestFactory6 {
    method TestFactory6 (line 93) | explicit TestFactory6(int i) : value{i} { print_created(this, i); }
    method TestFactory6 (line 94) | TestFactory6(TestFactory6 &&f) noexcept {
    method TestFactory6 (line 101) | TestFactory6(const TestFactory6 &f) {
    method get (line 109) | virtual int get() { return value; }
    method has_alias (line 110) | bool has_alias() const { return alias; }
  function PyTF6 (line 116) | explicit PyTF6(TestFactory6 &&base) : TestFactory6(std::move(base)) {
  function PyTF6 (line 120) | explicit PyTF6(int i) : TestFactory6(i) {
  function PyTF6 (line 124) | PyTF6(PyTF6 &&f) noexcept : TestFactory6(std::move(f)) { print_move_crea...
  function PyTF6 (line 125) | PyTF6(const PyTF6 &f) : TestFactory6(f) { print_copy_created(this); }
  function PyTF6 (line 126) | explicit PyTF6(std::string s) : TestFactory6((int) s.size()) {
  function PYBIND11_OVERRIDE (line 131) | PYBIND11_OVERRIDE(int, TestFactory6, get, /*no args*/); }
  function PyTF7 (line 167) | PyTF7(const PyTF7 &f) : TestFactory7(f) { print_copy_created(this); }
  function PYBIND11_OVERRIDE (line 169) | PYBIND11_OVERRIDE(int, TestFactory7, get, /*no args*/); }

FILE: tests/test_factory_constructors.py
  function test_init_factory_basic (line 14) | def test_init_factory_basic():
  function test_init_factory_signature (line 74) | def test_init_factory_signature(msg):
  function test_init_factory_casting (line 108) | def test_init_factory_casting():
  function test_init_factory_alias (line 157) | def test_init_factory_alias():
  function test_init_factory_dual (line 228) | def test_init_factory_dual():
  function test_no_placement_new (line 311) | def test_no_placement_new(capture):
  function test_multiple_inheritance (line 337) | def test_multiple_inheritance():
  function create_and_destroy (line 348) | def create_and_destroy(*args):
  function strip_comments (line 355) | def strip_comments(s):
  function test_reallocation_a (line 360) | def test_reallocation_a(capture, msg):
  function test_reallocation_b (line 383) | def test_reallocation_b(capture, msg):
  function test_reallocation_c (line 400) | def test_reallocation_c(capture, msg):
  function test_reallocation_d (line 415) | def test_reallocation_d(capture, msg):
  function test_reallocation_e (line 431) | def test_reallocation_e(capture, msg):
  function test_reallocation_f (line 448) | def test_reallocation_f(capture, msg):
  function test_reallocation_g (line 464) | def test_reallocation_g(capture, msg):
  function test_invalid_self (line 481) | def test_invalid_self():

FILE: tests/test_gil_scoped.cpp
  class VirtClass (line 21) | class VirtClass {
    method VirtClass (line 24) | VirtClass() = default;
    method VirtClass (line 25) | VirtClass(const VirtClass &) = delete;
    method virtual_func (line 26) | virtual void virtual_func() {}
  function PYBIND11_OVERRIDE_PURE (line 33) | PYBIND11_OVERRIDE_PURE(void, VirtClass, pure_virtual_func, );

FILE: tests/test_gil_scoped.py
  class ExtendedVirtClass (line 23) | class ExtendedVirtClass(m.VirtClass):
    method virtual_func (line 24) | def virtual_func(self):
    method pure_virtual_func (line 27) | def pure_virtual_func(self):
  function test_callback_py_obj (line 31) | def test_callback_py_obj():
  function test_callback_std_func (line 35) | def test_callback_std_func():
  function test_callback_virtual_func (line 39) | def test_callback_virtual_func():
  function test_callback_pure_virtual_func (line 44) | def test_callback_pure_virtual_func():
  function test_cross_module_gil_released (line 49) | def test_cross_module_gil_released():
  function test_cross_module_gil_acquired (line 54) | def test_cross_module_gil_acquired():
  function test_cross_module_gil_inner_custom_released (line 59) | def test_cross_module_gil_inner_custom_released():
  function test_cross_module_gil_inner_custom_acquired (line 65) | def test_cross_module_gil_inner_custom_acquired():
  function test_cross_module_gil_inner_pybind11_released (line 71) | def test_cross_module_gil_inner_pybind11_released():
  function test_cross_module_gil_inner_pybind11_acquired (line 77) | def test_cross_module_gil_inner_pybind11_acquired():
  function test_cross_module_gil_nested_custom_released (line 84) | def test_cross_module_gil_nested_custom_released():
  function test_cross_module_gil_nested_custom_acquired (line 91) | def test_cross_module_gil_nested_custom_acquired():
  function test_cross_module_gil_nested_pybind11_released (line 98) | def test_cross_module_gil_nested_pybind11_released():
  function test_cross_module_gil_nested_pybind11_acquired (line 105) | def test_cross_module_gil_nested_pybind11_acquired():
  function test_release_acquire (line 111) | def test_release_acquire():
  function test_nested_acquire (line 115) | def test_nested_acquire():
  function test_multi_acquire_release_cross_module (line 124) | def test_multi_acquire_release_cross_module():
  function test_all_basic_tests_completeness (line 153) | def test_all_basic_tests_completeness():
  function _intentional_deadlock (line 163) | def _intentional_deadlock():
  function _run_in_process (line 170) | def _run_in_process(target, *args, **kwargs):
  function _run_in_threads (line 220) | def _run_in_threads(test_fn, num_threads, parallel):
  function test_run_in_process_one_thread (line 240) | def test_run_in_process_one_thread(test_fn):
  function test_run_in_process_multiple_threads_parallel (line 255) | def test_run_in_process_multiple_threads_parallel(test_fn):
  function test_run_in_process_multiple_threads_sequential (line 269) | def test_run_in_process_multiple_threads_sequential(test_fn):
  function test_run_in_process_direct (line 289) | def test_run_in_process_direct(test_fn):

FILE: tests/test_iostream.cpp
  function noisy_function (line 20) | void noisy_function(const std::string &msg, bool flush) {
  function noisy_funct_dual (line 28) | void noisy_funct_dual(const std::string &msg, const std::string &emsg) {
  type TestThread (line 36) | struct TestThread {
    method TestThread (line 37) | TestThread() : stop_{false} {
    method stop (line 59) | void stop() { stop_ = true; }
    method join (line 61) | void join() const {
    method sleep (line 66) | void sleep() {
  function TEST_SUBMODULE (line 75) | TEST_SUBMODULE(iostream, m) {

FILE: tests/test_iostream.py
  function test_captured (line 23) | def test_captured(capsys):
  function test_captured_large_string (line 41) | def test_captured_large_string(capsys):
  function test_captured_utf8_2byte_offset0 (line 52) | def test_captured_utf8_2byte_offset0(capsys):
  function test_captured_utf8_2byte_offset1 (line 62) | def test_captured_utf8_2byte_offset1(capsys):
  function test_captured_utf8_3byte_offset0 (line 72) | def test_captured_utf8_3byte_offset0(capsys):
  function test_captured_utf8_3byte_offset1 (line 82) | def test_captured_utf8_3byte_offset1(capsys):
  function test_captured_utf8_3byte_offset2 (line 92) | def test_captured_utf8_3byte_offset2(capsys):
  function test_captured_utf8_4byte_offset0 (line 102) | def test_captured_utf8_4byte_offset0(capsys):
  function test_captured_utf8_4byte_offset1 (line 112) | def test_captured_utf8_4byte_offset1(capsys):
  function test_captured_utf8_4byte_offset2 (line 122) | def test_captured_utf8_4byte_offset2(capsys):
  function test_captured_utf8_4byte_offset3 (line 132) | def test_captured_utf8_4byte_offset3(capsys):
  function test_guard_capture (line 142) | def test_guard_capture(capsys):
  function test_series_captured (line 150) | def test_series_captured(capture):
  function test_flush (line 157) | def test_flush(capfd):
  function test_not_captured (line 176) | def test_not_captured(capfd):
  function test_err (line 195) | def test_err(capfd):
  function test_multi_captured (line 214) | def test_multi_captured(capfd):
  function test_dual (line 226) | def test_dual(capsys):
  function test_redirect (line 233) | def test_redirect(capfd):
  function test_redirect_err (line 257) | def test_redirect_err(capfd):
  function test_redirect_both (line 271) | def test_redirect_both(capfd):
  function test_threading (line 288) | def test_threading():

FILE: tests/test_kwargs_and_defaults.cpp
  function TEST_SUBMODULE (line 17) | TEST_SUBMODULE(kwargs_and_defaults, m) {

FILE: tests/test_kwargs_and_defaults.py
  function test_function_signatures (line 9) | def test_function_signatures(doc):
  function test_named_arguments (line 90) | def test_named_arguments():
  function test_arg_and_kwargs (line 118) | def test_arg_and_kwargs():
  function test_mixed_args_and_kwargs (line 128) | def test_mixed_args_and_kwargs(msg):
  function test_keyword_only_args (line 252) | def test_keyword_only_args(msg):
  function test_positional_only_args (line 306) | def test_positional_only_args():
  function test_signatures (line 395) | def test_signatures():
  function test_args_refcount (line 419) | def test_args_refcount():

FILE: tests/test_local_bindings.cpp
  function TEST_SUBMODULE (line 20) | TEST_SUBMODULE(local_bindings, m) {

FILE: tests/test_local_bindings.py
  function test_load_external (line 11) | def test_load_external():
  function test_local_bindings (line 58) | def test_local_bindings():
  function test_nonlocal_failure (line 85) | def test_nonlocal_failure():
  function test_duplicate_local (line 96) | def test_duplicate_local():
  function test_stl_bind_local (line 109) | def test_stl_bind_local():
  function test_stl_bind_global (line 143) | def test_stl_bind_global():
  function test_mixed_local_global (line 165) | def test_mixed_local_global():
  function test_internal_locals_differ (line 210) | def test_internal_locals_differ():
  function test_stl_caster_vs_stl_bind (line 217) | def test_stl_caster_vs_stl_bind(msg):
  function test_cross_module_calls (line 241) | def test_cross_module_calls():

FILE: tests/test_methods_and_attributes.cpp
  class ExampleMandA (line 19) | class ExampleMandA {
    method ExampleMandA (line 21) | ExampleMandA() { print_default_created(this); }
    method ExampleMandA (line 22) | explicit ExampleMandA(int value) : value(value) { print_created(this, ...
    method ExampleMandA (line 23) | ExampleMandA(const ExampleMandA &e) : value(e.value) { print_copy_crea...
    method ExampleMandA (line 24) | explicit ExampleMandA(std::string &&) {}
    method ExampleMandA (line 25) | ExampleMandA(ExampleMandA &&e) noexcept : value(e.value) { print_move_...
    method toString (line 28) | std::string toString() const { return "ExampleMandA[value=" + std::to_...
    method add1 (line 40) | void add1(ExampleMandA other) { value += other.value; }
    method add2 (line 41) | void add2(ExampleMandA &other) { value += other.value; }
    method add3 (line 42) | void add3(const ExampleMandA &other) { value += other.value; }
    method add4 (line 43) | void add4(ExampleMandA *other) { value += other->value; }
    method add5 (line 44) | void add5(const ExampleMandA *other) { value += other->value; }
    method add6 (line 46) | void add6(int other) { value += other; }
    method add7 (line 47) | void add7(int &other) { value += other; }
    method add8 (line 48) | void add8(const int &other) { value += other; }
    method add9 (line 50) | void add9(int *other) { value += *other; }
    method add10 (line 51) | void add10(const int *other) { value += *other; }
    method consume_str (line 53) | void consume_str(std::string &&) {}
    method ExampleMandA (line 55) | ExampleMandA self1() { return *this; }
    method ExampleMandA (line 56) | ExampleMandA &self2() { return *this; }
    method ExampleMandA (line 57) | const ExampleMandA &self3() const { return *this; }
    method ExampleMandA (line 58) | ExampleMandA *self4() { return this; }
    method ExampleMandA (line 59) | const ExampleMandA *self5() const { return this; }
    method internal1 (line 61) | int internal1() const { return value; }
    method overloaded (line 67) | py::str overloaded() { return "()"; }
    method overloaded (line 68) | py::str overloaded(int) { return "(int)"; }
    method overloaded (line 69) | py::str overloaded(int, float) { return "(int, float)"; }
    method overloaded (line 70) | py::str overloaded(float, int) { return "(float, int)"; }
    method overloaded (line 71) | py::str overloaded(int, int) { return "(int, int)"; }
    method overloaded (line 72) | py::str overloaded(float, float) { return "(float, float)"; }
    method overloaded (line 73) | py::str overloaded(int) const { return "(int) const"; }
    method overloaded (line 74) | py::str overloaded(int, float) const { return "(int, float) const"; }
    method overloaded (line 75) | py::str overloaded(float, int) const { return "(float, int) const"; }
    method overloaded (line 76) | py::str overloaded(int, int) const { return "(int, int) const"; }
    method overloaded (line 77) | py::str overloaded(float, float) const { return "(float, float) const"; }
    method overloaded (line 79) | static py::str overloaded(float) { return "static float"; }
  type TestProperties (line 84) | struct TestProperties {
    method get (line 88) | int get() const { return value; }
    method set (line 89) | void set(int v) { value = v; }
    method static_get (line 91) | static int static_get() { return static_value; }
    method static_set (line 92) | static void static_set(int v) { static_value = v; }
  type TestPropertiesOverride (line 96) | struct TestPropertiesOverride : TestProperties {
  type TestPropRVP (line 102) | struct TestPropRVP {
    method UserType (line 108) | const UserType &get1() const { return v1; }
    method UserType (line 109) | const UserType &get2() const { return v2; }
    method UserType (line 110) | UserType get_rvalue() const { return v2; }
    method set1 (line 111) | void set1(int v) { v1.set(v); }
    method set2 (line 112) | void set2(int v) { v2.set(v); }
  class NoneTester (line 118) | class NoneTester {
  function none1 (line 122) | int none1(const NoneTester &obj) { return obj.answer; }
  function none2 (line 123) | int none2(NoneTester *obj) { return obj ? obj->answer : -1; }
  function none3 (line 124) | int none3(std::shared_ptr<NoneTester> &obj) { return obj ? obj->answer :...
  function none4 (line 125) | int none4(std::shared_ptr<NoneTester> *obj) { return obj && *obj ? (*obj...
  function none5 (line 126) | int none5(const std::shared_ptr<NoneTester> &obj) { return obj ? obj->an...
  class NoneCastTester (line 129) | class NoneCastTester {
    method NoneCastTester (line 132) | NoneCastTester() = default;
    method NoneCastTester (line 133) | explicit NoneCastTester(int v) : answer(v) {}
  type StrIssue (line 136) | struct StrIssue {
    method StrIssue (line 139) | StrIssue() = default;
    method StrIssue (line 140) | explicit StrIssue(int i) : val{i} {}
  class UnregisteredBase (line 145) | class UnregisteredBase {
    method do_nothing (line 147) | void do_nothing() const {}
    method increase_value (line 148) | void increase_value() {
    method set_int (line 152) | void set_int(int v) { rw_value = v; }
    method get_int (line 153) | int get_int() const { return rw_value; }
    method get_double (line 154) | double get_double() const { return ro_value; }
  class RegisteredDerived (line 158) | class RegisteredDerived : public UnregisteredBase {
    method sum (line 161) | double sum() const { return rw_value + ro_value; }
  type RefQualified (line 165) | struct RefQualified {
    method refQualified (line 168) | void refQualified(int other) & { value += other; }
    method constRefQualified (line 169) | int constRefQualified(int other) const & { return value + other; }
  type RValueRefParam (line 173) | struct RValueRefParam {
    method func1 (line 174) | std::size_t func1(std::string &&s) { return s.size(); }
    method func2 (line 175) | std::size_t func2(std::string &&s) const { return s.size(); }
    method func3 (line 176) | std::size_t func3(std::string &&s) & { return s.size(); }
    method func4 (line 177) | std::size_t func4(std::string &&s) const & { return s.size(); }
  type pybind11_tests (line 180) | namespace pybind11_tests {
    type exercise_is_setter (line 181) | namespace exercise_is_setter {
      type FieldBase (line 183) | struct FieldBase {
        method int_value (line 184) | int int_value() const { return int_value_; }
        method FieldBase (line 186) | FieldBase &SetIntValue(int int_value) {
      type Field (line 195) | struct Field : FieldBase {}
      function add_bindings (line 197) | void add_bindings(py::module &m) {
  function TEST_SUBMODULE (line 212) | TEST_SUBMODULE(methods_and_attributes, m) {

FILE: tests/test_methods_and_attributes.py
  function test_self_only_pos_only (line 22) | def test_self_only_pos_only():
  function test_methods_and_attributes (line 29) | def test_methods_and_attributes():
  function test_copy_method (line 93) | def test_copy_method():
  function test_properties (line 110) | def test_properties():
  function test_static_properties (line 143) | def test_static_properties():
  function test_static_cls (line 210) | def test_static_cls():
  function test_metaclass_override (line 224) | def test_metaclass_override():
  function test_no_mixed_overloads (line 242) | def test_no_mixed_overloads():
  function test_property_return_value_policies (line 274) | def test_property_return_value_policies(access):
  function test_property_rvalue_policy (line 294) | def test_property_rvalue_policy():
  function test_dynamic_attributes (line 312) | def test_dynamic_attributes():
  function test_cyclic_gc (line 363) | def test_cyclic_gc():
  function test_bad_arg_default (line 386) | def test_bad_arg_default(msg):
  function test_accepts_none (line 410) | def test_accepts_none(msg):
  function test_casts_none (line 472) | def test_casts_none():
  function test_str_issue (line 483) | def test_str_issue(msg):
  function test_unregistered_base_implementations (line 502) | def test_unregistered_base_implementations():
  function test_ref_qualified (line 520) | def test_ref_qualified():
  function test_overload_ordering (line 531) | def test_overload_ordering():
  function test_rvalue_ref_param (line 560) | def test_rvalue_ref_param():
  function test_is_setter (line 568) | def test_is_setter():

FILE: tests/test_modules.cpp
  function TEST_SUBMODULE (line 14) | TEST_SUBMODULE(modules, m) {

FILE: tests/test_modules.py
  function test_nested_modules (line 13) | def test_nested_modules():
  function test_reference_internal (line 29) | def test_reference_internal():
  function test_importing (line 66) | def test_importing():
  function test_reimport (line 74) | def test_reimport():
  function test_pydoc (line 91) | def test_pydoc():
  function test_module_handle_type_name (line 102) | def test_module_handle_type_name():
  function test_duplicate_registration (line 109) | def test_duplicate_registration():
  function test_builtin_key_type (line 115) | def test_builtin_key_type():
  function test_def_submodule_failures (line 124) | def test_def_submodule_failures():

FILE: tests/test_multiple_inheritance.cpp
  type BaseN (line 19) | struct BaseN {
    method BaseN (line 20) | explicit BaseN(int i) : i(i) {}
  type Vanilla (line 25) | struct Vanilla {
    method vanilla (line 26) | std::string vanilla() { return "Vanilla"; }
  type WithStatic1 (line 28) | struct WithStatic1 {
    method static_func1 (line 29) | static std::string static_func1() { return "WithStatic1"; }
  type WithStatic2 (line 32) | struct WithStatic2 {
    method static_func2 (line 33) | static std::string static_func2() { return "WithStatic2"; }
  type VanillaStaticMix1 (line 36) | struct VanillaStaticMix1 : Vanilla, WithStatic1, WithStatic2 {
    method static_func (line 37) | static std::string static_func() { return "VanillaStaticMix1"; }
  type VanillaStaticMix2 (line 40) | struct VanillaStaticMix2 : WithStatic1, Vanilla, WithStatic2 {
    method static_func (line 41) | static std::string static_func() { return "VanillaStaticMix2"; }
  type Base1a (line 50) | struct Base1a {
    method Base1a (line 51) | explicit Base1a(int i) : i(i) {}
    method foo (line 52) | int foo() const { return i; }
  type Base2a (line 55) | struct Base2a {
    method Base2a (line 56) | explicit Base2a(int i) : i(i) {}
    method bar (line 57) | int bar() const { return i; }
  type Base12a (line 60) | struct Base12a : Base1a, Base2a {
    method Base12a (line 61) | Base12a(int i, int j) : Base1a(i), Base2a(j) {}
  type I801B1 (line 66) | struct I801B1 {
    method I801B1 (line 68) | I801B1() = default;
    method I801B1 (line 69) | I801B1(const I801B1 &) = default;
  type I801B2 (line 72) | struct I801B2 {
    method I801B2 (line 74) | I801B2() = default;
    method I801B2 (line 75) | I801B2(const I801B2 &) = default;
  type I801C (line 78) | struct I801C : I801B1, I801B2 {}
  type I801D (line 79) | struct I801D : I801C {}
  function TEST_SUBMODULE (line 83) | TEST_SUBMODULE(multiple_inheritance, m) {

FILE: tests/test_multiple_inheritance.py
  function test_multiple_inheritance_cpp (line 10) | def test_multiple_inheritance_cpp():
  function test_multiple_inheritance_mix1 (line 18) | def test_multiple_inheritance_mix1():
  function test_multiple_inheritance_mix2 (line 37) | def test_multiple_inheritance_mix2():
  function test_multiple_inheritance_python (line 57) | def test_multiple_inheritance_python():
  function test_multiple_inheritance_python_many_bases (line 162) | def test_multiple_inheritance_python_many_bases():
  function test_multiple_inheritance_virtbase (line 231) | def test_multiple_inheritance_virtbase():
  function test_mi_static_properties (line 242) | def test_mi_static_properties():
  function test_mi_dynamic_attributes (line 266) | def test_mi_dynamic_attributes():
  function test_mi_unaligned_base (line 274) | def test_mi_unaligned_base():
  function test_mi_base_return (line 303) | def test_mi_base_return():
  function test_diamond_inheritance (line 352) | def test_diamond_inheritance():
  function test_pr3635_diamond_b (line 367) | def test_pr3635_diamond_b():
  function test_pr3635_diamond_c (line 374) | def test_pr3635_diamond_c():
  function test_pr3635_diamond_d0 (line 385) | def test_pr3635_diamond_d0():
  function test_pr3635_diamond_d1 (line 401) | def test_pr3635_diamond_d1():
  function test_pr3635_diamond_e (line 417) | def test_pr3635_diamond_e():
  function test_pr3635_diamond_f (line 445) | def test_pr3635_diamond_f():
  function test_python_inherit_from_mi (line 481) | def test_python_inherit_from_mi():

FILE: tests/test_multiple_interpreters.py
  function get_interpreters (line 32) | def get_interpreters(*, modern: bool):
  function test_independent_subinterpreters (line 89) | def test_independent_subinterpreters():
  function test_independent_subinterpreters_modern (line 140) | def test_independent_subinterpreters_modern():
  function test_dependent_subinterpreters (line 186) | def test_dependent_subinterpreters():
  function test_import_module_with_singleton_per_interpreter (line 263) | def test_import_module_with_singleton_per_interpreter():
  function test_import_in_subinterpreter_after_main (line 276) | def test_import_in_subinterpreter_after_main():
  function test_import_in_subinterpreter_before_main (line 332) | def test_import_in_subinterpreter_before_main():
  function test_import_in_subinterpreter_concurrently (line 417) | def test_import_in_subinterpreter_concurrently():

FILE: tests/test_native_enum.cpp
  type test_native_enum (line 7) | namespace test_native_enum {
    type smallenum (line 12) | enum smallenum : std::int16_t { a, b, c }
    type color (line 15) | enum color { red, yellow, green = 20, blue }
    type altitude (line 18) | enum class altitude : char {
    type flags_uchar (line 23) | enum class flags_uchar : unsigned char { bit0 = 0x1u, bit1 = 0x2u, bit...
    type flags_uint (line 24) | enum class flags_uint : unsigned int { bit0 = 0x1u, bit1 = 0x2u, bit2 ...
    type export_values (line 26) | enum class export_values { exv0, exv1 }
    type member_doc (line 28) | enum class member_doc { mem0, mem1, mem2 }
    type class_with_enum (line 30) | struct class_with_enum {
      type in_class (line 31) | enum class in_class { one, two }
    type is_proto_enum (line 38) | struct is_proto_enum : std::false_type {}
    type some_proto_enum (line 40) | enum some_proto_enum : int { Zero, One }
    type is_proto_enum<some_proto_enum> (line 43) | struct is_proto_enum<some_proto_enum> : std::true_type {}
    type func_sig_rendering (line 45) | enum class func_sig_rendering {}
  type type_caster_enum_type_enabled<
    ProtoEnumType,
    enable_if_t<test_native_enum::is_proto_enum<ProtoEnumType>::value>> (line 55) | struct type_caster_enum_type_enabled<
  type type_caster<ProtoEnumType,
                   detail::enable_if_t<test_native_enum::is_proto_enum<ProtoEnumType>::value>> (line 62) | struct type_caster<ProtoEnumType,
    method handle (line 64) | static handle
    method load (line 69) | bool load(handle /*src*/, bool /*convert*/) {
  function TEST_SUBMODULE (line 80) | TEST_SUBMODULE(native_enum, m) {

FILE: tests/test_native_enum.py
  function test_enum_type (line 74) | def test_enum_type(enum_type):
  function test_enum_members (line 80) | def test_enum_members(enum_type, members):
  function test_pickle_roundtrip (line 86) | def test_pickle_roundtrip(enum_type, members):
  function test_enum_flag (line 96) | def test_enum_flag(enum_type):
  function test_export_values (line 103) | def test_export_values():
  function test_class_doc (line 108) | def test_class_doc():
  function test_member_doc (line 114) | def test_member_doc():
  function test_pybind11_isinstance_color (line 121) | def test_pybind11_isinstance_color():
  function test_pass_color_success (line 131) | def test_pass_color_success():
  function test_pass_color_fail (line 136) | def test_pass_color_fail():
  function test_return_color_success (line 142) | def test_return_color_success():
  function test_return_color_fail (line 147) | def test_return_color_fail():
  function test_return_color_ptr (line 155) | def test_return_color_ptr():
  function test_property_type_hint (line 160) | def test_property_type_hint():
  function test_func_sig_rendering (line 169) | def test_func_sig_rendering():
  function test_type_caster_enum_type_enabled_false (line 176) | def test_type_caster_enum_type_enabled_false():
  function test_obj_cast_color_ptr (line 183) | def test_obj_cast_color_ptr():
  function test_py_cast_color_handle (line 189) | def test_py_cast_color_handle():
  function test_exercise_import_or_getattr_leading_dot (line 194) | def test_exercise_import_or_getattr_leading_dot():
  function test_exercise_import_or_getattr_bad_top_level (line 200) | def test_exercise_import_or_getattr_bad_top_level():
  function test_exercise_import_or_getattr_dot_dot (line 209) | def test_exercise_import_or_getattr_dot_dot():
  function test_exercise_import_or_getattr_bad_enum_attr (line 217) | def test_exercise_import_or_getattr_bad_enum_attr():
  function test_native_enum_data_missing_finalize_error_message (line 232) | def test_native_enum_data_missing_finalize_error_message():
  function test_native_enum_malformed_utf8 (line 240) | def test_native_enum_malformed_utf8(func):
  function test_native_enum_double_finalize (line 248) | def test_native_enum_double_finalize():
  function test_native_enum_value_after_finalize (line 257) | def test_native_enum_value_after_finalize():
  function test_double_registration_native_enum (line 266) | def test_double_registration_native_enum():
  function test_native_enum_name_clash (line 275) | def test_native_enum_name_clash():
  function test_native_enum_value_name_clash (line 286) | def test_native_enum_value_name_clash():
  function test_double_registration_enum_before_native_enum (line 298) | def test_double_registration_enum_before_native_enum():
  function test_double_registration_native_enum_before_enum (line 308) | def test_double_registration_native_enum_before_enum():
  function test_native_enum_missing_finalize_failure (line 318) | def test_native_enum_missing_finalize_failure():
  function test_unregister_native_enum_when_destroyed (line 324) | def test_unregister_native_enum_when_destroyed():

FILE: tests/test_numpy_array.cpp
  type DtypeCheck (line 20) | struct DtypeCheck {
  function DtypeCheck (line 26) | DtypeCheck get_dtype_check(const char *name) {
  function get_concrete_dtype_checks (line 34) | std::vector<DtypeCheck> get_concrete_dtype_checks() {
  type DtypeSizeCheck (line 46) | struct DtypeSizeCheck {
  function DtypeSizeCheck (line 55) | DtypeSizeCheck get_dtype_size_check() {
  function get_platform_dtype_size_checks (line 64) | std::vector<DtypeSizeCheck> get_platform_dtype_size_checks() {
  function arr (line 83) | arr data(const arr &a, Ix... index) {
  function arr (line 88) | arr data_t(const arr_t &a, Ix... index) {
  function arr (line 93) | arr &mutate_data(arr &a, Ix... index) {
  function arr_t (line 102) | arr_t &mutate_data_t(arr_t &a, Ix... index) {
  function index_at (line 111) | py::ssize_t index_at(const arr &a, Ix... idx) {
  function index_at_t (line 115) | py::ssize_t index_at_t(const arr_t &a, Ix... idx) {
  function offset_at (line 119) | py::ssize_t offset_at(const arr &a, Ix... idx) {
  function offset_at_t (line 123) | py::ssize_t offset_at_t(const arr_t &a, Ix... idx) {
  function at_t (line 127) | py::ssize_t at_t(const arr_t &a, Ix... idx) {
  function arr_t (line 131) | arr_t &mutate_at_t(arr_t &a, Ix... idx) {
  function auxiliaries (line 143) | py::handle auxiliaries(T &&r, T2 &&r2) {
  function PyObject (line 164) | PyObject *convert_to_pyobjecttype<PyObject *>(py::object obj) {
  function pass_array_return_sum_str_values (line 179) | std::string pass_array_return_sum_str_values(const py::array_t<PyObjectT...
  function pass_array_return_as_list (line 188) | py::list pass_array_return_as_list(const py::array_t<PyObjectType> &objs) {
  function return_array_cpp_loop (line 193) | py::array_t<PyObjectType> return_array_cpp_loop(const py::list &objs) {
  function return_array_from_list (line 205) | py::array_t<PyObjectType> return_array_from_list(const py::list &objs) {
  function TEST_SUBMODULE (line 212) | TEST_SUBMODULE(numpy_array, sm) {

FILE: tests/test_numpy_array.py
  function test_dtypes (line 11) | def test_dtypes():
  function arr (line 28) | def arr():
  function test_array_attributes (line 32) | def test_array_attributes():
  function test_shape_strides_span (line 72) | def test_shape_strides_span():
  function test_index_offset (line 113) | def test_index_offset(arr, args, ret):
  function test_dim_check_fail (line 120) | def test_dim_check_fail(arr):
  function test_data (line 145) | def test_data(arr, args, ret):
  function test_at_fail (line 154) | def test_at_fail(arr, dim):
  function test_at (line 161) | def test_at(arr):
  function test_mutate_readonly (line 169) | def test_mutate_readonly(arr):
  function test_mutate_data (line 181) | def test_mutate_data(arr):
  function test_bounds_check (line 195) | def test_bounds_check(arr):
  function test_make_c_f_array (line 214) | def test_make_c_f_array():
  function test_make_empty_shaped_array (line 221) | def test_make_empty_shaped_array():
  function test_wrap (line 230) | def test_wrap():
  function test_numpy_view (line 285) | def test_numpy_view(capture):
  function test_cast_numpy_int64_to_uint64 (line 318) | def test_cast_numpy_int64_to_uint64():
  function test_isinstance (line 323) | def test_isinstance():
  function test_constructors (line 328) | def test_constructors():
  function test_array_object_type (line 344) | def test_array_object_type(doc):
  function test_overload_resolution (line 351) | def test_overload_resolution(msg):
  function test_greedy_string_overload (line 421) | def test_greedy_string_overload():
  function test_array_unchecked_fixed_dims (line 429) | def test_array_unchecked_fixed_dims(msg):
  function test_array_unchecked_dyn_dims (line 455) | def test_array_unchecked_dyn_dims():
  function test_array_failure (line 467) | def test_array_failure():
  function test_initializer_list (line 481) | def test_initializer_list():
  function test_array_resize (line 488) | def test_array_resize():
  function test_array_create_and_resize (line 516) | def test_array_create_and_resize():
  function test_array_view (line 522) | def test_array_view():
  function test_array_view_invalid (line 531) | def test_array_view_invalid():
  function test_reshape_initializer_list (line 537) | def test_reshape_initializer_list():
  function test_reshape_tuple (line 547) | def test_reshape_tuple():
  function test_index_using_ellipsis (line 562) | def test_index_using_ellipsis():
  function test_format_descriptors_for_floating_point_types (line 576) | def test_format_descriptors_for_floating_point_types(test_func):
  function test_argument_conversions (line 591) | def test_argument_conversions(forcecast, contiguity, noconvert):
  function test_dtype_refcount_leak (line 633) | def test_dtype_refcount_leak():
  function test_round_trip_float (line 645) | def test_round_trip_float():
  class PyValueHolder (line 665) | class PyValueHolder:
    method __init__ (line 666) | def __init__(self, value):
  function WrapWithPyValueHolder (line 670) | def WrapWithPyValueHolder(*values):
  function UnwrapPyValueHolder (line 674) | def UnwrapPyValueHolder(vhs):
  function test_pass_array_object_return_sum_str_values_ndarray (line 688) | def test_pass_array_object_return_sum_str_values_ndarray(pass_array):
  function test_pass_array_object_return_sum_str_values_list (line 699) | def test_pass_array_object_return_sum_str_values_list(pass_array):
  function test_pass_array_object_return_as_list (line 712) | def test_pass_array_object_return_as_list(pass_array):
  function test_return_array_object_cpp_loop (line 730) | def test_return_array_object_cpp_loop(return_array, unwrap):
  function test_arraylike_signature (line 738) | def test_arraylike_signature(doc):

FILE: tests/test_numpy_dtypes.cpp
  type SimpleStruct (line 25) | struct SimpleStruct {
  type SimpleStructReordered (line 36) | struct SimpleStructReordered {
  type PackedStruct (line 43) | struct PackedStruct {
  type NestedStruct (line 54) | struct NestedStruct {
  type PartialStruct (line 63) | struct PartialStruct {
  type PartialNestedStruct (line 71) | struct PartialNestedStruct {
  type UnboundStruct (line 77) | struct UnboundStruct {}
  type StringStruct (line 79) | struct StringStruct {
  type ComplexStruct (line 84) | struct ComplexStruct {
  type ArrayStruct (line 93) | struct ArrayStruct {
  type StructWithUglyNames (line 100) | struct StructWithUglyNames {
  type E1 (line 105) | enum class E1 : int64_t { A = -1, B = 1 }
  type E2 (line 106) | enum E2 : uint8_t { X = 1, Y = 2 }
  type EnumStruct (line 108) | struct EnumStruct {
  function mkarray_via_buffer (line 154) | py::array mkarray_via_buffer(size_t n) {
  function create_recarray (line 168) | py::array_t<S, 0> create_recarray(size_t n) {
  function print_recarray (line 179) | py::list print_recarray(const py::array_t<S, 0> &arr) {
  function test_array_ctors (line 191) | py::array_t<int32_t, 0> test_array_ctors(int i) {
  function test_dtype_ctors (line 278) | py::list test_dtype_ctors() {
  function dispatch_array_increment (line 304) | py::array_t<T> dispatch_array_increment(const py::array_t<T> &arr) {
  type A (line 312) | struct A {}
  type B (line 313) | struct B {}
  function TEST_SUBMODULE (line 315) | TEST_SUBMODULE(numpy_dtypes, m) {

FILE: tests/test_numpy_dtypes.py
  function simple_dtype (line 14) | def simple_dtype():
  function packed_dtype (line 26) | def packed_dtype():
  function dt_fmt (line 30) | def dt_fmt():
  function simple_dtype_fmt (line 41) | def simple_dtype_fmt():
  function packed_dtype_fmt (line 47) | def packed_dtype_fmt():
  function partial_ld_offset (line 55) | def partial_ld_offset():
  function partial_dtype_fmt (line 64) | def partial_dtype_fmt():
  function partial_nested_fmt (line 74) | def partial_nested_fmt():
  function assert_equal (line 84) | def assert_equal(actual, expected_data, expected_dtype):
  function test_format_descriptors (line 88) | def test_format_descriptors():
  function test_dtype (line 120) | def test_dtype(simple_dtype):
  function test_recarray (line 208) | def test_recarray(simple_dtype, packed_dtype):
  function test_array_constructors (line 281) | def test_array_constructors():
  function test_string_array (line 291) | def test_string_array():
  function test_array_array (line 307) | def test_array_array():
  function test_enum_array (line 335) | def test_enum_array():
  function test_complex_array (line 349) | def test_complex_array():
  function test_signature (line 367) | def test_signature(doc):
  function test_scalar_conversion (line 374) | def test_scalar_conversion():
  function test_vectorize (line 394) | def test_vectorize():
  function test_cls_and_dtype_conversion (line 403) | def test_cls_and_dtype_conversion(simple_dtype):
  function test_register_dtype (line 443) | def test_register_dtype():
  function test_str_leak (line 450) | def test_str_leak():
  function test_compare_buffer_info (line 463) | def test_compare_buffer_info():

FILE: tests/test_numpy_scalars.cpp
  type pybind11_test_numpy_scalars (line 19) | namespace pybind11_test_numpy_scalars {
    type add (line 22) | struct add {
      method add (line 24) | explicit add(T x) : x(x) {}
      method T (line 25) | T operator()(T y) const { return static_cast<T>(x + y); }
    function register_test (line 29) | void register_test(py::module &m, const char *name, F &&func) {
  function TEST_SUBMODULE (line 41) | TEST_SUBMODULE(numpy_scalars, m) {

FILE: tests/test_numpy_scalars.py
  function test_numpy_scalars (line 31) | def test_numpy_scalars(npy_scalar_type, expected_value):
  function test_eq_ne (line 50) | def test_eq_ne():

FILE: tests/test_numpy_vectorize.cpp
  function my_func (line 17) | double my_func(int x, float y, double z) {
  function TEST_SUBMODULE (line 22) | TEST_SUBMODULE(numpy_vectorize, m) {

FILE: tests/test_numpy_vectorize.py
  function test_vectorize (line 10) | def test_vectorize(capture):
  function test_type_selection (line 140) | def test_type_selection():
  function test_docs (line 149) | def test_docs(doc):
  function test_trivial_broadcasting (line 158) | def test_trivial_broadcasting():
  function test_passthrough_arguments (line 209) | def test_passthrough_arguments(doc):
  function test_method_vectorization (line 242) | def test_method_vectorization():
  function test_array_collapse (line 249) | def test_array_collapse():
  function test_vectorized_noreturn (line 260) | def test_vectorized_noreturn():

FILE: tests/test_opaque_types.cpp
  function TEST_SUBMODULE (line 25) | TEST_SUBMODULE(opaque_types, m) {

FILE: tests/test_opaque_types.py
  function test_string_list (line 10) | def test_string_list():
  function test_pointers (line 30) | def test_pointers(msg, backport_typehints):
  function test_unions (line 59) | def test_unions():

FILE: tests/test_operator_overloading.cpp
  class Vector2 (line 18) | class Vector2 {
    method Vector2 (line 20) | Vector2(float x, float y) : x(x), y(y) { print_created(this, toString(...
    method Vector2 (line 21) | Vector2(const Vector2 &v) : x(v.x), y(v.y) { print_copy_created(this); }
    method Vector2 (line 22) | Vector2(Vector2 &&v) noexcept : x(v.x), y(v.y) {
    method Vector2 (line 26) | Vector2 &operator=(const Vector2 &v) {
    method Vector2 (line 32) | Vector2 &operator=(Vector2 &&v) noexcept {
    method toString (line 41) | std::string toString() const {
    method Vector2 (line 45) | Vector2 operator-() const { return Vector2(-x, -y); }
    method Vector2 (line 46) | Vector2 operator+(const Vector2 &v) const { return Vector2(x + v.x, y ...
    method Vector2 (line 47) | Vector2 operator-(const Vector2 &v) const { return Vector2(x - v.x, y ...
    method Vector2 (line 48) | Vector2 operator-(float value) const { return Vector2(x - value, y - v...
    method Vector2 (line 49) | Vector2 operator+(float value) const { return Vector2(x + value, y + v...
    method Vector2 (line 50) | Vector2 operator*(float value) const { return Vector2(x * value, y * v...
    method Vector2 (line 51) | Vector2 operator/(float value) const { return Vector2(x / value, y / v...
    method Vector2 (line 52) | Vector2 operator*(const Vector2 &v) const { return Vector2(x * v.x, y ...
    method Vector2 (line 53) | Vector2 operator/(const Vector2 &v) const { return Vector2(x / v.x, y ...
    method Vector2 (line 54) | Vector2 &operator+=(const Vector2 &v) {
    method Vector2 (line 59) | Vector2 &operator-=(const Vector2 &v) {
    method Vector2 (line 64) | Vector2 &operator*=(float v) {
    method Vector2 (line 69) | Vector2 &operator/=(float v) {
    method Vector2 (line 74) | Vector2 &operator*=(const Vector2 &v) {
    method Vector2 (line 79) | Vector2 &operator/=(const Vector2 &v) {
    method Vector2 (line 85) | Vector2 operator+(float f, const Vector2 &v) { return Vector2(f + v.x,...
    method Vector2 (line 86) | Vector2 operator-(float f, const Vector2 &v) { return Vector2(f - v.x,...
    method Vector2 (line 87) | Vector2 operator*(float f, const Vector2 &v) { return Vector2(f * v.x,...
    method Vector2 (line 88) | Vector2 operator/(float f, const Vector2 &v) { return Vector2(f / v.x,...
  class C1 (line 97) | class C1 {}
  class C2 (line 98) | class C2 {}
  type HashMe (line 105) | struct HashMe {
  type std (line 116) | namespace std {
    type hash<Vector2> (line 118) | struct hash<Vector2> {
    type hash<HashMe> (line 125) | struct hash<HashMe> {
  function abs (line 133) | std::string abs(const Vector2 &) { return "abs(Vector2)"; }
  function TEST_SUBMODULE (line 150) | TEST_SUBMODULE(operators, m) {

FILE: tests/test_operator_overloading.py
  function test_operator_overloading (line 11) | def test_operator_overloading():
  function test_operators_notimplemented (line 94) | def test_operators_notimplemented():
  function test_nested (line 104) | def test_nested():
  function test_overriding_eq_reset_hash (line 142) | def test_overriding_eq_reset_hash():
  function test_return_set_of_unhashable (line 158) | def test_return_set_of_unhashable():

FILE: tests/test_pickling.cpp
  type exercise_trampoline (line 17) | namespace exercise_trampoline {
    type SimpleBase (line 19) | struct SimpleBase {
      method SimpleBase (line 24) | SimpleBase() = default;
      method SimpleBase (line 25) | SimpleBase(const SimpleBase &) = default;
    type SimpleBaseTrampoline (line 28) | struct SimpleBaseTrampoline : SimpleBase {}
    type SimpleCppDerived (line 30) | struct SimpleCppDerived : SimpleBase {}
    function wrap (line 32) | void wrap(py::module m) {
  function TEST_SUBMODULE (line 60) | TEST_SUBMODULE(pickling, m) {

FILE: tests/test_pickling.py
  function all_pickle_protocols (line 13) | def all_pickle_protocols():
  function test_pickle_simple_callable (line 19) | def test_pickle_simple_callable(protocol):
  function test_roundtrip (line 52) | def test_roundtrip(cls_name):
  function test_roundtrip_with_dict (line 79) | def test_roundtrip_with_dict(cls_name):
  function test_enum_pickle (line 92) | def test_enum_pickle():
  class SimplePyDerived (line 102) | class SimplePyDerived(m.SimpleBase):
  function test_roundtrip_simple_py_derived (line 106) | def test_roundtrip_simple_py_derived():
  function test_roundtrip_simple_cpp_derived (line 117) | def test_roundtrip_simple_cpp_derived():
  function test_new_style_pickle_getstate_pos_only (line 135) | def test_new_style_pickle_getstate_pos_only():

FILE: tests/test_potentially_slicing_weak_ptr.cpp
  type pybind11_tests (line 9) | namespace pybind11_tests {
    type potentially_slicing_weak_ptr (line 10) | namespace potentially_slicing_weak_ptr {
      type VirtBase (line 13) | struct VirtBase {
        method VirtBase (line 14) | VirtBase() = default;
        method VirtBase (line 16) | VirtBase(const VirtBase &) = delete;
        method get_code (line 17) | virtual int get_code() { return 100; }
      type trampoline_is_alive_simple (line 24) | struct trampoline_is_alive_simple {
        method trampoline_is_alive_simple (line 27) | trampoline_is_alive_simple() = default;
        method trampoline_is_alive_simple (line 31) | trampoline_is_alive_simple(const trampoline_is_alive_simple &other...
        method trampoline_is_alive_simple (line 32) | trampoline_is_alive_simple(trampoline_is_alive_simple &&other) noe...
        method trampoline_is_alive_simple (line 37) | trampoline_is_alive_simple &operator=(const trampoline_is_alive_si...
        method trampoline_is_alive_simple (line 38) | trampoline_is_alive_simple &operator=(trampoline_is_alive_simple &...
      type PyVirtBaseSH (line 59) | struct PyVirtBaseSH : VirtBaseSH, py::trampoline_self_life_support, ...
        method get_code (line 61) | int get_code() override { PYBIND11_OVERRIDE(int, VirtBaseSH, get_c...
      type PyVirtBaseSP (line 64) | struct PyVirtBaseSP : VirtBaseSP, trampoline_is_alive_simple { // se...
        method get_code (line 66) | int get_code() override { PYBIND11_OVERRIDE(int, VirtBaseSP, get_c...
      function rtrn_obj_cast_shared_ptr (line 70) | std::shared_ptr<VB> rtrn_obj_cast_shared_ptr(py::handle obj) {
      function rtrn_potentially_slicing_shared_ptr (line 77) | std::shared_ptr<VB> rtrn_potentially_slicing_shared_ptr(py::handle o...
      type SpOwner (line 82) | struct SpOwner {
        method set_sp (line 83) | void set_sp(const std::shared_ptr<VB> &sp_) { sp = sp_; }
        method get_code (line 85) | int get_code() const {
      type WpOwner (line 99) | struct WpOwner {
        method set_wp (line 100) | void set_wp(const std::weak_ptr<VB> &wp_) { wp = wp_; }
        method get_code (line 102) | int get_code() const {
      function wrap (line 117) | void wrap(py::module_ &m,
  function TEST_SUBMODULE (line 150) | TEST_SUBMODULE(potentially_slicing_weak_ptr, m) {

FILE: tests/test_potentially_slicing_weak_ptr.py
  class PyDrvdSH (line 43) | class PyDrvdSH(m.VirtBaseSH):
    method get_code (line 44) | def get_code(self):
  class PyDrvdSP (line 48) | class PyDrvdSP(m.VirtBaseSP):
    method get_code (line 49) | def get_code(self):
  function test_rtrn_obj_cast_shared_ptr (line 85) | def test_rtrn_obj_cast_shared_ptr(holder_kind, rtrn_kind, expected_code):
  function test_with_sp_owner (line 102) | def test_with_sp_owner(holder_kind, expected_code):
  function test_with_wp_owner (line 131) | def test_with_wp_owner(holder_kind, set_meth, expected_code):
  function test_potentially_slicing_weak_ptr_not_convertible_error (line 162) | def test_potentially_slicing_weak_ptr_not_convertible_error():

FILE: tests/test_python_multiple_inheritance.cpp
  type test_python_multiple_inheritance (line 3) | namespace test_python_multiple_inheritance {
    type CppBase (line 8) | struct CppBase {
      method CppBase (line 9) | explicit CppBase(int value) : base_value(value) {}
      method get_base_value (line 10) | int get_base_value() const { return base_value; }
      method reset_base_value (line 11) | void reset_base_value(int new_value) { base_value = new_value; }
    type CppDrvd (line 17) | struct CppDrvd : CppBase {
      method CppDrvd (line 18) | explicit CppDrvd(int value) : CppBase(value), drvd_value(value * 3) {}
      method get_drvd_value (line 19) | int get_drvd_value() const { return drvd_value; }
      method reset_drvd_value (line 20) | void reset_drvd_value(int new_value) { drvd_value = new_value; }
      method get_base_value_from_drvd (line 22) | int get_base_value_from_drvd() const { return get_base_value(); }
      method reset_base_value_from_drvd (line 23) | void reset_base_value_from_drvd(int new_value) { reset_base_value(ne...
  function TEST_SUBMODULE (line 31) | TEST_SUBMODULE(python_multiple_inheritance, m) {

FILE: tests/test_python_multiple_inheritance.py
  class PC (line 8) | class PC(m.CppBase):
  class PPCC (line 12) | class PPCC(PC, m.CppDrvd):
  function test_PC (line 16) | def test_PC():
  function test_PPCC (line 23) | def test_PPCC():

FILE: tests/test_pytypes.cpp
  type external (line 25) | namespace external {
    type detail (line 26) | namespace detail {
      function check (line 27) | bool check(PyObject *o) { return PyFloat_Check(o) != 0; }
      function PyObject (line 29) | PyObject *conv(PyObject *o) {
      function PyObject (line 42) | PyObject *default_constructed() { return PyFloat_FromDouble(0.0); }
    class float_ (line 44) | class float_ : public py::object {
      method float_ (line 47) | float_() : py::object(external::detail::default_constructed(), stole...
      method get_value (line 49) | double get_value() const { return PyFloat_AsDouble(this->ptr()); }
  type pybind11 (line 53) | namespace pybind11 {
    type detail (line 54) | namespace detail {
      type handle_type_name<external::float_> (line 56) | struct handle_type_name<external::float_> {
      type type_caster<RealNumber> (line 157) | struct type_caster<RealNumber> {
        method handle (line 160) | static handle cast(const RealNumber &number, return_value_policy, ...
        method load (line 164) | bool load(handle src, bool convert) {
    type detail (line 154) | namespace detail {
      type handle_type_name<external::float_> (line 56) | struct handle_type_name<external::float_> {
      type type_caster<RealNumber> (line 157) | struct type_caster<RealNumber> {
        method handle (line 160) | static handle cast(const RealNumber &number, return_value_policy, ...
        method load (line 164) | bool load(handle src, bool convert) {
  type implicit_conversion_from_0_to_handle (line 62) | namespace implicit_conversion_from_0_to_handle {
  function pure_compile_tests_for_handle_from_PyObject_pointers (line 68) | void pure_compile_tests_for_handle_from_PyObject_pointers() {
  type handle_from_move_only_type_with_operator_PyObject (line 86) | namespace handle_from_move_only_type_with_operator_PyObject {
    type operator_ncnst (line 90) | struct operator_ncnst {
      method operator_ncnst (line 91) | operator_ncnst() = default;
      method operator_ncnst (line 92) | operator_ncnst(operator_ncnst &&) = default;
    type operator_const (line 96) | struct operator_const {
      method operator_const (line 97) | operator_const() = default;
      method operator_const (line 98) | operator_const(operator_const &&) = default;
    function from_ncnst (line 102) | bool from_ncnst() {
    function from_const (line 108) | bool from_const() {
    function m_defs (line 114) | void m_defs(py::module_ &m) {
  type literals (line 122) | namespace literals {
    type Color (line 123) | enum Color { RED = 0, BLUE = 1 }
  type typevar (line 135) | namespace typevar {
  type RealNumber (line 149) | struct RealNumber {
  type pybind11 (line 153) | namespace pybind11 {
    type detail (line 54) | namespace detail {
      type handle_type_name<external::float_> (line 56) | struct handle_type_name<external::float_> {
      type type_caster<RealNumber> (line 157) | struct type_caster<RealNumber> {
        method handle (line 160) | static handle cast(const RealNumber &number, return_value_policy, ...
        method load (line 164) | bool load(handle src, bool convert) {
    type detail (line 154) | namespace detail {
      type handle_type_name<external::float_> (line 56) | struct handle_type_name<external::float_> {
      type type_caster<RealNumber> (line 157) | struct type_caster<RealNumber> {
        method handle (line 160) | static handle cast(const RealNumber &number, return_value_policy, ...
        method load (line 164) | bool load(handle src, bool convert) {
  function TEST_SUBMODULE (line 180) | TEST_SUBMODULE(pytypes, m) {

FILE: tests/test_pytypes.py
  function test_obj_class_name (line 14) | def test_obj_class_name():
  function test_handle_from_move_only_type_with_operator_PyObject (line 20) | def test_handle_from_move_only_type_with_operator_PyObject():
  function test_bool (line 25) | def test_bool(doc):
  function test_int (line 29) | def test_int(doc):
  function test_iterator (line 33) | def test_iterator(doc):
  function test_from_iterable (line 46) | def test_from_iterable(pytype, from_iter_func):
  function test_iterable (line 53) | def test_iterable(doc):
  function test_float (line 62) | def test_float(doc):
  function test_list (line 73) | def test_list(capture, doc):
  function test_none (line 106) | def test_none(doc):
  function test_set (line 111) | def test_set(capture, doc):
  function test_frozenset (line 143) | def test_frozenset(capture, doc):
  function test_dict (line 168) | def test_dict(capture, doc):
  class CustomContains (line 193) | class CustomContains:
    method __contains__ (line 196) | def __contains__(self, m):
  function test_unhashable_exceptions (line 208) | def test_unhashable_exceptions(arg, func):
  function test_tuple (line 217) | def test_tuple():
  function test_simple_namespace (line 224) | def test_simple_namespace():
  function test_str (line 232) | def test_str(doc):
  function test_surrogate_pairs_unicode_error (line 277) | def test_surrogate_pairs_unicode_error(func):
  function test_bytes (line 283) | def test_bytes(doc):
  function test_bytearray (line 292) | def test_bytearray():
  function test_capsule (line 299) | def test_capsule(capture):
  function test_accessors (line 388) | def test_accessors():
  function test_accessor_moves (line 427) | def test_accessor_moves():
  function test_constructors (line 436) | def test_constructors():
  function test_non_converting_constructors (line 473) | def test_non_converting_constructors():
  function test_pybind11_str_raw_str (line 490) | def test_pybind11_str_raw_str():
  function test_implicit_casting (line 528) | def test_implicit_casting():
  function test_print (line 548) | def test_print(capture):
  function test_hash (line 573) | def test_hash():
  function test_number_protocol (line 589) | def test_number_protocol():
  function test_list_slicing (line 611) | def test_list_slicing():
  function test_issue2361 (line 617) | def test_issue2361():
  function test_memoryview (line 636) | def test_memoryview(method, args, fmt, expected_view):
  function test_memoryview_refcount (line 651) | def test_memoryview_refcount(method):
  function test_memoryview_from_buffer_empty_shape (line 661) | def test_memoryview_from_buffer_empty_shape():
  function test_test_memoryview_from_buffer_invalid_strides (line 668) | def test_test_memoryview_from_buffer_invalid_strides():
  function test_test_memoryview_from_buffer_nullptr (line 673) | def test_test_memoryview_from_buffer_nullptr():
  function test_memoryview_from_memory (line 678) | def test_memoryview_from_memory():
  function test_builtin_functions (line 685) | def test_builtin_functions():
  function test_isinstance_string_types (line 695) | def test_isinstance_string_types():
  function test_pass_bytes_or_unicode_to_string_types (line 706) | def test_pass_bytes_or_unicode_to_string_types():
  function test_weakref (line 737) | def test_weakref(create_weakref, create_weakref_with_callback):
  function test_weakref_err (line 774) | def test_weakref_err(create_weakref, has_callback):
  function test_cpp_iterators (line 790) | def test_cpp_iterators():
  function test_implementation_details (line 796) | def test_implementation_details():
  function test_external_float_ (line 817) | def test_external_float_():
  function test_tuple_rvalue_getter (line 822) | def test_tuple_rvalue_getter():
  function test_list_rvalue_getter (line 828) | def test_list_rvalue_getter():
  function test_populate_dict_rvalue (line 834) | def test_populate_dict_rvalue():
  function test_populate_obj_str_attrs (line 840) | def test_populate_obj_str_attrs():
  function test_inplace_append (line 853) | def test_inplace_append(a, b):
  function test_inplace_subtract (line 861) | def test_inplace_subtract(a, b):
  function test_inplace_multiply (line 867) | def test_inplace_multiply(a, b):
  function test_inplace_divide (line 873) | def test_inplace_divide(a, b):
  function test_inplace_or (line 890) | def test_inplace_or(a, b):
  function test_inplace_and (line 907) | def test_inplace_and(a, b):
  function test_inplace_lshift (line 913) | def test_inplace_lshift(a, b):
  function test_inplace_rshift (line 919) | def test_inplace_rshift(a, b):
  function test_tuple_nonempty_annotations (line 924) | def test_tuple_nonempty_annotations(doc):
  function test_tuple_empty_annotations (line 931) | def test_tuple_empty_annotations(doc):
  function test_tuple_variable_length_annotations (line 937) | def test_tuple_variable_length_annotations(doc):
  function test_dict_annotations (line 944) | def test_dict_annotations(doc):
  function test_list_annotations (line 951) | def test_list_annotations(doc):
  function test_set_annotations (line 958) | def test_set_annotations(doc):
  function test_iterable_annotations (line 962) | def test_iterable_annotations(doc):
  function test_iterator_annotations (line 969) | def test_iterator_annotations(doc):
  function test_fn_annotations (line 976) | def test_fn_annotations(doc):
  function test_fn_return_only (line 983) | def test_fn_return_only(doc):
  function test_type_annotation (line 990) | def test_type_annotation(doc):
  function test_union_annotations (line 997) | def test_union_annotations(doc):
  function test_union_typing_only (line 1004) | def test_union_typing_only(doc):
  function test_union_object_annotations (line 1008) | def test_union_object_annotations(doc):
  function test_optional_annotations (line 1015) | def test_optional_annotations(doc):
  function test_type_guard_annotations (line 1021) | def test_type_guard_annotations(doc, backport_typehints):
  function test_type_is_annotations (line 1028) | def test_type_is_annotations(doc, backport_typehints):
  function test_no_return_annotation (line 1035) | def test_no_return_annotation(doc):
  function test_never_annotation (line 1039) | def test_never_annotation(doc, backport_typehints):
  function test_optional_object_annotations (line 1045) | def test_optional_object_annotations(doc):
  function test_literal (line 1056) | def test_literal(doc):
  function test_typevar (line 1100) | def test_typevar(doc):
  function test_tuple_ranges (line 1119) | def test_tuple_ranges(tested_tuple, expected):
  function test_list_ranges (line 1131) | def test_list_ranges(tested_list, expected):
  function test_dict_ranges (line 1148) | def test_dict_ranges(tested_dict, expected):
  function get_annotations_helper (line 1154) | def get_annotations_helper(o):
  function test_module_attribute_types (line 1168) | def test_module_attribute_types() -> None:
  function test_get_annotations_compliance (line 1192) | def test_get_annotations_compliance() -> None:
  function test_class_attribute_types (line 1208) | def test_class_attribute_types() -> None:
  function test_redeclaration_attr_with_type_hint (line 1246) | def test_redeclaration_attr_with_type_hint() -> None:
  function test_final_annotation (line 1263) | def test_final_annotation() -> None:
  function test_arg_return_type_hints (line 1268) | def test_arg_return_type_hints(doc, backport_typehints):
  function test_const_kwargs_ref_to_str (line 1372) | def test_const_kwargs_ref_to_str():

FILE: tests/test_scoped_critical_section.cpp
  type test_scoped_critical_section_ns (line 14) | namespace test_scoped_critical_section_ns {
    function test_one_nullptr (line 16) | void test_one_nullptr() { py::scoped_critical_section lock{py::handle{...
    function test_two_nullptrs (line 18) | void test_two_nullptrs() { py::scoped_critical_section lock{py::handle...
    function test_first_nullptr (line 20) | void test_first_nullptr() {
    function test_second_nullptr (line 25) | void test_second_nullptr() {
    class BoolWrapper (line 31) | class BoolWrapper {
      method BoolWrapper (line 33) | explicit BoolWrapper(bool value) : value_{value} {}
      method get (line 34) | bool get() const { return value_.load(std::memory_order_acquire); }
      method set (line 35) | void set(bool value) { value_.store(value, std::memory_order_release...
    function test_scoped_critical_section (line 48) | void test_scoped_critical_section(const py::handle &cls) {
    function test_scoped_critical_section2 (line 102) | void test_scoped_critical_section2(const py::handle &cls) {
    function test_scoped_critical_section2_same_object_no_deadlock (line 180) | void test_scoped_critical_section2_same_object_no_deadlock(const py::h...
    function test_scoped_critical_section (line 237) | void test_scoped_critical_section(const py::handle &) {}
    function test_scoped_critical_section2 (line 238) | void test_scoped_critical_section2(const py::handle &) {}
    function test_scoped_critical_section2_same_object_no_deadlock (line 239) | void test_scoped_critical_section2_same_object_no_deadlock(const py::h...
  function TEST_SUBMODULE (line 245) | TEST_SUBMODULE(scoped_critical_section, m) {

FILE: tests/test_scoped_critical_section.py
  function test_nullptr_combinations (line 8) | def test_nullptr_combinations():
  function test_scoped_critical_section (line 16) | def test_scoped_critical_section() -> None:
  function test_scoped_critical_section2 (line 22) | def test_scoped_critical_section2() -> None:
  function test_scoped_critical_section2_same_object_no_deadlock (line 28) | def test_scoped_critical_section2_same_object_no_deadlock() -> None:

FILE: tests/test_sequences_and_iterators.cpp
  class NonZeroIterator (line 26) | class NonZeroIterator {
    method NonZeroIterator (line 30) | explicit NonZeroIterator(const T *ptr) : ptr_(ptr) {}
    method NonZeroIterator (line 33) | NonZeroIterator(const NonZeroIterator &) = delete;
    method NonZeroIterator (line 34) | NonZeroIterator(NonZeroIterator &&) noexcept = default;
    method NonZeroIterator (line 35) | NonZeroIterator &operator=(const NonZeroIterator &) = delete;
    method NonZeroIterator (line 36) | NonZeroIterator &operator=(NonZeroIterator &&) noexcept = default;
    method T (line 38) | const T &operator*() const { return *ptr_; }
    method NonZeroIterator (line 39) | NonZeroIterator &operator++() {
  class NonZeroSentinel (line 45) | class NonZeroSentinel {}
  class NonRefIterator (line 54) | class NonRefIterator {
    method NonRefIterator (line 58) | explicit NonRefIterator(const T *ptr) : ptr_(ptr) {}
    method T (line 59) | T operator*() const { return T(*ptr_); }
    method NonRefIterator (line 60) | NonRefIterator &operator++() {
  class NonCopyableInt (line 67) | class NonCopyableInt {
    method NonCopyableInt (line 69) | explicit NonCopyableInt(int value) : value_(value) {}
    method NonCopyableInt (line 70) | NonCopyableInt(const NonCopyableInt &) = delete;
    method NonCopyableInt (line 71) | NonCopyableInt(NonCopyableInt &&other) noexcept : value_(other.value_) {
    method NonCopyableInt (line 74) | NonCopyableInt &operator=(const NonCopyableInt &) = delete;
    method NonCopyableInt (line 75) | NonCopyableInt &operator=(NonCopyableInt &&other) noexcept {
    method get (line 80) | int get() const { return value_; }
    method set (line 81) | void set(int value) { value_ = value; }
  function test_random_access_iterator (line 93) | py::list test_random_access_iterator(const PythonType &x) {
  function TEST_SUBMODULE (line 136) | TEST_SUBMODULE(sequences_and_iterators, m) {

FILE: tests/test_sequences_and_iterators.py
  function test_slice_constructors (line 13) | def test_slice_constructors():
  function test_slice_constructors_explicit_optional (line 19) | def test_slice_constructors_explicit_optional():
  function test_generalized_iterators (line 24) | def test_generalized_iterators():
  function test_nonref_iterators (line 49) | def test_nonref_iterators():
  function test_generalized_iterators_simple (line 56) | def test_generalized_iterators_simple():
  function test_iterator_doc_annotations (line 66) | def test_iterator_doc_annotations():
  function test_iterator_referencing (line 83) | def test_iterator_referencing():
  function test_sliceable (line 107) | def test_sliceable():
  function test_sequence (line 120) | def test_sequence():
  function test_sequence_length (line 184) | def test_sequence_length():
  function test_sequence_doc (line 204) | def test_sequence_doc():
  function test_map_iterator (line 211) | def test_map_iterator():
  function test_python_iterator_in_cpp (line 235) | def test_python_iterator_in_cpp():
  function test_iterator_passthrough (line 267) | def test_iterator_passthrough():
  function test_iterator_rvp (line 273) | def test_iterator_rvp():
  function test_carray_iterator (line 280) | def test_carray_iterator():
  function test_generated_dunder_methods_pos_only (line 288) | def test_generated_dunder_methods_pos_only():

FILE: tests/test_smart_ptr.cpp
  class huge_unique_ptr (line 23) | class huge_unique_ptr {
    method huge_unique_ptr (line 28) | explicit huge_unique_ptr(T *p) : ptr(p) {}
    method T (line 29) | T *get() { return ptr.get(); }
  class custom_unique_ptr (line 34) | class custom_unique_ptr {
    method custom_unique_ptr (line 38) | explicit custom_unique_ptr(T *p) : impl(p) {}
    method T (line 39) | T *get() const { return impl.get(); }
    method T (line 40) | T *release_ptr() { return impl.release(); }
  class shared_ptr_with_addressof_operator (line 47) | class shared_ptr_with_addressof_operator {
    method shared_ptr_with_addressof_operator (line 51) | shared_ptr_with_addressof_operator() = default;
    method shared_ptr_with_addressof_operator (line 52) | explicit shared_ptr_with_addressof_operator(T *p) : impl(p) {}
    method T (line 53) | T *get() const { return impl.get(); }
    method T (line 54) | T **operator&() { throw std::logic_error("Call of overloaded operator&...
  class unique_ptr_with_addressof_operator (line 61) | class unique_ptr_with_addressof_operator {
    method unique_ptr_with_addressof_operator (line 65) | unique_ptr_with_addressof_operator() = default;
    method unique_ptr_with_addressof_operator (line 66) | explicit unique_ptr_with_addressof_operator(T *p) : impl(p) {}
    method T (line 67) | T *get() const { return impl.get(); }
    method T (line 68) | T *release_ptr() { return impl.release(); }
    method T (line 69) | T **operator&() { throw std::logic_error("Call of overloaded operator&...
  class const_only_shared_ptr (line 74) | class const_only_shared_ptr {
    method const_only_shared_ptr (line 78) | const_only_shared_ptr() = default;
    method const_only_shared_ptr (line 79) | explicit const_only_shared_ptr(const T *ptr) : ptr_(ptr) {}
    method T (line 80) | const T *get() const { return ptr_.get(); }
  class MyObject1 (line 87) | class MyObject1 : public Object {
    method MyObject1 (line 89) | explicit MyObject1(int value) : value(value) { print_created(this, toS...
    method toString (line 90) | std::string toString() const override { return "MyObject1[" + std::to_...
  class MyObject2 (line 100) | class MyObject2 {
    method MyObject2 (line 102) | MyObject2(const MyObject2 &) = default;
    method MyObject2 (line 103) | explicit MyObject2(int value) : value(value) { print_created(this, toS...
    method toString (line 104) | std::string toString() const { return "MyObject2[" + std::to_string(va...
  class MyObject3 (line 112) | class MyObject3 : public std::enable_shared_from_this<MyObject3> {
    method MyObject3 (line 114) | MyObject3(const MyObject3 &) = default;
    method MyObject3 (line 115) | explicit MyObject3(int value) : value(value) { print_created(this, toS...
    method toString (line 116) | std::string toString() const { return "MyObject3[" + std::to_string(va...
  class MyObject4 (line 132) | class MyObject4 {
    method MyObject4 (line 134) | explicit MyObject4(int value) : value{value} {
    method cleanupAllInstances (line 140) | static void cleanupAllInstances() {
  class MyObject4a (line 158) | class MyObject4a {
    method MyObject4a (line 160) | explicit MyObject4a(int i) : value{i} {
    method MyObject4a (line 164) | MyObject4a(const MyObject4a &) = delete;
    method cleanupAllInstances (line 168) | static void cleanupAllInstances() {
  class MyObject4b (line 184) | class MyObject4b : public MyObject4a {
    method MyObject4b (line 186) | explicit MyObject4b(int i) : MyObject4a(i) { print_created(this); }
    method MyObject4b (line 187) | MyObject4b(const MyObject4b &) = delete;
  class MyObject5 (line 192) | class MyObject5 { // managed by huge_unique_ptr
    method MyObject5 (line 194) | explicit MyObject5(int value) : value{value} { print_created(this); }
    method MyObject5 (line 195) | MyObject5(const MyObject5 &) = delete;
  class MyObject6 (line 201) | class MyObject6 {
    method createObject (line 203) | static const_only_shared_ptr<MyObject6> createObject(std::string value) {
    method MyObject6 (line 210) | explicit MyObject6(std::string &&value) : value_{std::move(value)} {}
  type SharedPtrRef (line 215) | struct SharedPtrRef {
    type A (line 216) | struct A {
      method A (line 217) | A() { print_created(this); }
      method A (line 218) | A(const A &) { print_copy_created(this); }
      method A (line 219) | A(A &&) noexcept { print_move_created(this); }
  type SharedFromThisRef (line 228) | struct SharedFromThisRef {
    type B (line 229) | struct B : std::enable_shared_from_this<B> {
      method B (line 230) | B() { print_created(this); }
      method B (line 232) | B(const B &) : std::enable_shared_from_this<B>() { print_copy_create...
      method B (line 234) | B(B &&) noexcept : std::enable_shared_from_this<B>() { print_move_cr...
  type SharedFromThisVBase (line 243) | struct SharedFromThisVBase : std::enable_shared_from_this<SharedFromThis...
    method SharedFromThisVBase (line 244) | SharedFromThisVBase() = default;
    method SharedFromThisVBase (line 245) | SharedFromThisVBase(const SharedFromThisVBase &) = default;
  type SharedFromThisVirt (line 248) | struct SharedFromThisVirt : virtual SharedFromThisVBase {}
  type C (line 251) | struct C {
    method C (line 252) | C() { print_created(this); }
    method C (line 253) | C(const C &) = delete;
  type TypeForHolderWithAddressOf (line 258) | struct TypeForHolderWithAddressOf {
    method TypeForHolderWithAddressOf (line 259) | TypeForHolderWithAddressOf() { print_created(this); }
    method TypeForHolderWithAddressOf (line 260) | TypeForHolderWithAddressOf(const TypeForHolderWithAddressOf &) { print...
    method TypeForHolderWithAddressOf (line 261) | TypeForHolderWithAddressOf(TypeForHolderWithAddressOf &&) noexcept {
    method toString (line 265) | std::string toString() const {
  type TypeForMoveOnlyHolderWithAddressOf (line 272) | struct TypeForMoveOnlyHolderWithAddressOf {
    method TypeForMoveOnlyHolderWithAddressOf (line 273) | explicit TypeForMoveOnlyHolderWithAddressOf(int value) : value{value} ...
    method TypeForMoveOnlyHolderWithAddressOf (line 274) | TypeForMoveOnlyHolderWithAddressOf(const TypeForMoveOnlyHolderWithAddr...
    method toString (line 276) | std::string toString() const {
  type HeldByDefaultHolder (line 283) | struct HeldByDefaultHolder {}
  type ElementBase (line 287) | struct ElementBase {
    method ElementBase (line 289) | ElementBase() = default;
    method ElementBase (line 290) | ElementBase(const ElementBase &) = delete;
  type ElementA (line 293) | struct ElementA : ElementBase {
    method ElementA (line 294) | explicit ElementA(int v) : v(v) {}
    method value (line 295) | int value() const { return v; }
  type ElementList (line 299) | struct ElementList {
    method add (line 300) | void add(const std::shared_ptr<ElementBase> &e) { l.push_back(e); }
  type PYBIND11_NAMESPACE (line 310) | namespace PYBIND11_NAMESPACE {
    type detail (line 311) | namespace detail {
      type holder_helper<ref<T>> (line 313) | struct holder_helper<ref<T>> {
        method T (line 314) | static const T *get(const ref<T> &p) { return p.get_ptr(); }
  type holder_caster_traits_test (line 329) | namespace holder_caster_traits_test {
    type example_base (line 330) | struct example_base {}
    type example_drvd (line 383) | struct example_drvd : example_base {}
    function wrap (line 385) | void wrap(py::module_ &m) {
  type copyable_holder_caster_shared_ptr_with_smart_holder_support_enabled<
    ExampleType,
    enable_if_t<std::is_base_of<holder_caster_traits_test::example_base, ExampleType>::value>> (line 339) | struct copyable_holder_caster_shared_ptr_with_smart_holder_support_enabled<
  type copyable_holder_caster<
    ExampleType,
    HolderType,
    enable_if_t<std::is_base_of<holder_caster_traits_test::example_base, ExampleType>::value>> (line 346) | struct copyable_holder_caster<
    method handle (line 352) | static handle cast(const HolderType &, return_value_policy, handle) {
  type move_only_holder_caster_unique_ptr_with_smart_holder_support_enabled<
    ExampleType,
    enable_if_t<std::is_base_of<holder_caster_traits_test::example_base, ExampleType>::value>> (line 360) | struct move_only_holder_caster_unique_ptr_with_smart_holder_support_enab...
  type move_only_holder_caster<
    ExampleType,
    HolderType,
    enable_if_t<std::is_base_of<holder_caster_traits_test::example_base, ExampleType>::value>> (line 367) | struct move_only_holder_caster<
    method handle (line 373) | static handle cast(const HolderType &, return_value_policy, handle) {
  type holder_caster_traits_test (line 381) | namespace holder_caster_traits_test {
    type example_base (line 330) | struct example_base {}
    type example_drvd (line 383) | struct example_drvd : example_base {}
    function wrap (line 385) | void wrap(py::module_ &m) {
  function TEST_SUBMODULE (line 395) | TEST_SUBMODULE(smart_ptr, m) {

FILE: tests/test_smart_ptr.py
  function test_smart_ptr (line 12) | def test_smart_ptr(capture):
  function test_smart_ptr_refcounting (line 120) | def test_smart_ptr_refcounting():
  function test_unique_nodelete (line 125) | def test_unique_nodelete():
  function test_unique_nodelete4a (line 137) | def test_unique_nodelete4a():
  function test_unique_deleter (line 149) | def test_unique_deleter():
  function test_large_holder (line 166) | def test_large_holder():
  function test_shared_ptr_and_references (line 176) | def test_shared_ptr_and_references():
  function test_shared_ptr_from_this_and_references (line 208) | def test_shared_ptr_from_this_and_references():
  function test_move_only_holder (line 255) | def test_move_only_holder():
  function test_holder_with_addressof_operator (line 267) | def test_holder_with_addressof_operator():
  function test_move_only_holder_with_addressof_operator (line 298) | def test_move_only_holder_with_addressof_operator():
  function test_smart_ptr_from_default (line 312) | def test_smart_ptr_from_default():
  function test_shared_ptr_gc (line 321) | def test_shared_ptr_gc():
  function test_private_esft_tolerance (line 331) | def test_private_esft_tolerance():
  function test_copyable_holder_caster_shared_ptr_with_smart_holder_support_enabled (line 343) | def test_copyable_holder_caster_shared_ptr_with_smart_holder_support_ena...
  function test_move_only_holder_caster_shared_ptr_with_smart_holder_support_enabled (line 349) | def test_move_only_holder_caster_shared_ptr_with_smart_holder_support_en...
  function test_const_only_holder (line 355) | def test_const_only_holder():

FILE: tests/test_stl.cpp
  type PYBIND11_NAMESPACE (line 27) | namespace PYBIND11_NAMESPACE {
    type detail (line 28) | namespace detail {
      type type_caster<boost::optional<T>> (line 30) | struct type_caster<boost::optional<T>> : optional_caster<boost::opti...
      type type_caster<boost::none_t> (line 33) | struct type_caster<boost::none_t> : void_caster<boost::none_t> {}
      type visit_helper<boost::variant> (line 53) | struct visit_helper<boost::variant> {
        method call (line 55) | static auto call(Args &&...args) -> decltype(boost::apply_visitor(...
      type type_caster<ReferenceSensitiveOptional<T>> (line 167) | struct type_caster<ReferenceSensitiveOptional<T>>
    type detail (line 48) | namespace detail {
      type type_caster<boost::optional<T>> (line 30) | struct type_caster<boost::optional<T>> : optional_caster<boost::opti...
      type type_caster<boost::none_t> (line 33) | struct type_caster<boost::none_t> : void_caster<boost::none_t> {}
      type visit_helper<boost::variant> (line 53) | struct visit_helper<boost::variant> {
        method call (line 55) | static auto call(Args &&...args) -> decltype(boost::apply_visitor(...
      type type_caster<ReferenceSensitiveOptional<T>> (line 167) | struct type_caster<ReferenceSensitiveOptional<T>>
    type detail (line 165) | namespace detail {
      type type_caster<boost::optional<T>> (line 30) | struct type_caster<boost::optional<T>> : optional_caster<boost::opti...
      type type_caster<boost::none_t> (line 33) | struct type_caster<boost::none_t> : void_caster<boost::none_t> {}
      type visit_helper<boost::variant> (line 53) | struct visit_helper<boost::variant> {
        method call (line 55) | static auto call(Args &&...args) -> decltype(boost::apply_visitor(...
      type type_caster<ReferenceSensitiveOptional<T>> (line 167) | struct type_caster<ReferenceSensitiveOptional<T>>
  type PYBIND11_NAMESPACE (line 47) | namespace PYBIND11_NAMESPACE {
    type detail (line 28) | namespace detail {
      type type_caster<boost::optional<T>> (line 30) | struct type_caster<boost::optional<T>> : optional_caster<boost::opti...
      type type_caster<boost::none_t> (line 33) | struct type_caster<boost::none_t> : void_caster<boost::none_t> {}
      type visit_helper<boost::variant> (line 53) | struct visit_helper<boost::variant> {
        method call (line 55) | static auto call(Args &&...args) -> decltype(boost::apply_visitor(...
      type type_caster<ReferenceSensitiveOptional<T>> (line 167) | struct type_caster<ReferenceSensitiveOptional<T>>
    type detail (line 48) | namespace detail {
      type type_caster<boost::optional<T>> (line 30) | struct type_caster<boost::optional<T>> : optional_caster<boost::opti...
      type type_caster<boost::none_t> (line 33) | struct type_caster<boost::none_t> : void_caster<boost::none_t> {}
      type visit_helper<boost::variant> (line 53) | struct visit_helper<boost::variant> {
        method call (line 55) | static auto call(Args &&...args) -> decltype(boost::apply_visitor(...
      type type_caster<ReferenceSensitiveOptional<T>> (line 167) | struct type_caster<ReferenceSensitiveOptional<T>>
    type detail (line 165) | namespace detail {
      type type_caster<boost::optional<T>> (line 30) | struct type_caster<boost::optional<T>> : optional_caster<boost::opti...
      type type_caster<boost::none_t> (line 33) | struct type_caster<boost::none_t> : void_caster<boost::none_t> {}
      type visit_helper<boost::variant> (line 53) | struct visit_helper<boost::variant> {
        method call (line 55) | static auto call(Args &&...args) -> decltype(boost::apply_visitor(...
      type type_caster<ReferenceSensitiveOptional<T>> (line 167) | struct type_caster<ReferenceSensitiveOptional<T>>
  type type_caster<boost::variant<Ts...>> (line 50) | struct type_caster<boost::variant<Ts...>> : variant_caster<boost::varian...
  type TplCtorClass (line 66) | struct TplCtorClass {
    method TplCtorClass (line 68) | explicit TplCtorClass(const T &) {}
  type std (line 72) | namespace std {
    type hash<TplCtorClass> (line 74) | struct hash<TplCtorClass> {
  type OptionalHolder (line 80) | struct OptionalHolder {
    method OptionalHolder (line 82) | OptionalHolder() {}
    method member_initialized (line 83) | bool member_initialized() const { return member && member->initialized; }
  type EnumType (line 87) | enum class EnumType {
  class OptionalProperties (line 97) | class OptionalProperties {
    method OptionalProperties (line 101) | OptionalProperties() : value(EnumType::kSet) {}
    method OptionalProperties (line 102) | OptionalProperties(const OptionalProperties &) = default;
    method OptionalEnumValue (line 110) | OptionalEnumValue &access_by_ref() { return value; }
    method OptionalEnumValue (line 111) | OptionalEnumValue access_by_copy() { return value; }
  class ReferenceSensitiveOptional (line 124) | class ReferenceSensitiveOptional {
    method ReferenceSensitiveOptional (line 128) | ReferenceSensitiveOptional() = default;
    method ReferenceSensitiveOptional (line 130) | ReferenceSensitiveOptional(const T &value) : storage{value} {}
    method ReferenceSensitiveOptional (line 132) | ReferenceSensitiveOptional(T &&value) : storage{std::move(value)} {}
    method ReferenceSensitiveOptional (line 133) | ReferenceSensitiveOptional &operator=(const T &value) {
    method ReferenceSensitiveOptional (line 137) | ReferenceSensitiveOptional &operator=(T &&value) {
    method T (line 143) | T &emplace(Args &&...args) {
    method T (line 149) | const T &value() const noexcept {
    method T (line 154) | const T &operator*() const noexcept { return value(); }
    method T (line 156) | const T *operator->() const noexcept { return &value(); }
  type PYBIND11_NAMESPACE (line 164) | namespace PYBIND11_NAMESPACE {
    type detail (line 28) | namespace detail {
      type type_caster<boost::optional<T>> (line 30) | struct type_caster<boost::optional<T>> : optional_caster<boost::opti...
      type type_caster<boost::none_t> (line 33) | struct type_caster<boost::none_t> : void_caster<boost::none_t> {}
      type visit_helper<boost::variant> (line 53) | struct visit_helper<boost::variant> {
        method call (line 55) | static auto call(Args &&...args) -> decltype(boost::apply_visitor(...
      type type_caster<ReferenceSensitiveOptional<T>> (line 167) | struct type_caster<ReferenceSensitiveOptional<T>>
    type detail (line 48) | namespace detail {
      type type_caster<boost::optional<T>> (line 30) | struct type_caster<boost::optional<T>> : optional_caster<boost::opti...
      type type_caster<boost::none_t> (line 33) | struct type_caster<boost::none_t> : void_caster<boost::none_t> {}
      type visit_helper<boost::variant> (line 53) | struct visit_helper<boost::variant> {
        method call (line 55) | static auto call(Args &&...args) -> decltype(boost::apply_visitor(...
      type type_caster<ReferenceSensitiveOptional<T>> (line 167) | struct type_caster<ReferenceSensitiveOptional<T>>
    type detail (line 165) | namespace detail {
      type type_caster<boost::optional<T>> (line 30) | struct type_caster<boost::optional<T>> : optional_caster<boost::opti...
      type type_caster<boost::none_t> (line 33) | struct type_caster<boost::none_t> : void_caster<boost::none_t> {}
      type visit_helper<boost::variant> (line 53) | struct visit_helper<boost::variant> {
        method call (line 55) | static auto call(Args &&...args) -> decltype(boost::apply_visitor(...
      type type_caster<ReferenceSensitiveOptional<T>> (line 167) | struct type_caster<ReferenceSensitiveOptional<T>>
  function pass_std_vector_int (line 172) | int pass_std_vector_int(const std::vector<int> &v) {
  function TEST_SUBMODULE (line 180) | TEST_SUBMODULE(stl, m) {

FILE: tests/test_stl.py
  function test_vector (line 10) | def test_vector(doc):
  function test_deque (line 32) | def test_deque():
  function test_array (line 41) | def test_array(doc):
  function test_array_no_default_ctor (line 58) | def test_array_no_default_ctor():
  function test_valarray (line 65) | def test_valarray(doc):
  function test_map (line 79) | def test_map(doc):
  function test_set (line 94) | def test_set(doc):
  function test_recursive_casting (line 106) | def test_recursive_casting():
  function test_move_out_container (line 126) | def test_move_out_container():
  function test_optional (line 137) | def test_optional():
  function test_exp_optional (line 171) | def test_exp_optional():
  function test_boost_optional (line 201) | def test_boost_optional():
  function test_reference_sensitive_optional (line 230) | def test_reference_sensitive_optional(doc):
  function test_fs_path (line 265) | def test_fs_path():
  function test_path_typing (line 308) | def test_path_typing(doc):
  function test_variant (line 342) | def test_variant(doc):
  function test_variant_monostate (line 362) | def test_variant_monostate(doc):
  function test_vec_of_reference_wrapper (line 375) | def test_vec_of_reference_wrapper():
  function test_stl_pass_by_pointer (line 383) | def test_stl_pass_by_pointer(msg):
  function test_missing_header_message (line 412) | def test_missing_header_message():
  function test_function_with_string_and_vector_string_arg (line 433) | def test_function_with_string_and_vector_string_arg():
  function test_stl_ownership (line 442) | def test_stl_ownership():
  function test_array_cast_sequence (line 451) | def test_array_cast_sequence():
  function test_issue_1561 (line 455) | def test_issue_1561():
  function test_return_vector_bool_raw_ptr (line 463) | def test_return_vector_bool_raw_ptr():
  function test_pass_std_vector_int (line 473) | def test_pass_std_vector_int(fn, offset):
  function test_pass_std_vector_pair_int (line 486) | def test_pass_std_vector_pair_int():
  function test_list_caster_fully_consumes_generator_object (line 492) | def test_list_caster_fully_consumes_generator_object():
  function test_pass_std_set_int (line 502) | def test_pass_std_set_int():
  function test_set_caster_dict_keys_failure (line 516) | def test_set_caster_dict_keys_failure():
  class FakePyMappingMissingItems (line 528) | class FakePyMappingMissingItems:
    method __getitem__ (line 529) | def __getitem__(self, _):
  class FakePyMappingWithItems (line 533) | class FakePyMappingWithItems(FakePyMappingMissingItems):
    method items (line 534) | def items(self):
  class FakePyMappingBadItems (line 538) | class FakePyMappingBadItems(FakePyMappingMissingItems):
    method items (line 539) | def items(self):
  class FakePyMappingItemsNotCallable (line 543) | class FakePyMappingItemsNotCallable(FakePyMappingMissingItems):
    method items (line 545) | def items(self):
  class FakePyMappingItemsWithArg (line 549) | class FakePyMappingItemsWithArg(FakePyMappingMissingItems):
    method items (line 550) | def items(self, _):
  class FakePyMappingGenObj (line 554) | class FakePyMappingGenObj(FakePyMappingMissingItems):
    method __init__ (line 555) | def __init__(self, gen_obj):
    method items (line 559) | def items(self):
  function test_pass_std_map_int (line 563) | def test_pass_std_map_int():
  function test_map_caster_fully_consumes_generator_object (line 586) | def test_map_caster_fully_consumes_generator_object(items, expected_exce...
  function test_sequence_caster_protocol (line 596) | def test_sequence_caster_protocol(doc):
  function test_mapping_caster_protocol (line 645) | def test_mapping_caster_protocol(doc):
  function test_set_caster_protocol (line 692) | def test_set_caster_protocol(doc):

FILE: tests/test_stl_binders.cpp
  class El (line 20) | class El {
    method El (line 22) | El() = delete;
    method El (line 23) | explicit El(int v) : a(v) {}
  class E_nc (line 34) | class E_nc {
    method E_nc (line 36) | explicit E_nc(int i) : value{i} {}
    method E_nc (line 37) | E_nc(const E_nc &) = delete;
    method E_nc (line 38) | E_nc &operator=(const E_nc &) = delete;
    method E_nc (line 39) | E_nc(E_nc &&) = default;
    method E_nc (line 40) | E_nc &operator=(E_nc &&) = default;
  function Container (line 46) | Container *one_to_n(int n) {
  function Map (line 55) | Map *times_ten(int n) {
  function NestMap (line 64) | NestMap *times_hundred(int n) {
  type RecursiveVector (line 77) | struct RecursiveVector : std::vector<RecursiveVector> {
  type RecursiveMap (line 82) | struct RecursiveMap : std::map<int, RecursiveMap> {
  class UserVectorLike (line 87) | class UserVectorLike : private std::vector<int> {
  class UserMapLike (line 122) | class UserMapLike : private std::map<int, int> {
  type MutuallyRecursiveContainerPairMV (line 158) | struct MutuallyRecursiveContainerPairMV
  type MutuallyRecursiveContainerPairVM (line 159) | struct MutuallyRecursiveContainerPairVM
  type MutuallyRecursiveContainerPairMV (line 161) | struct MutuallyRecursiveContainerPairMV : std::map<int, MutuallyRecursiv...
  type MutuallyRecursiveContainerPairVM (line 162) | struct MutuallyRecursiveContainerPairVM : std::vector<MutuallyRecursiveC...
  type pybind11 (line 164) | namespace pybind11 {
    type detail (line 165) | namespace detail {
      type recursive_container_traits<MutuallyRecursiveContainerPairMV, SFINAE> (line 167) | struct recursive_container_traits<MutuallyRecursiveContainerPairMV, ...
      type recursive_container_traits<MutuallyRecursiveContainerPairVM, SFINAE> (line 171) | struct recursive_container_traits<MutuallyRecursiveContainerPairVM, ...
  function TEST_SUBMODULE (line 177) | TEST_SUBMODULE(stl_binders, m) {

FILE: tests/test_stl_binders.py
  function test_vector_int (line 8) | def test_vector_int():
  function test_vector_buffer (line 71) | def test_vector_buffer():
  function test_vector_buffer_numpy (line 90) | def test_vector_buffer_numpy():
  function test_vector_bool (line 129) | def test_vector_bool():
  function test_vector_custom (line 140) | def test_vector_custom():
  function test_map_string_double (line 152) | def test_map_string_double():
  function test_map_string_double_const (line 198) | def test_map_string_double_const():
  function test_noncopyable_containers (line 211) | def test_noncopyable_containers():
  function test_map_delitem (line 294) | def test_map_delitem():
  function test_map_view_types (line 335) | def test_map_view_types():
  function test_recursive_vector (line 385) | def test_recursive_vector():
  function test_recursive_map (line 395) | def test_recursive_map():
  function test_user_vector_like (line 403) | def test_user_vector_like():
  function test_user_like_map (line 410) | def test_user_like_map():

FILE: tests/test_tagbased_polymorphic.cpp
  type Animal (line 14) | struct Animal {
    method Animal (line 20) | Animal(const Animal &) = delete;
    type Kind (line 23) | enum class Kind {
    method Animal (line 40) | Animal(const std::string &_name, Kind _kind) : kind(_kind), name(_name...
  type Dog (line 43) | struct Dog : Animal {
    method Dog (line 44) | explicit Dog(const std::string &_name, Kind _kind = Kind::Dog) : Anima...
    method bark (line 45) | std::string bark() const { return name_of_kind(kind) + " " + name + " ...
  type Labrador (line 49) | struct Labrador : Dog {
    method Labrador (line 50) | explicit Labrador(const std::string &_name, int _excitement = 9001)
  type Chihuahua (line 55) | struct Chihuahua : Dog {
    method Chihuahua (line 56) | explicit Chihuahua(const std::string &_name) : Dog(_name, Kind::Chihua...
    method bark (line 59) | std::string bark() const { return Dog::bark() + " and runs in circles"; }
  type Cat (line 62) | struct Cat : Animal {
    method Cat (line 63) | explicit Cat(const std::string &_name, Kind _kind = Kind::Cat) : Anima...
    method purr (line 64) | std::string purr() const { return "mrowr"; }
  type Panther (line 67) | struct Panther : Cat {
    method Panther (line 68) | explicit Panther(const std::string &_name) : Cat(_name, Kind::Panther) {}
    method purr (line 69) | std::string purr() const { return "mrrrRRRRRR"; }
  function create_zoo (line 72) | std::vector<std::unique_ptr<Animal>> create_zoo() {
  type PYBIND11_NAMESPACE (line 123) | namespace PYBIND11_NAMESPACE {
    type polymorphic_type_hook<itype, detail::enable_if_t<std::is_base_of<Animal, itype>::value>> (line 125) | struct polymorphic_type_hook<itype, detail::enable_if_t<std::is_base_o...
  function TEST_SUBMODULE (line 133) | TEST_SUBMODULE(tagbased_polymorphic, m) {

FILE: tests/test_tagbased_polymorphic.py
  function test_downcast (line 6) | def test_downcast():

FILE: tests/test_thread.cpp
  type IntStruct (line 26) | struct IntStruct {
    method IntStruct (line 27) | explicit IntStruct(int v) : value(v) {}
    method IntStruct (line 29) | IntStruct(const IntStruct &) = default;
    method IntStruct (line 30) | IntStruct &operator=(const IntStruct &) = default;
  type EmptyStruct (line 35) | struct EmptyStruct {}
  function TEST_SUBMODULE (line 40) | TEST_SUBMODULE(thread, m) {

FILE: tests/test_thread.py
  class Thread (line 12) | class Thread(threading.Thread):
    method __init__ (line 13) | def __init__(self, fn):
    method run (line 18) | def run(self):
    method join (line 25) | def join(self):
  function test_implicit_conversion (line 32) | def test_implicit_conversion():
  function test_implicit_conversion_no_gil (line 43) | def test_implicit_conversion_no_gil():
  function test_bind_shared_instance (line 54) | def test_bind_shared_instance():
  function test_pythread_state_clear_destructor (line 75) | def test_pythread_state_clear_destructor():

FILE: tests/test_type_caster_pyobject_ptr.cpp
  function make_vector_pyobject_ptr (line 13) | std::vector<PyObject *> make_vector_pyobject_ptr(const py::object &Value...
  type WithPyObjectPtrReturn (line 22) | struct WithPyObjectPtrReturn {
    method WithPyObjectPtrReturn (line 24) | WithPyObjectPtrReturn() = default;
    method WithPyObjectPtrReturn (line 25) | WithPyObjectPtrReturn(const WithPyObjectPtrReturn &) = default;
  function PyObject (line 32) | PyObject *return_pyobject_ptr() const override {
  function TEST_SUBMODULE (line 53) | TEST_SUBMODULE(type_caster_pyobject_ptr, m) {

FILE: tests/test_type_caster_pyobject_ptr.py
  class ValueHolder (line 9) | class ValueHolder:
    method __init__ (line 10) | def __init__(self, value):
  function test_cast_from_pyobject_ptr (line 14) | def test_cast_from_pyobject_ptr():
  function test_cast_handle_to_pyobject_ptr (line 18) | def test_cast_handle_to_pyobject_ptr():
  function test_cast_object_to_pyobject_ptr (line 22) | def test_cast_object_to_pyobject_ptr():
  function test_cast_list_to_pyobject_ptr (line 26) | def test_cast_list_to_pyobject_ptr():
  function test_return_pyobject_ptr (line 30) | def test_return_pyobject_ptr():
  function test_pass_pyobject_ptr (line 34) | def test_pass_pyobject_ptr():
  function test_call_callback_with_object_return (line 45) | def test_call_callback_with_object_return(call_callback):
  function test_call_callback_with_pyobject_ptr_arg (line 57) | def test_call_callback_with_pyobject_ptr_arg():
  function test_cast_to_python_nullptr (line 65) | def test_cast_to_python_nullptr(set_error):
  function test_cast_to_python_non_nullptr_with_error_set (line 77) | def test_cast_to_python_non_nullptr_with_error_set():
  function test_pass_list_pyobject_ptr (line 84) | def test_pass_list_pyobject_ptr():
  function test_return_list_pyobject_ptr_take_ownership (line 89) | def test_return_list_pyobject_ptr_take_ownership():
  function test_return_list_pyobject_ptr_reference (line 94) | def test_return_list_pyobject_ptr_reference():
  function test_type_caster_name_via_incompatible_function_arguments_type_error (line 104) | def test_type_caster_name_via_incompatible_function_arguments_type_error():
  function test_trampoline_with_pyobject_ptr_return (line 112) | def test_trampoline_with_pyobject_ptr_return():

FILE: tests/test_type_caster_std_function_specializations.cpp
  type SpecialReturn (line 10) | struct SpecialReturn {
  type pybind11 (line 16) | namespace pybind11 {
    type detail (line 17) | namespace detail {
      type type_caster_std_function_specializations (line 18) | namespace type_caster_std_function_specializations {
  type func_wrapper<SpecialReturn, Args...> (line 21) | struct func_wrapper<SpecialReturn, Args...> : func_wrapper_base {
    method SpecialReturn (line 23) | SpecialReturn operator()(Args... args) const {
  function TEST_SUBMODULE (line 40) | TEST_SUBMODULE(type_caster_std_function_specializations, m) {

FILE: tests/test_type_caster_std_function_specializations.py
  function test_callback_with_special_return (line 6) | def test_callback_with_special_return():

FILE: tests/test_union.cpp
  function TEST_SUBMODULE (line 12) | TEST_SUBMODULE(union_, m) {

FILE: tests/test_union.py
  function test_union (line 6) | def test_union():

FILE: tests/test_unnamed_namespace_a.cpp
  type any_struct (line 4) | struct any_struct {}
  function TEST_SUBMODULE (line 7) | TEST_SUBMODULE(unnamed_namespace_a, m) {

FILE: tests/test_unnamed_namespace_a.py
  function test_have_class_any_struct (line 19) | def test_have_class_any_struct(any_struct):
  function test_have_at_least_one_class_any_struct (line 23) | def test_have_at_least_one_class_any_struct():
  function test_have_both_class_any_struct (line 31) | def test_have_both_class_any_struct():

FILE: tests/test_unnamed_namespace_b.cpp
  type any_struct (line 4) | struct any_struct {}
  function TEST_SUBMODULE (line 7) | TEST_SUBMODULE(unnamed_namespace_b, m) {

FILE: tests/test_unnamed_namespace_b.py
  function test_have_attr_any_struct (line 6) | def test_have_attr_any_struct():

FILE: tests/test_vector_unique_ptr_member.cpp
  type pybind11_tests (line 7) | namespace pybind11_tests {
    type vector_unique_ptr_member (line 8) | namespace vector_unique_ptr_member {
      type DataType (line 10) | struct DataType {}
      type VectorOwner (line 13) | struct VectorOwner {
        method Create (line 14) | static std::unique_ptr<VectorOwner> Create(std::size_t num_elems) {
        method data_size (line 19) | std::size_t data_size() const { return data_.size(); }
        method VectorOwner (line 22) | explicit VectorOwner(std::vector<std::unique_ptr<DataType>> data) ...
  type pybind11 (line 30) | namespace pybind11 {
    type detail (line 31) | namespace detail {
      type is_copy_constructible<pybind11_tests::vector_unique_ptr_member::VectorOwner> (line 34) | struct is_copy_constructible<pybind11_tests::vector_unique_ptr_membe...
      type is_move_constructible<pybind11_tests::vector_unique_ptr_member::VectorOwner> (line 38) | struct is_move_constructible<pybind11_tests::vector_unique_ptr_membe...
  function py_cast_VectorOwner_ptr (line 46) | py::object py_cast_VectorOwner_ptr(VectorOwner *ptr) { return py::cast(p...
  function TEST_SUBMODULE (line 48) | TEST_SUBMODULE(vector_unique_ptr_member, m) {

FILE: tests/test_vector_unique_ptr_member.py
  function test_create (line 9) | def test_create(num_elems):
  function test_cast (line 14) | def test_cast():

FILE: tests/test_virtual_functions.cpp
  class ExampleVirt (line 18) | class ExampleVirt {
    method ExampleVirt (line 20) | explicit ExampleVirt(int state) : state(state) { print_created(this, s...
    method ExampleVirt (line 21) | ExampleVirt(const ExampleVirt &e) : state(e.state) { print_copy_create...
    method ExampleVirt (line 22) | ExampleVirt(ExampleVirt &&e) noexcept : state(e.state) {
    method run (line 28) | virtual int run(int value) {
  function run (line 54) | int run(int value) override {
  function PYBIND11_OVERRIDE (line 92) | PYBIND11_OVERRIDE(const std::string *, /* Return type */
  class NCVirtTrampoline (line 145) | class NCVirtTrampoline : public NCVirt {
    method NonCopyable (line 147) | NonCopyable get_noncopyable(int a, int b) override {
    method Movable (line 151) | Movable get_movable(int a, int b) override {
  type Base (line 156) | struct Base {
    method Base (line 159) | Base() = default;
    method Base (line 160) | Base(const Base &) = delete;
  type DispatchIssue (line 163) | struct DispatchIssue : Base {
    method dispatch (line 164) | std::string dispatch() const override {
  type AdderBase (line 171) | struct AdderBase {
    type Data (line 172) | struct Data {}
    method AdderBase (line 179) | AdderBase() = default;
    method AdderBase (line 180) | AdderBase(const AdderBase &) = delete;
  type Adder (line 183) | struct Adder : AdderBase {
  function test_gil (line 191) | static void test_gil() {
  function test_gil_from_thread (line 203) | static void test_gil_from_thread() {
  class test_override_cache_helper (line 210) | class test_override_cache_helper {
    method func (line 213) | virtual int func() { return 0; }
    method test_override_cache_helper (line 215) | test_override_cache_helper() = default;
    method test_override_cache_helper (line 218) | test_override_cache_helper &operator=(test_override_cache_helper const...
    method test_override_cache_helper (line 219) | test_override_cache_helper(test_override_cache_helper const &Copy) = d...
  class test_override_cache_helper_trampoline (line 222) | class test_override_cache_helper_trampoline : public test_override_cache...
    method func (line 223) | int func() override { PYBIND11_OVERRIDE(int, test_override_cache_helpe...
  function test_override_cache (line 226) | inline int test_override_cache(std::shared_ptr<test_override_cache_helpe...
  function TEST_SUBMODULE (line 234) | TEST_SUBMODULE(virtual_functions, m) {
  class A_Repeat (line 423) | class A_Repeat {
    method A_METHODS (line 436) | A_METHODS
    method A_Repeat (line 438) | A_Repeat(const A_Repeat &) = delete;
  class A_Tpl (line 464) | class A_Tpl {
    method A_Tpl (line 466) | A_Tpl() = default;
    method A_Tpl (line 467) | A_Tpl(const A_Tpl &) = delete;
  function unlucky_number (line 484) | int unlucky_number() override { PYBIND11_OVERRIDE_PURE(int, A_Repeat, un...
  function PYBIND11_OVERRIDE (line 492) | PYBIND11_OVERRIDE(int, B_Repeat, unlucky_number, ); }
  function PYBIND11_OVERRIDE (line 501) | PYBIND11_OVERRIDE(int, C_Repeat, unlucky_number, ); }
  function unlucky_number (line 510) | int unlucky_number() override { PYBIND11_OVERRIDE(int, D_Repeat, unlucky...
  function unlucky_number (line 535) | int unlucky_number() override { PYBIND11_OVERRIDE_PURE(int, Base, unluck...
  function unlucky_number (line 545) | int unlucky_number() override { PYBIND11_OVERRIDE(int, Base, unlucky_num...
  function initialize_inherited_virtuals (line 561) | void initialize_inherited_virtuals(py::module_ &m) {

FILE: tests/test_virtual_functions.py
  function test_override (line 13) | def test_override(capture, msg):
  function test_alias_delay_initialization1 (line 98) | def test_alias_delay_initialization1(capture):
  function test_alias_delay_initialization2 (line 138) | def test_alias_delay_initialization2(capture):
  function test_move_support (line 200) | def test_move_support():
  function test_dispatch_issue (line 245) | def test_dispatch_issue(msg):
  function test_recursive_dispatch_issue (line 267) | def test_recursive_dispatch_issue():
  function test_override_ref (line 300) | def test_override_ref():
  function test_inherited_virtuals (line 316) | def test_inherited_virtuals():
  function test_issue_1454 (line 446) | def test_issue_1454():
  function test_python_override (line 452) | def test_python_override():

FILE: tests/test_warnings.cpp
  function TEST_SUBMODULE (line 16) | TEST_SUBMODULE(warnings_, m) {

FILE: tests/test_warnings.py
  function test_warning_simple (line 19) | def test_warning_simple(
  function test_warning_wrong_subclass_fail (line 30) | def test_warning_wrong_subclass_fail():
  function test_warning_double_register_fail (line 41) | def test_warning_double_register_fail():
  function test_warning_register (line 52) | def test_warning_register():
  function test_warning_custom (line 62) | def test_warning_custom():

FILE: tests/test_with_catch/catch.cpp
  class ProgressReporter (line 37) | class ProgressReporter : public Catch::StreamingReporterBase<ProgressRep...
    method getDescription (line 41) | static std::string getDescription() { return "Simple progress reporter...
    method testCaseStarting (line 43) | void testCaseStarting(Catch::TestCaseInfo const &testInfo) override {
    method testCaseEnded (line 50) | void testCaseEnded(Catch::TestCaseStats const &stats) override {
    method noMatchingTestCases (line 57) | void noMatchingTestCases(std::string const &spec) override {
    method reportInvalidArguments (line 63) | void reportInvalidArguments(std::string const &arg) override {
    method assertionStarting (line 69) | void assertionStarting(Catch::AssertionInfo const &) override {}
    method assertionEnded (line 71) | bool assertionEnded(Catch::AssertionStats const &) override { return f...
    method testRunEnded (line 73) | void testRunEnded(Catch::TestRunStats const &stats) override {
    method print_python_version_once (line 89) | void print_python_version_once() {
  function get_utc_timestamp (line 108) | std::string get_utc_timestamp() {
  function termination_signal_handler (line 129) | void termination_signal_handler(int sig) {
  function main (line 142) | int main(int argc, char *argv[]) {

FILE: tests/test_with_catch/external_module.cpp
  function unsafe_reset_local_internals (line 12) | void unsafe_reset_local_internals() {
  function PYBIND11_MODULE (line 21) | PYBIND11_MODULE(external_module,

FILE: tests/test_with_catch/test_args_convert_vector.cpp
  function get_sample_vectors (line 10) | std::vector<Container> get_sample_vectors() {
  function require_vector_matches_sample (line 21) | void require_vector_matches_sample(const args_convert_vector &actual,
  function mutation_test_with_samples (line 30) | void mutation_test_with_samples(ActualMutationFunc actual_mutation_func,

FILE: tests/test_with_catch/test_argument_vector.cpp
  function argument_vector (line 12) | argument_vector to_argument_vector(const std::vector<py::handle> &v) {
  function get_sample_argument_vector_contents (line 21) | std::vector<std::vector<py::handle>> get_sample_argument_vector_contents...
  function get_sample_argument_vectors (line 30) | std::vector<argument_vector> get_sample_argument_vectors() {
  function require_vector_matches_sample (line 38) | void require_vector_matches_sample(const argument_vector &actual,
  function mutation_test_with_samples (line 47) | void mutation_test_with_samples(ActualMutationFunc actual_mutation_func,

FILE: tests/test_with_catch/test_interpreter.cpp
  function get_sys_path_size (line 18) | size_t get_sys_path_size() {
  function has_state_dict_internals_obj (line 23) | bool has_state_dict_internals_obj() {
  function get_details_as_uintptr (line 28) | uintptr_t get_details_as_uintptr() {
  class Widget (line 32) | class Widget {
    method Widget (line 34) | explicit Widget(std::string message) : message(std::move(message)) {}
    method the_message (line 37) | std::string the_message() const { return message; }
  class PyWidget (line 45) | class PyWidget final : public Widget {
    method the_answer (line 48) | int the_answer() const override { PYBIND11_OVERRIDE_PURE(int, Widget, ...
    method argv0 (line 49) | std::string argv0() const override { PYBIND11_OVERRIDE_PURE(std::strin...
  class test_override_cache_helper (line 52) | class test_override_cache_helper {
    method func (line 55) | virtual int func() { return 0; }
    method test_override_cache_helper (line 57) | test_override_cache_helper() = default;
    method test_override_cache_helper (line 60) | test_override_cache_helper &operator=(test_override_cache_helper const...
    method test_override_cache_helper (line 61) | test_override_cache_helper(test_override_cache_helper const &Copy) = d...
  class test_override_cache_helper_trampoline (line 64) | class test_override_cache_helper_trampoline : public test_override_cache...
    method func (line 65) | int func() override { PYBIND11_OVERRIDE(int, test_override_cache_helpe...
  function PYBIND11_EMBEDDED_MODULE (line 68) | PYBIND11_EMBEDDED_MODULE(widget_module, m, py::multiple_interpreters::pe...
  function PYBIND11_EMBEDDED_MODULE (line 79) | PYBIND11_EMBEDDED_MODULE(trampoline_module, m) {
  type scope_exit (line 396) | struct scope_exit {
    method scope_exit (line 398) | explicit scope_exit(std::function<void()> f) noexcept : f_(std::move(f...

FILE: tests/test_with_catch/test_interpreter.py
  class DerivedWidget (line 8) | class DerivedWidget(Widget):
    method __init__ (line 9) | def __init__(self, message):
    method the_answer (line 12) | def the_answer(self):
    method argv0 (line 15) | def argv0(self):

FILE: tests/test_with_catch/test_subinterpreter.cpp
  function unsafe_reset_internals_for_single_interpreter (line 25) | void unsafe_reset_internals_for_single_interpreter() {

FILE: tests/test_with_catch/test_trampoline.py
  function func (line 6) | def func():
  function func2 (line 14) | def func2():

FILE: tools/codespell_ignore_lines_from_errors.py
  function run (line 17) | def run(args: list[str]) -> None:

FILE: tools/make_global.py
  function get_global (line 16) | def get_global() -> str: