perf: use type guards to avoid descending into nodes

Stranger6667 · Stranger6667 · commit 19c71348b6c0 · 2025-11-16T12:02:57.000+01:00
Signed-off-by: Dmitry Dygalo &lt;dmitry@dygalo.dev&gt;
diff --git a/crates/jsonschema/src/keywords/boolean.rs b/crates/jsonschema/src/keywords/boolean.rs
@@ -1,6 +1,8 @@
 use crate::paths::{LazyLocation, Location};
 
-use crate::{error::ValidationError, keywords::CompilationResult, validator::Validate};
+use crate::{
+    error::ValidationError, keywords::CompilationResult, types::JsonTypeSet, validator::Validate,
+};
 use serde_json::Value;
 
 pub(crate) struct FalseValidator {
@@ -28,6 +30,10 @@ impl Validate for FalseValidator {
             instance,
         ))
     }
+
+    fn applicable_types(&self) -> JsonTypeSet {
+        JsonTypeSet::empty()
+    }
 }
 
 #[cfg(test)]
diff --git a/crates/jsonschema/src/keywords/const_.rs b/crates/jsonschema/src/keywords/const_.rs
@@ -1,5 +1,10 @@
 use crate::{
-    compiler, error::ValidationError, ext::cmp, keywords::CompilationResult, paths::Location,
+    compiler,
+    error::ValidationError,
+    ext::cmp,
+    keywords::CompilationResult,
+    paths::Location,
+    types::{JsonType, JsonTypeSet},
     validator::Validate,
 };
 use serde_json::{Map, Number, Value};
@@ -45,6 +50,10 @@ impl Validate for ConstArrayValidator {
             false
         }
     }
+
+    fn applicable_types(&self) -> JsonTypeSet {
+        JsonTypeSet::empty().insert(JsonType::Array)
+    }
 }
 
 struct ConstBooleanValidator {
@@ -83,6 +92,10 @@ impl Validate for ConstBooleanValidator {
             false
         }
     }
+
+    fn applicable_types(&self) -> JsonTypeSet {
+        JsonTypeSet::empty().insert(JsonType::Boolean)
+    }
 }
 
 struct ConstNullValidator {
@@ -114,6 +127,10 @@ impl Validate for ConstNullValidator {
     fn is_valid(&self, instance: &Value) -> bool {
         instance.is_null()
     }
+
+    fn applicable_types(&self) -> JsonTypeSet {
+        JsonTypeSet::empty().insert(JsonType::Null)
+    }
 }
 
 struct ConstNumberValidator {
@@ -157,6 +174,14 @@ impl Validate for ConstNumberValidator {
             false
         }
     }
+
+    fn applicable_types(&self) -> JsonTypeSet {
+        let mut set = JsonTypeSet::empty().insert(JsonType::Number);
+        if self.original_value.is_i64() || self.original_value.is_u64() {
+            set = set.insert(JsonType::Integer);
+        }
+        set
+    }
 }
 
 pub(crate) struct ConstObjectValidator {
@@ -198,6 +223,10 @@ impl Validate for ConstObjectValidator {
             false
         }
     }
+
+    fn applicable_types(&self) -> JsonTypeSet {
+        JsonTypeSet::empty().insert(JsonType::Object)
+    }
 }
 
 pub(crate) struct ConstStringValidator {
@@ -239,6 +268,10 @@ impl Validate for ConstStringValidator {
             false
         }
     }
+
+    fn applicable_types(&self) -> JsonTypeSet {
+        JsonTypeSet::empty().insert(JsonType::String)
+    }
 }
 
 #[inline]
diff --git a/crates/jsonschema/src/keywords/enum_.rs b/crates/jsonschema/src/keywords/enum_.rs
@@ -27,7 +27,7 @@ impl EnumValidator {
     ) -> CompilationResult<'a> {
         let mut types = JsonTypeSet::empty();
         for item in items {
-            types = types.insert(JsonType::from(item));
+            types = types.union(JsonTypeSet::from_value(item));
         }
         Ok(Box::new(EnumValidator {
             options: schema.clone(),
@@ -66,13 +66,18 @@ impl Validate for EnumValidator {
             false
         }
     }
+
+    fn applicable_types(&self) -> JsonTypeSet {
+        self.types
+    }
 }
 
 #[derive(Debug)]
 pub(crate) struct SingleValueEnumValidator {
     value: Value,
     options: Value,
     location: Location,
+    types: JsonTypeSet,
 }
 
 impl SingleValueEnumValidator {
@@ -86,6 +91,7 @@ impl SingleValueEnumValidator {
             options: schema.clone(),
             value: value.clone(),
             location,
+            types: JsonTypeSet::from_value(value),
         }))
     }
 }
@@ -111,6 +117,10 @@ impl Validate for SingleValueEnumValidator {
     fn is_valid(&self, instance: &Value) -> bool {
         cmp::equal(&self.value, instance)
     }
+
+    fn applicable_types(&self) -> JsonTypeSet {
+        self.types
+    }
 }
 
 #[inline]
diff --git a/crates/jsonschema/src/keywords/legacy/type_draft_4.rs b/crates/jsonschema/src/keywords/legacy/type_draft_4.rs
@@ -68,6 +68,10 @@ impl Validate for MultipleTypesValidator {
             ))
         }
     }
+
+    fn applicable_types(&self) -> JsonTypeSet {
+        self.types
+    }
 }
 
 pub(crate) struct IntegerTypeValidator {
@@ -105,6 +109,10 @@ impl Validate for IntegerTypeValidator {
             ))
         }
     }
+
+    fn applicable_types(&self) -> JsonTypeSet {
+        JsonTypeSet::empty().insert(JsonType::Integer)
+    }
 }
 
 fn is_integer(num: &Number) -> bool {
diff --git a/crates/jsonschema/src/keywords/type_.rs b/crates/jsonschema/src/keywords/type_.rs
@@ -70,6 +70,10 @@ impl Validate for MultipleTypesValidator {
             ))
         }
     }
+
+    fn applicable_types(&self) -> JsonTypeSet {
+        self.types
+    }
 }
 
 pub(crate) struct NullTypeValidator {
@@ -103,6 +107,10 @@ impl Validate for NullTypeValidator {
             ))
         }
     }
+
+    fn applicable_types(&self) -> JsonTypeSet {
+        JsonTypeSet::empty().insert(JsonType::Null)
+    }
 }
 
 pub(crate) struct BooleanTypeValidator {
@@ -136,6 +144,10 @@ impl Validate for BooleanTypeValidator {
             ))
         }
     }
+
+    fn applicable_types(&self) -> JsonTypeSet {
+        JsonTypeSet::empty().insert(JsonType::Boolean)
+    }
 }
 
 pub(crate) struct StringTypeValidator {
@@ -170,6 +182,10 @@ impl Validate for StringTypeValidator {
             ))
         }
     }
+
+    fn applicable_types(&self) -> JsonTypeSet {
+        JsonTypeSet::empty().insert(JsonType::String)
+    }
 }
 
 pub(crate) struct ArrayTypeValidator {
@@ -204,6 +220,10 @@ impl Validate for ArrayTypeValidator {
             ))
         }
     }
+
+    fn applicable_types(&self) -> JsonTypeSet {
+        JsonTypeSet::empty().insert(JsonType::Array)
+    }
 }
 
 pub(crate) struct ObjectTypeValidator {
@@ -237,6 +257,10 @@ impl Validate for ObjectTypeValidator {
             ))
         }
     }
+
+    fn applicable_types(&self) -> JsonTypeSet {
+        JsonTypeSet::empty().insert(JsonType::Object)
+    }
 }
 
 pub(crate) struct NumberTypeValidator {
@@ -270,6 +294,10 @@ impl Validate for NumberTypeValidator {
             ))
         }
     }
+
+    fn applicable_types(&self) -> JsonTypeSet {
+        JsonTypeSet::empty().insert(JsonType::Number)
+    }
 }
 
 pub(crate) struct IntegerTypeValidator {
@@ -307,6 +335,10 @@ impl Validate for IntegerTypeValidator {
             ))
         }
     }
+
+    fn applicable_types(&self) -> JsonTypeSet {
+        JsonTypeSet::empty().insert(JsonType::Integer)
+    }
 }
 
 fn is_integer(num: &Number) -> bool {
diff --git a/crates/jsonschema/src/node.rs b/crates/jsonschema/src/node.rs
@@ -5,6 +5,7 @@ use crate::{
     output::{Annotations, BasicOutput, ErrorDescription, OutputUnit},
     paths::{LazyLocation, Location},
     thread::{Shared, SharedWeak},
+    types::JsonTypeSet,
     validator::{PartialApplication, Validate},
     ValidationError,
 };
@@ -22,6 +23,7 @@ pub(crate) struct SchemaNode {
     validators: Shared<NodeValidators>,
     location: Location,
     absolute_path: Option<Arc<Uri<String>>>,
+    applicable_types: JsonTypeSet,
 }
 
 // Separate type used only during compilation for handling recursive references
@@ -35,6 +37,7 @@ struct PendingTarget {
     validators: SharedWeak<NodeValidators>,
     location: Location,
     absolute_path: Option<Arc<Uri<String>>>,
+    applicable_types: JsonTypeSet,
 }
 
 enum NodeValidators {
@@ -89,6 +92,15 @@ struct ArrayValidatorEntry {
     absolute_location: Option<Arc<Uri<String>>>,
 }
 
+fn merged_applicable_types<'a, I>(validators: I) -> JsonTypeSet
+where
+    I: Iterator<Item = &'a BoxedValidator>,
+{
+    validators.fold(JsonTypeSet::all(), |acc, validator| {
+        acc.intersection(validator.applicable_types())
+    })
+}
+
 impl PendingSchemaNode {
     pub(crate) fn new() -> Self {
         PendingSchemaNode {
@@ -101,6 +113,7 @@ impl PendingSchemaNode {
             validators: Shared::downgrade(&node.validators),
             location: node.location.clone(),
             absolute_path: node.absolute_path.clone(),
+            applicable_types: node.applicable_types,
         };
         self.cell
             .set(target)
@@ -134,6 +147,7 @@ impl PendingTarget {
             validators,
             location: self.location.clone(),
             absolute_path: self.absolute_path.clone(),
+            applicable_types: self.applicable_types,
         }
     }
 }
@@ -162,9 +176,13 @@ impl Validate for PendingSchemaNode {
 
 impl SchemaNode {
     pub(crate) fn from_boolean(ctx: &Context<'_>, validator: Option<BoxedValidator>) -> SchemaNode {
+        let applicable_types = validator
+            .as_ref()
+            .map_or(JsonTypeSet::all(), |validator| validator.applicable_types());
         SchemaNode {
             location: ctx.location().clone(),
             absolute_path: ctx.base_uri(),
+            applicable_types,
             validators: Shared::new(NodeValidators::Boolean { validator }),
         }
     }
@@ -186,10 +204,13 @@ impl SchemaNode {
                     absolute_location,
                 }
             })
-            .collect();
+            .collect::<Vec<_>>();
+        let applicable_types =
+            merged_applicable_types(validators.iter().map(|entry| &entry.validator));
         SchemaNode {
             location: ctx.location().clone(),
             absolute_path,
+            applicable_types,
             validators: Shared::new(NodeValidators::Keyword(KeywordValidators {
                 unmatched_keywords,
                 validators,
@@ -211,10 +232,13 @@ impl SchemaNode {
                     absolute_location,
                 }
             })
-            .collect();
+            .collect::<Vec<_>>();
+        let applicable_types =
+            merged_applicable_types(validators.iter().map(|entry| &entry.validator));
         SchemaNode {
             location: ctx.location().clone(),
             absolute_path,
+            applicable_types,
             validators: Shared::new(NodeValidators::Array { validators }),
         }
     }
@@ -228,6 +252,7 @@ impl SchemaNode {
             validators: self.validators.clone(),
             location,
             absolute_path,
+            applicable_types: self.applicable_types,
         }
     }
 
@@ -466,6 +491,9 @@ impl Validate for SchemaNode {
     }
 
     fn is_valid(&self, instance: &Value) -> bool {
+        if !self.applicable_types.contains_value_type(instance) {
+            return false;
+        }
         match self.validators.as_ref() {
             // If we only have one validator then calling it's `is_valid` directly does
             // actually save the 20 or so instructions required to call the `slice::Iter::all`
diff --git a/crates/jsonschema/src/types.rs b/crates/jsonschema/src/types.rs
diff --git a/crates/jsonschema/src/validator.rs b/crates/jsonschema/src/validator.rs

Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,10 @@`
`1`	`1`	`use crate::{`
`2`		`- compiler, error::ValidationError, ext::cmp, keywords::CompilationResult, paths::Location,`
	`2`	`+ compiler,`
	`3`	`+ error::ValidationError,`
	`4`	`+ ext::cmp,`
	`5`	`+ keywords::CompilationResult,`
	`6`	`+ paths::Location,`
	`7`	`+ types::{JsonType, JsonTypeSet},`
`3`	`8`	`validator::Validate,`
`4`	`9`	`};`
`5`	`10`	`use serde_json::{Map, Number, Value};`
`@@ -45,6 +50,10 @@ impl Validate for ConstArrayValidator {`
`45`	`50`	`false`
`46`	`51`	`}`
`47`	`52`	`}`
	`53`	`+`
	`54`	`+ fn applicable_types(&self) -> JsonTypeSet {`
	`55`	`+ JsonTypeSet::empty().insert(JsonType::Array)`
	`56`	`+ }`
`48`	`57`	`}`
`49`	`58`
`50`	`59`	`struct ConstBooleanValidator {`
`@@ -83,6 +92,10 @@ impl Validate for ConstBooleanValidator {`
`83`	`92`	`false`
`84`	`93`	`}`
`85`	`94`	`}`
	`95`	`+`
	`96`	`+ fn applicable_types(&self) -> JsonTypeSet {`
	`97`	`+ JsonTypeSet::empty().insert(JsonType::Boolean)`
	`98`	`+ }`
`86`	`99`	`}`
`87`	`100`
`88`	`101`	`struct ConstNullValidator {`
`@@ -114,6 +127,10 @@ impl Validate for ConstNullValidator {`
`114`	`127`	`fn is_valid(&self, instance: &Value) -> bool {`
`115`	`128`	`instance.is_null()`
`116`	`129`	`}`
	`130`	`+`
	`131`	`+ fn applicable_types(&self) -> JsonTypeSet {`
	`132`	`+ JsonTypeSet::empty().insert(JsonType::Null)`
	`133`	`+ }`
`117`	`134`	`}`
`118`	`135`
`119`	`136`	`struct ConstNumberValidator {`
`@@ -157,6 +174,14 @@ impl Validate for ConstNumberValidator {`
`157`	`174`	`false`
`158`	`175`	`}`
`159`	`176`	`}`
	`177`	`+`
	`178`	`+ fn applicable_types(&self) -> JsonTypeSet {`
	`179`	`+ let mut set = JsonTypeSet::empty().insert(JsonType::Number);`
	`180`	`+ if self.original_value.is_i64() \|\| self.original_value.is_u64() {`
	`181`	`+ set = set.insert(JsonType::Integer);`
	`182`	`+ }`
	`183`	`+ set`
	`184`	`+ }`
`160`	`185`	`}`
`161`	`186`
`162`	`187`	`pub(crate) struct ConstObjectValidator {`
`@@ -198,6 +223,10 @@ impl Validate for ConstObjectValidator {`
`198`	`223`	`false`
`199`	`224`	`}`
`200`	`225`	`}`
	`226`	`+`
	`227`	`+ fn applicable_types(&self) -> JsonTypeSet {`
	`228`	`+ JsonTypeSet::empty().insert(JsonType::Object)`
	`229`	`+ }`
`201`	`230`	`}`
`202`	`231`
`203`	`232`	`pub(crate) struct ConstStringValidator {`
`@@ -239,6 +268,10 @@ impl Validate for ConstStringValidator {`
`239`	`268`	`false`
`240`	`269`	`}`
`241`	`270`	`}`
	`271`	`+`
	`272`	`+ fn applicable_types(&self) -> JsonTypeSet {`
	`273`	`+ JsonTypeSet::empty().insert(JsonType::String)`
	`274`	`+ }`
`242`	`275`	`}`
`243`	`276`
`244`	`277`	`#[inline]`
Original file line number	Diff line number	Diff line change
`@@ -27,7 +27,7 @@ impl EnumValidator {`
`27`	`27`	`) -> CompilationResult<'a> {`
`28`	`28`	`let mut types = JsonTypeSet::empty();`
`29`	`29`	`for item in items {`
`30`		`- types = types.insert(JsonType::from(item));`
	`30`	`+ types = types.union(JsonTypeSet::from_value(item));`
`31`	`31`	`}`
`32`	`32`	`Ok(Box::new(EnumValidator {`
`33`	`33`	`options: schema.clone(),`
`@@ -66,13 +66,18 @@ impl Validate for EnumValidator {`
`66`	`66`	`false`
`67`	`67`	`}`
`68`	`68`	`}`
	`69`	`+`
	`70`	`+ fn applicable_types(&self) -> JsonTypeSet {`
	`71`	`+ self.types`
	`72`	`+ }`
`69`	`73`	`}`
`70`	`74`
`71`	`75`	`#[derive(Debug)]`
`72`	`76`	`pub(crate) struct SingleValueEnumValidator {`
`73`	`77`	`value: Value,`
`74`	`78`	`options: Value,`
`75`	`79`	`location: Location,`
	`80`	`+ types: JsonTypeSet,`
`76`	`81`	`}`
`77`	`82`
`78`	`83`	`impl SingleValueEnumValidator {`
`@@ -86,6 +91,7 @@ impl SingleValueEnumValidator {`
`86`	`91`	`options: schema.clone(),`
`87`	`92`	`value: value.clone(),`
`88`	`93`	`location,`
	`94`	`+ types: JsonTypeSet::from_value(value),`
`89`	`95`	`}))`
`90`	`96`	`}`
`91`	`97`	`}`
`@@ -111,6 +117,10 @@ impl Validate for SingleValueEnumValidator {`
`111`	`117`	`fn is_valid(&self, instance: &Value) -> bool {`
`112`	`118`	`cmp::equal(&self.value, instance)`
`113`	`119`	`}`
	`120`	`+`
	`121`	`+ fn applicable_types(&self) -> JsonTypeSet {`
	`122`	`+ self.types`
	`123`	`+ }`
`114`	`124`	`}`
`115`	`125`
`116`	`126`	`#[inline]`
Original file line number	Diff line number	Diff line change
`@@ -68,6 +68,10 @@ impl Validate for MultipleTypesValidator {`
`68`	`68`	`))`
`69`	`69`	`}`
`70`	`70`	`}`
	`71`	`+`
	`72`	`+ fn applicable_types(&self) -> JsonTypeSet {`
	`73`	`+ self.types`
	`74`	`+ }`
`71`	`75`	`}`
`72`	`76`
`73`	`77`	`pub(crate) struct IntegerTypeValidator {`
`@@ -105,6 +109,10 @@ impl Validate for IntegerTypeValidator {`
`105`	`109`	`))`
`106`	`110`	`}`
`107`	`111`	`}`
	`112`	`+`
	`113`	`+ fn applicable_types(&self) -> JsonTypeSet {`
	`114`	`+ JsonTypeSet::empty().insert(JsonType::Integer)`
	`115`	`+ }`
`108`	`116`	`}`
`109`	`117`
`110`	`118`	`fn is_integer(num: &Number) -> bool {`
Original file line number	Diff line number	Diff line change
`@@ -70,6 +70,10 @@ impl Validate for MultipleTypesValidator {`
`70`	`70`	`))`
`71`	`71`	`}`
`72`	`72`	`}`
	`73`	`+`
	`74`	`+ fn applicable_types(&self) -> JsonTypeSet {`
	`75`	`+ self.types`
	`76`	`+ }`
`73`	`77`	`}`
`74`	`78`
`75`	`79`	`pub(crate) struct NullTypeValidator {`
`@@ -103,6 +107,10 @@ impl Validate for NullTypeValidator {`
`103`	`107`	`))`
`104`	`108`	`}`
`105`	`109`	`}`
	`110`	`+`
	`111`	`+ fn applicable_types(&self) -> JsonTypeSet {`
	`112`	`+ JsonTypeSet::empty().insert(JsonType::Null)`
	`113`	`+ }`
`106`	`114`	`}`
`107`	`115`
`108`	`116`	`pub(crate) struct BooleanTypeValidator {`
`@@ -136,6 +144,10 @@ impl Validate for BooleanTypeValidator {`
`136`	`144`	`))`
`137`	`145`	`}`
`138`	`146`	`}`
	`147`	`+`
	`148`	`+ fn applicable_types(&self) -> JsonTypeSet {`
	`149`	`+ JsonTypeSet::empty().insert(JsonType::Boolean)`
	`150`	`+ }`
`139`	`151`	`}`
`140`	`152`
`141`	`153`	`pub(crate) struct StringTypeValidator {`
`@@ -170,6 +182,10 @@ impl Validate for StringTypeValidator {`
`170`	`182`	`))`
`171`	`183`	`}`
`172`	`184`	`}`
	`185`	`+`
	`186`	`+ fn applicable_types(&self) -> JsonTypeSet {`
	`187`	`+ JsonTypeSet::empty().insert(JsonType::String)`
	`188`	`+ }`
`173`	`189`	`}`
`174`	`190`
`175`	`191`	`pub(crate) struct ArrayTypeValidator {`
`@@ -204,6 +220,10 @@ impl Validate for ArrayTypeValidator {`
`204`	`220`	`))`
`205`	`221`	`}`
`206`	`222`	`}`
	`223`	`+`
	`224`	`+ fn applicable_types(&self) -> JsonTypeSet {`
	`225`	`+ JsonTypeSet::empty().insert(JsonType::Array)`
	`226`	`+ }`
`207`	`227`	`}`
`208`	`228`
`209`	`229`	`pub(crate) struct ObjectTypeValidator {`
`@@ -237,6 +257,10 @@ impl Validate for ObjectTypeValidator {`
`237`	`257`	`))`
`238`	`258`	`}`
`239`	`259`	`}`
	`260`	`+`
	`261`	`+ fn applicable_types(&self) -> JsonTypeSet {`
	`262`	`+ JsonTypeSet::empty().insert(JsonType::Object)`
	`263`	`+ }`
`240`	`264`	`}`
`241`	`265`
`242`	`266`	`pub(crate) struct NumberTypeValidator {`
`@@ -270,6 +294,10 @@ impl Validate for NumberTypeValidator {`
`270`	`294`	`))`
`271`	`295`	`}`
`272`	`296`	`}`
	`297`	`+`
	`298`	`+ fn applicable_types(&self) -> JsonTypeSet {`
	`299`	`+ JsonTypeSet::empty().insert(JsonType::Number)`
	`300`	`+ }`
`273`	`301`	`}`
`274`	`302`
`275`	`303`	`pub(crate) struct IntegerTypeValidator {`
`@@ -307,6 +335,10 @@ impl Validate for IntegerTypeValidator {`
`307`	`335`	`))`
`308`	`336`	`}`
`309`	`337`	`}`
	`338`	`+`
	`339`	`+ fn applicable_types(&self) -> JsonTypeSet {`
	`340`	`+ JsonTypeSet::empty().insert(JsonType::Integer)`
	`341`	`+ }`
`310`	`342`	`}`
`311`	`343`
`312`	`344`	`fn is_integer(num: &Number) -> bool {`