Use function-local classes for KeysView etc

This limits the scope of the classes.

Author: bmerry

include/pybind11/stl_bind.h

@@ -595,34 +595,16 @@ template <typename Map, typename Class_> auto map_if_insertion_operator(Class_ &
     );
 }
 
-template<typename Map>
-struct keys_view
-{
-    Map &map;
-};
-
-template<typename Map>
-struct values_view
-{
-    Map &map;
-};
-
-template<typename Map>
-struct items_view
-{
-    Map &map;
-};
-
 PYBIND11_NAMESPACE_END(detail)
 
 template <typename Map, typename holder_type = std::unique_ptr<Map>, typename... Args>
 class_<Map, holder_type> bind_map(handle scope, const std::string &name, Args&&... args) {
     using KeyType = typename Map::key_type;
     using MappedType = typename Map::mapped_type;
-    using KeysView = detail::keys_view<Map>;
-    using ValuesView = detail::values_view<Map>;
-    using ItemsView = detail::items_view<Map>;
     using Class_ = class_<Map, holder_type>;
+    struct keys_view { Map &map; };
+    struct values_view { Map &map; };
+    struct items_view { Map &map; };
 
     // If either type is a non-module-local bound type then make the map binding non-local as well;
     // otherwise (e.g. both types are either module-local or converting) the map will be
@@ -635,11 +617,11 @@ class_<Map, holder_type> bind_map(handle scope, const std::string &name, Args&&.
     }
 
     Class_ cl(scope, name.c_str(), pybind11::module_local(local), std::forward<Args>(args)...);
-    py::class_<KeysView> keys_view(
+    py::class_<keys_view> KeysView(
         scope, ("KeysView[" + name + "]").c_str(), pybind11::module_local(local));
-    py::class_<ValuesView> values_view(
+    py::class_<values_view> ValuesView(
         scope, ("ValuesView[" + name + "]").c_str(), pybind11::module_local(local));
-    py::class_<ItemsView> items_view(
+    py::class_<items_view> ItemsView(
         scope, ("ItemsView[" + name + "]").c_str(), pybind11::module_local(local));
 
     cl.def(init<>());
@@ -658,17 +640,17 @@ class_<Map, holder_type> bind_map(handle scope, const std::string &name, Args&&.
     );
 
     cl.def("keys",
-           [](Map &m) { return KeysView{m}; },
+           [](Map &m) { return keys_view{m}; },
            keep_alive<0, 1>() /* Essential: keep map alive while view exists */
     );
 
     cl.def("values",
-           [](Map &m) { return ValuesView{m}; },
+           [](Map &m) { return values_view{m}; },
            keep_alive<0, 1>() /* Essential: keep map alive while view exists */
     );
 
     cl.def("items",
-           [](Map &m) { return ItemsView{m}; },
+           [](Map &m) { return items_view{m}; },
            keep_alive<0, 1>() /* Essential: keep map alive while view exists */
     );
 
@@ -705,33 +687,33 @@ class_<Map, holder_type> bind_map(handle scope, const std::string &name, Args&&.
 
     cl.def("__len__", &Map::size);
 
-    keys_view.def("__len__", [](KeysView &view) { return view.map.size(); });
-    keys_view.def("__iter__",
-        [](KeysView &view) {
+    KeysView.def("__len__", [](keys_view &view) { return view.map.size(); });
+    KeysView.def("__iter__",
+        [](keys_view &view) {
             return make_key_iterator(view.map.begin(), view.map.end());
         },
         keep_alive<0, 1>() /* Essential: keep view alive while iterator exists */
     );
-    keys_view.def("__contains__",
-        [](KeysView &view, const KeyType &k) -> bool {
+    KeysView.def("__contains__",
+        [](keys_view &view, const KeyType &k) -> bool {
             auto it = view.map.find(k);
             if (it == view.map.end())
                 return false;
             return true;
         }
     );
 
-    values_view.def("__len__", [](ValuesView &view) { return view.map.size(); });
-    values_view.def("__iter__",
-        [](ValuesView &view) {
+    ValuesView.def("__len__", [](values_view &view) { return view.map.size(); });
+    ValuesView.def("__iter__",
+        [](values_view &view) {
             return make_value_iterator(view.map.begin(), view.map.end());
         },
         keep_alive<0, 1>() /* Essential: keep view alive while iterator exists */
     );
 
-    items_view.def("__len__", [](ItemsView &view) { return view.map.size(); });
-    items_view.def("__iter__",
-        [](ItemsView &view) {
+    ItemsView.def("__len__", [](items_view &view) { return view.map.size(); });
+    ItemsView.def("__iter__",
+        [](items_view &view) {
             return make_iterator(view.map.begin(), view.map.end());
         },
         keep_alive<0, 1>() /* Essential: keep view alive while iterator exists */