make recursion guard option-al

Author: samuelcolvin

Cargo.lock

@@ -19,6 +19,7 @@ indexmap = "1.8.1"
 mimalloc = { version = "0.1.29", default-features = false, optional = true }
 speedate = "0.4.1"
 ahash = "0.7.6"
+nohash-hasher = "0.2.0"
 
 [lib]
 name = "_pydantic_core"

Cargo.toml

@@ -1,7 +1,9 @@
-use ahash::AHashSet;
+use std::collections::HashSet;
 use std::fmt::Debug;
+use std::hash::BuildHasherDefault;
 
 use enum_dispatch::enum_dispatch;
+use nohash_hasher::NoHashHasher;
 
 use pyo3::exceptions::PyRecursionError;
 use pyo3::prelude::*;
@@ -75,19 +77,24 @@ impl SchemaValidator {
     }
 
     pub fn validate_python(&self, py: Python, input: &PyAny) -> PyResult<PyObject> {
-        let mut recursion_guard = RecursionGuard::new();
-        let r = self
-            .validator
-            .validate(py, input, &Extra::default(), &self.slots, &mut recursion_guard);
+        let r = self.validator.validate(
+            py,
+            input,
+            &Extra::default(),
+            &self.slots,
+            &mut RecursionGuard::default(),
+        );
         r.map_err(|e| self.prepare_validation_err(py, e))
     }
 
     pub fn isinstance_python(&self, py: Python, input: &PyAny) -> PyResult<bool> {
-        let mut recursion_guard = RecursionGuard::new();
-        match self
-            .validator
-            .validate(py, input, &Extra::default(), &self.slots, &mut recursion_guard)
-        {
+        match self.validator.validate(
+            py,
+            input,
+            &Extra::default(),
+            &self.slots,
+            &mut RecursionGuard::default(),
+        ) {
             Ok(_) => Ok(true),
             Err(ValError::InternalErr(err)) => Err(err),
             _ => Ok(false),
@@ -97,10 +104,13 @@ impl SchemaValidator {
     pub fn validate_json(&self, py: Python, input: String) -> PyResult<PyObject> {
         match parse_json::<JsonInput>(&input) {
             Ok(input) => {
-                let mut recursion_guard = RecursionGuard::new();
-                let r = self
-                    .validator
-                    .validate(py, &input, &Extra::default(), &self.slots, &mut recursion_guard);
+                let r = self.validator.validate(
+                    py,
+                    &input,
+                    &Extra::default(),
+                    &self.slots,
+                    &mut RecursionGuard::default(),
+                );
                 r.map_err(|e| self.prepare_validation_err(py, e))
             }
             Err(e) => {
@@ -118,11 +128,13 @@ impl SchemaValidator {
     pub fn isinstance_json(&self, py: Python, input: String) -> PyResult<bool> {
         match parse_json::<JsonInput>(&input) {
             Ok(input) => {
-                let mut recursion_guard = RecursionGuard::new();
-                match self
-                    .validator
-                    .validate(py, &input, &Extra::default(), &self.slots, &mut recursion_guard)
-                {
+                match self.validator.validate(
+                    py,
+                    &input,
+                    &Extra::default(),
+                    &self.slots,
+                    &mut RecursionGuard::default(),
+                ) {
                     Ok(_) => Ok(true),
                     Err(ValError::InternalErr(err)) => Err(err),
                     _ => Ok(false),
@@ -137,10 +149,9 @@ impl SchemaValidator {
             data: Some(data),
             field: Some(field.as_str()),
         };
-        let mut recursion_guard = RecursionGuard::new();
         let r = self
             .validator
-            .validate(py, input, &extra, &self.slots, &mut recursion_guard);
+            .validate(py, input, &extra, &self.slots, &mut RecursionGuard::default());
         r.map_err(|e| self.prepare_validation_err(py, e))
     }
 
@@ -353,7 +364,40 @@ pub enum CombinedValidator {
     FrozenSet(frozenset::FrozenSetValidator),
 }
 
-pub type RecursionGuard = AHashSet<usize>;
+#[derive(Debug, Clone, Default)]
+pub struct RecursionGuard(Option<HashSet<usize, BuildHasherDefault<NoHashHasher<usize>>>>);
+
+impl RecursionGuard {
+    pub fn insert(&mut self, id: usize) {
+        match self.0 {
+            Some(ref mut set) => {
+                set.insert(id);
+            }
+            None => {
+                let mut set: HashSet<usize, BuildHasherDefault<NoHashHasher<usize>>> =
+                    HashSet::with_capacity_and_hasher(10, BuildHasherDefault::default());
+                set.insert(id);
+                self.0 = Some(set);
+            }
+        };
+    }
+
+    pub fn remove(&mut self, id: &usize) {
+        match self.0 {
+            Some(ref mut set) => {
+                set.remove(id);
+            }
+            None => unreachable!(),
+        };
+    }
+
+    pub fn contains(&self, id: &usize) -> bool {
+        match self.0 {
+            Some(ref set) => set.contains(id),
+            None => false,
+        }
+    }
+}
 
 /// This trait must be implemented by all validators, it allows various validators to be accessed consistently,
 /// validators defined in `build_validator` also need `EXPECTED_TYPE` as a const, but that can't be part of the trait