Fix build

Author: MaxwellGengYF

include/pybind11/detail/class.h

@@ -414,7 +414,7 @@ inline void add_patient(PyObject *nurse, PyObject *patient) {
 
 inline void clear_patients(PyObject *self) {
     auto *instance = reinterpret_cast<detail::instance *>(self);
-    std::vector<PyObject *> patients;
+    luisa::vector<PyObject *> patients;
 
     with_internals([&](internals &internals) {
         auto pos = internals.patients.find(self);

include/pybind11/detail/internals.h

@@ -116,7 +116,7 @@ struct type_equal_to {
 #endif
 
 template <typename value_type>
-using type_map = std::unordered_map<std::type_index, value_type, type_hash, type_equal_to>;
+using type_map = pybind::unordered_map<std::type_index, value_type, type_hash, type_equal_to>;
 
 struct override_hash {
     inline size_t operator()(const std::pair<const PyObject *, const char *> &v) const {
@@ -126,7 +126,7 @@ struct override_hash {
     }
 };
 
-using instance_map = std::unordered_multimap<const void *, instance *>;
+using instance_map = pybind::unordered_multimap<const void *, instance *>;
 
 #ifdef Py_GIL_DISABLED
 // Wrapper around PyMutex to provide BasicLockable semantics
@@ -162,19 +162,19 @@ struct internals {
     // std::type_index -> pybind11's type information
     type_map<type_info *> registered_types_cpp;
     // PyTypeObject* -> base type_info(s)
-    std::unordered_map<PyTypeObject *, luisa::vector<type_info *>> registered_types_py;
+    pybind::unordered_map<PyTypeObject *, luisa::vector<type_info *>> registered_types_py;
 #ifdef Py_GIL_DISABLED
     std::unique_ptr<instance_map_shard[]> instance_shards; // void * -> instance*
     size_t instance_shards_mask;
 #else
     instance_map registered_instances; // void * -> instance*
 #endif
-    std::unordered_set<std::pair<const PyObject *, const char *>, override_hash>
+    pybind::unordered_set<std::pair<const PyObject *, const char *>, override_hash>
         inactive_override_cache;
     type_map<luisa::vector<bool (*)(PyObject *, void *&)>> direct_conversions;
-    std::unordered_map<const PyObject *, luisa::vector<PyObject *>> patients;
+    pybind::unordered_map<const PyObject *, luisa::vector<PyObject *>> patients;
     std::forward_list<ExceptionTranslator> registered_exception_translators;
-    std::unordered_map<std::string, void *> shared_data; // Custom data to be shared across
+    pybind::unordered_map<std::string, void *> shared_data; // Custom data to be shared across
                                                          // extensions
     std::forward_list<std::string> static_strings;       // Stores the std::strings backing
                                                          // detail::c_str()

include/pybind11/detail/type_caster_base.h

@@ -43,7 +43,7 @@ PYBIND11_NAMESPACE_BEGIN(detail)
 class loader_life_support {
 private:
     loader_life_support *parent = nullptr;
-    std::unordered_set<PyObject *> keep_alive;
+    pybind::unordered_set<PyObject *> keep_alive;
 
     // Store stack pointer in thread-local storage.
     static PYBIND11_TLS_KEY_REF get_stack_tls_key() {

include/pybind11/numpy.h

@@ -136,7 +136,7 @@ struct numpy_type_info {
 };
 
 struct numpy_internals {
-    std::unordered_map<std::type_index, numpy_type_info> registered_dtypes;
+    pybind::unordered_map<std::type_index, numpy_type_info> registered_dtypes;
 
     numpy_type_info *get_type_info(const std::type_info &tinfo, bool throw_if_missing = true) {
         auto it = registered_dtypes.find(std::type_index(tinfo));

include/pybind11/pybind11.h

@@ -12,6 +12,28 @@
 #include <luisa/core/stl/vector.h>
 #include <luisa/core/stl/functional.h>
 #include <luisa/core/stl/variant.h>
+#include <unordered_map>
+#include <unordered_set>
+namespace pybind {
+template<typename K, typename V,
+        typename Hash = std::hash<K>,
+        typename Eq = std::equal_to<>,
+        typename Alloc = luisa::allocator<std::pair<const K, V>>>
+using unordered_map = std::unordered_map<K, V, Hash, Eq, Alloc>;
+template<typename K, typename V,
+        typename Hash = std::hash<K>,
+        typename Eq = std::equal_to<>,
+        typename Alloc = luisa::allocator<std::pair<const K, V>>>
+using unordered_multimap = std::unordered_multimap<K, V, Hash, Eq, Alloc>;
+
+template<typename K,
+         typename Hash = std::hash<K>,
+         typename Eq = std::equal_to<>,
+         typename Alloc = luisa::allocator<K>>
+using unordered_set = std::unordered_set<K, Hash, Eq, Alloc>;
+}
+
+
 #include "detail/class.h"
 #include "detail/dynamic_raw_ptr_cast_if_possible.h"
 #include "detail/exception_translation.h"

include/pybind11/stl.h

@@ -420,7 +420,7 @@ struct array_caster {
         // Deliberate choice: no template specializations, for simplicity, and
         // because the compile time overhead for the specializations is deemed
         // more significant than the runtime overhead for the `temp` storage.
-        std::vector<Value> temp;
+        luisa::vector<Value> temp;
         temp.reserve(l.size());
         for (auto it : l) {
             value_conv conv;
@@ -513,16 +513,16 @@ struct type_caster<std::set<Key, Compare, Alloc>>
     : set_caster<std::set<Key, Compare, Alloc>, Key> {};
 
 template <typename Key, typename Hash, typename Equal, typename Alloc>
-struct type_caster<std::unordered_set<Key, Hash, Equal, Alloc>>
-    : set_caster<std::unordered_set<Key, Hash, Equal, Alloc>, Key> {};
+struct type_caster<pybind::unordered_set<Key, Hash, Equal, Alloc>>
+    : set_caster<pybind::unordered_set<Key, Hash, Equal, Alloc>, Key> {};
 
 template <typename Key, typename Value, typename Compare, typename Alloc>
 struct type_caster<std::map<Key, Value, Compare, Alloc>>
     : map_caster<std::map<Key, Value, Compare, Alloc>, Key, Value> {};
 
 template <typename Key, typename Value, typename Hash, typename Equal, typename Alloc>
-struct type_caster<std::unordered_map<Key, Value, Hash, Equal, Alloc>>
-    : map_caster<std::unordered_map<Key, Value, Hash, Equal, Alloc>, Key, Value> {};
+struct type_caster<pybind::unordered_map<Key, Value, Hash, Equal, Alloc>>
+    : map_caster<pybind::unordered_map<Key, Value, Hash, Equal, Alloc>, Key, Value> {};
 
 // This type caster is intended to be used for std::optional and std::experimental::optional
 template <typename Type, typename Value = typename Type::value_type>

include/pybind11/stl_bind.h

@@ -566,7 +566,7 @@ class_<Vector, holder_type> bind_vector(handle scope, std::string const &name, A
 }
 
 //
-// std::map, std::unordered_map
+// std::map, pybind::unordered_map
 //
 
 PYBIND11_NAMESPACE_BEGIN(detail)