Rename py::local to py::module_local

Author: jagerman

include/pybind11/attr.h

@@ -65,7 +65,7 @@ struct metaclass {
 };
 
 /// Annotation that marks a class as local to the module:
-struct local { bool value; local(bool v = true) : value(v) { } };
+struct module_local { bool value; module_local(bool v = true) : value(v) { } };
 
 /// Annotation to mark enums as an arithmetic type
 struct arithmetic { };
@@ -199,7 +199,7 @@ struct function_record {
 /// Special data structure which (temporarily) holds metadata about a bound class
 struct type_record {
     PYBIND11_NOINLINE type_record()
-        : multiple_inheritance(false), dynamic_attr(false), buffer_protocol(false), local(false) { }
+        : multiple_inheritance(false), dynamic_attr(false), buffer_protocol(false), module_local(false) { }
 
     /// Handle to the parent scope
     handle scope;
@@ -247,7 +247,7 @@ struct type_record {
     bool default_holder : 1;
 
     /// Is the class definition local to the module shared object?
-    bool local : 1;
+    bool module_local : 1;
 
     PYBIND11_NOINLINE void add_base(const std::type_info &base, void *(*caster)(void *)) {
         auto base_info = detail::get_type_info(base, false);
@@ -415,8 +415,8 @@ struct process_attribute<metaclass> : process_attribute_default<metaclass> {
 };
 
 template <>
-struct process_attribute<local> : process_attribute_default<local> {
-    static void init(const local &l, type_record *r) { r->local = l.value; }
+struct process_attribute<module_local> : process_attribute_default<module_local> {
+    static void init(const module_local &l, type_record *r) { r->module_local = l.value; }
 };
 
 /// Process an 'arithmetic' attribute for enums (does nothing here)

include/pybind11/pybind11.h

@@ -844,7 +844,7 @@ class generic_type : public object {
         auto tindex = std::type_index(*rec.type);
         tinfo->direct_conversions = &internals.direct_conversions[tindex];
         tinfo->default_holder = rec.default_holder;
-        if (rec.local)
+        if (rec.module_local)
             registered_local_types_cpp()[tindex] = tinfo;
         else
             internals.registered_types_cpp[tindex] = tinfo;
@@ -989,7 +989,7 @@ class class_ : public detail::generic_type {
         generic_type::initialize(record);
 
         if (has_alias) {
-            auto &instances = record.local ? registered_local_types_cpp() : get_internals().registered_types_cpp;
+            auto &instances = record.module_local ? registered_local_types_cpp() : get_internals().registered_types_cpp;
             instances[std::type_index(typeid(type_alias))] = instances[std::type_index(typeid(type))];
         }
     }
@@ -1438,7 +1438,7 @@ iterator make_iterator(Iterator first, Sentinel last, Extra &&... extra) {
     typedef detail::iterator_state<Iterator, Sentinel, false, Policy> state;
 
     if (!detail::get_type_info(typeid(state), false)) {
-        class_<state>(handle(), "iterator", pybind11::local())
+        class_<state>(handle(), "iterator", pybind11::module_local())
             .def("__iter__", [](state &s) -> state& { return s; })
             .def("__next__", [](state &s) -> ValueType {
                 if (!s.first_or_done)
@@ -1467,7 +1467,7 @@ iterator make_key_iterator(Iterator first, Sentinel last, Extra &&... extra) {
     typedef detail::iterator_state<Iterator, Sentinel, true, Policy> state;
 
     if (!detail::get_type_info(typeid(state), false)) {
-        class_<state>(handle(), "iterator", pybind11::local())
+        class_<state>(handle(), "iterator", pybind11::module_local())
             .def("__iter__", [](state &s) -> state& { return s; })
             .def("__next__", [](state &s) -> KeyType {
                 if (!s.first_or_done)

include/pybind11/stl_bind.h

@@ -379,7 +379,7 @@ template <typename Vector, typename holder_type = std::unique_ptr<Vector>, typen
 class_<Vector, holder_type> bind_vector(handle scope, std::string const &name, Args&&... args) {
     using Class_ = class_<Vector, holder_type>;
 
-    Class_ cl(scope, name.c_str(), pybind11::local(), std::forward<Args>(args)...);
+    Class_ cl(scope, name.c_str(), pybind11::module_local(), std::forward<Args>(args)...);
 
     // Declare the buffer interface if a buffer_protocol() is passed in
     detail::vector_buffer<Vector, Class_, Args...>(cl);
@@ -536,7 +536,7 @@ class_<Map, holder_type> bind_map(handle scope, const std::string &name, Args&&.
     using MappedType = typename Map::mapped_type;
     using Class_ = class_<Map, holder_type>;
 
-    Class_ cl(scope, name.c_str(), pybind11::local(), std::forward<Args>(args)...);
+    Class_ cl(scope, name.c_str(), pybind11::module_local(), std::forward<Args>(args)...);
 
     cl.def(init<>());
 

tests/pybind11_local_bindings.cpp

@@ -19,7 +19,7 @@ PYBIND11_MODULE(pybind11_local_bindings, m) {
 
     // test_local_bindings
     // Local to both:
-    bind_local<LocalType, 1>(m, "LocalType", py::local())
+    bind_local<LocalType, 1>(m, "LocalType", py::module_local())
         .def("get2", [](LocalType &t) { return t.i + 2; })
         ;
 
@@ -34,20 +34,20 @@ PYBIND11_MODULE(pybind11_local_bindings, m) {
     });
 
     // test_stl_bind_local
-    // stl_bind.h binders defaults to py::local.  Note that the value doesn't have to be local, even
+    // stl_bind.h binders defaults to py::module_local.  Note that the value doesn't have to be local, even
     // if the overall container is:
     py::bind_vector<std::vector<LocalType>>(m, "LocalVec");
     py::bind_vector<std::vector<NonLocalType>>(m, "LocalVec2");
     py::bind_map<std::unordered_map<std::string, LocalType>>(m, "LocalMap");
     py::bind_map<std::unordered_map<std::string, NonLocalType>>(m, "LocalMap2");
 
     // test_stl_bind_global
-    // stl_bind binders can, however, be overridden to global using `py::local(false)` (in which
+    // stl_bind binders can, however, be overridden to global using `py::module_local(false)` (in which
     // case this will fail):
     m.def("register_nonlocal_stl1", [m]() {
-        py::bind_vector<std::vector<NonLocal2>>(m, "NonLocalVec", py::local(false));
+        py::bind_vector<std::vector<NonLocal2>>(m, "NonLocalVec", py::module_local(false));
     });
     m.def("register_nonlocal_stl2", [m]() {
-        py::bind_map<std::unordered_map<std::string, NonLocal2>>(m, "NonLocalMap", py::local(false));
+        py::bind_map<std::unordered_map<std::string, NonLocal2>>(m, "NonLocalMap", py::module_local(false));
     });
 }

tests/test_class.cpp

@@ -228,7 +228,7 @@ TEST_SUBMODULE(class_, m) {
 
     // This test is actually part of test_local_bindings (test_duplicate_local), but we need a
     // definition in a different compilation unit within the same module:
-    bind_local<LocalExternal, 17>(m, "LocalExternal", py::local());
+    bind_local<LocalExternal, 17>(m, "LocalExternal", py::module_local());
 }
 
 template <int N> class BreaksBase {};

tests/test_local_bindings.cpp

@@ -1,6 +1,6 @@
 /*
-    tests/test_local_bindings.cpp -- tests the py::local class feature which makes a class binding
-                                     local to the module in which it is defined.
+    tests/test_local_bindings.cpp -- tests the py::module_local class feature which makes a class
+                                     binding local to the module in which it is defined.
 
     Copyright (c) 2017 Jason Rhinelander <[email protected]>
 
@@ -15,8 +15,8 @@
 TEST_SUBMODULE(local_bindings, m) {
 
     // test_local_bindings
-    // Register a class with py::local:
-    bind_local<LocalType, -1>(m, "LocalType", py::local())
+    // Register a class with py::module_local:
+    bind_local<LocalType, -1>(m, "LocalType", py::module_local())
         .def("get3", [](LocalType &t) { return t.i + 3; })
         ;
 
@@ -31,28 +31,28 @@ TEST_SUBMODULE(local_bindings, m) {
         ;
 
     // test_duplicate_local
-    // py::local declarations should be visible across compilation units that get linked together;
+    // py::module_local declarations should be visible across compilation units that get linked together;
     // this tries to register a duplicate local.  It depends on a definition in test_class.cpp and
     // should raise a runtime error from the duplicate definition attempt.  If test_class isn't
     // available it *also* throws a runtime error (with "test_class not enabled" as value).
     m.def("register_local_external", [m]() {
         auto main = py::module::import("pybind11_tests");
         if (py::hasattr(main, "class_")) {
-            bind_local<LocalExternal, 7>(m, "LocalExternal", py::local());
+            bind_local<LocalExternal, 7>(m, "LocalExternal", py::module_local());
         }
         else throw std::runtime_error("test_class not enabled");
     });
 
     // test_stl_bind_local
-    // stl_bind.h binders defaults to py::local:
+    // stl_bind.h binders defaults to py::module_local:
     py::bind_vector<std::vector<LocalType>>(m, "LocalVec");
     py::bind_vector<std::vector<NonLocalType>>(m, "LocalVec2");
     py::bind_map<std::unordered_map<std::string, LocalType>>(m, "LocalMap");
     py::bind_map<std::unordered_map<std::string, NonLocalType>>(m, "LocalMap2");
 
     // test_stl_bind_global
-    // They can, however, be overridden to global using `py::local(false)`:
+    // They can, however, be overridden to global using `py::module_local(false)`:
     bind_local<NonLocal2, 10>(m, "NonLocal2");
-    py::bind_vector<std::vector<NonLocal2>>(m, "NonLocalVec", py::local(false));
-    py::bind_map<std::unordered_map<std::string, NonLocal2>>(m, "NonLocalMap", py::local(false));
+    py::bind_vector<std::vector<NonLocal2>>(m, "NonLocalVec", py::module_local(false));
+    py::bind_map<std::unordered_map<std::string, NonLocal2>>(m, "NonLocalMap", py::module_local(false));
 }