feat: make MainEngine Send and Sync

Changed `Rc` to `Arc` in the automaton labels. 
Added static_assert that MainEngine implements Send+Sync

---------

Co-authored-by: Ivan Azoyan <i..azoyan@dats.team>

Author: azoyan

crates/rsonpath-lib/Cargo.toml

@@ -54,4 +54,4 @@ path = "examples/approx_spans_usage.rs"
 doc-scrape-examples = true
 
 [lints]
-workspace = true
+workspace = true

crates/rsonpath-lib/src/automaton.rs

@@ -12,20 +12,20 @@ use crate::{automaton::error::CompilerError, debug, string_pattern::StringPatter
 use nfa::NondeterministicAutomaton;
 use rsonpath_syntax::{num::JsonUInt, JsonPathQuery};
 use smallvec::SmallVec;
-use std::{fmt::Display, ops::Index, rc::Rc};
+use std::{fmt::Display, ops::Index, sync::Arc};
 
 /// A minimal, deterministic automaton representing a JSONPath query.
-#[derive(Debug, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq)]
 pub struct Automaton {
     states: Vec<StateTable>,
 }
 
 /// Transition when a JSON member name matches a [`StringPattern`].
-pub type MemberTransition = (Rc<StringPattern>, State);
+pub type MemberTransition = (Arc<StringPattern>, State);
 
 /// Transition on elements of an array with indices specified by either a single index
 /// or a simple slice expression.
-#[derive(Debug, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq)]
 pub struct ArrayTransition {
     label: ArrayTransitionLabel,
     target: State,
@@ -44,7 +44,7 @@ pub(super) enum ArrayTransitionLabel {
 ///
 /// Contains transitions triggered by matching member names or array indices, and a fallback transition
 /// triggered when none of the labelled transitions match.
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct StateTable {
     attributes: StateAttributes,
     member_transitions: SmallVec<[MemberTransition; 2]>,

crates/rsonpath-lib/src/automaton/minimizer.rs

@@ -1,6 +1,6 @@
 //! Determinization and minimization of an NFA into the final DFA used by the engines.
 
-use std::rc::Rc;
+use std::sync::Arc;
 
 // NOTE: Some comments in this module are outdated, because the minimizer doesn't
 // actually produce minimal automata as of now - see #91.
@@ -50,7 +50,7 @@ pub(super) struct Minimizer {
 #[derive(Debug)]
 struct SuperstateTransitionTable {
     array: ArrayTransitionSet,
-    member: VecMap<Rc<StringPattern>, SmallSet256>,
+    member: VecMap<Arc<StringPattern>, SmallSet256>,
     wildcard: SmallSet256,
 }
 
@@ -177,7 +177,7 @@ impl Minimizer {
         &self,
         id: DfaStateId,
         array_transitions: &[ArrayTransition],
-        member_transitions: &[(Rc<StringPattern>, DfaStateId)],
+        member_transitions: &[(Arc<StringPattern>, DfaStateId)],
         fallback: DfaStateId,
     ) -> StateAttributes {
         let mut attrs = StateAttributesBuilder::new();
@@ -554,8 +554,8 @@ mod tests {
     #[test]
     fn interstitial_descendant_wildcard() {
         // Query = $..a.b..*.a..b
-        let label_a = Rc::new(StringPattern::new(&JsonString::new("a")));
-        let label_b = Rc::new(StringPattern::new(&JsonString::new("b")));
+        let label_a = Arc::new(StringPattern::new(&JsonString::new("a")));
+        let label_b = Arc::new(StringPattern::new(&JsonString::new("b")));
 
         let nfa = NondeterministicAutomaton {
             ordered_states: vec![
@@ -623,8 +623,8 @@ mod tests {
     #[test]
     fn interstitial_nondescendant_wildcard() {
         // Query = $..a.b.*.a..b
-        let label_a = Rc::new(StringPattern::new(&JsonString::new("a")));
-        let label_b = Rc::new(StringPattern::new(&JsonString::new("b")));
+        let label_a = Arc::new(StringPattern::new(&JsonString::new("a")));
+        let label_b = Arc::new(StringPattern::new(&JsonString::new("b")));
 
         let nfa = NondeterministicAutomaton {
             ordered_states: vec![
@@ -698,7 +698,7 @@ mod tests {
     #[test]
     fn simple_multi_accepting() {
         // Query = $..a.*
-        let label = Rc::new(StringPattern::new(&JsonString::new("a")));
+        let label = Arc::new(StringPattern::new(&JsonString::new("a")));
 
         let nfa = NondeterministicAutomaton {
             ordered_states: vec![
@@ -796,7 +796,7 @@ mod tests {
     #[test]
     fn chained_wildcard_children() {
         // Query = $.a.*.*.*
-        let label = Rc::new(StringPattern::new(&JsonString::new("a")));
+        let label = Arc::new(StringPattern::new(&JsonString::new("a")));
 
         let nfa = NondeterministicAutomaton {
             ordered_states: vec![
@@ -857,7 +857,7 @@ mod tests {
     #[test]
     fn chained_wildcard_children_after_descendant() {
         // Query = $..a.*.*
-        let label = Rc::new(StringPattern::new(&JsonString::new("a")));
+        let label = Arc::new(StringPattern::new(&JsonString::new("a")));
 
         let nfa = NondeterministicAutomaton {
             ordered_states: vec![
@@ -935,11 +935,11 @@ mod tests {
     #[test]
     fn child_and_descendant() {
         // Query = $.x..a.b.a.b.c..d
-        let label_a = Rc::new(StringPattern::new(&JsonString::new("a")));
-        let label_b = Rc::new(StringPattern::new(&JsonString::new("b")));
-        let label_c = Rc::new(StringPattern::new(&JsonString::new("c")));
-        let label_d = Rc::new(StringPattern::new(&JsonString::new("d")));
-        let label_x = Rc::new(StringPattern::new(&JsonString::new("x")));
+        let label_a = Arc::new(StringPattern::new(&JsonString::new("a")));
+        let label_b = Arc::new(StringPattern::new(&JsonString::new("b")));
+        let label_c = Arc::new(StringPattern::new(&JsonString::new("c")));
+        let label_d = Arc::new(StringPattern::new(&JsonString::new("d")));
+        let label_x = Arc::new(StringPattern::new(&JsonString::new("x")));
 
         let nfa = NondeterministicAutomaton {
             ordered_states: vec![
@@ -1021,9 +1021,9 @@ mod tests {
     #[test]
     fn child_descendant_and_child_wildcard() {
         // Query = $.x.*..a.*.b
-        let label_a = Rc::new(StringPattern::new(&JsonString::new("a")));
-        let label_b = Rc::new(StringPattern::new(&JsonString::new("b")));
-        let label_x = Rc::new(StringPattern::new(&JsonString::new("x")));
+        let label_a = Arc::new(StringPattern::new(&JsonString::new("a")));
+        let label_b = Arc::new(StringPattern::new(&JsonString::new("b")));
+        let label_x = Arc::new(StringPattern::new(&JsonString::new("x")));
 
         let nfa = NondeterministicAutomaton {
             ordered_states: vec![
@@ -1103,10 +1103,10 @@ mod tests {
     #[test]
     fn all_name_and_wildcard_selectors() {
         // Query = $.a.b..c..d.*..*
-        let label_a = Rc::new(StringPattern::new(&JsonString::new("a")));
-        let label_b = Rc::new(StringPattern::new(&JsonString::new("b")));
-        let label_c = Rc::new(StringPattern::new(&JsonString::new("c")));
-        let label_d = Rc::new(StringPattern::new(&JsonString::new("d")));
+        let label_a = Arc::new(StringPattern::new(&JsonString::new("a")));
+        let label_b = Arc::new(StringPattern::new(&JsonString::new("b")));
+        let label_c = Arc::new(StringPattern::new(&JsonString::new("c")));
+        let label_d = Arc::new(StringPattern::new(&JsonString::new("d")));
 
         let nfa = NondeterministicAutomaton {
             ordered_states: vec![

crates/rsonpath-lib/src/automaton/nfa.rs

@@ -5,7 +5,7 @@ use crate::{automaton::SimpleSlice, error::UnsupportedFeatureError, string_patte
 
 use super::{error::CompilerError, ArrayTransitionLabel};
 use rsonpath_syntax::{str::JsonString, JsonPathQuery, Step};
-use std::{collections::HashMap, fmt::Display, ops::Index, rc::Rc};
+use std::{collections::HashMap, fmt::Display, ops::Index, sync::Arc};
 
 /// An NFA representing a query. It is always a directed path
 /// from an initial state to the unique accepting state at the end,
@@ -34,7 +34,7 @@ pub(super) enum Transition {
     /// A transition matching array indices.
     Array(ArrayTransitionLabel),
     /// A transition matching a specific member.
-    Member(Rc<StringPattern>),
+    Member(Arc<StringPattern>),
     /// A transition matching anything.
     Wildcard,
 }
@@ -71,7 +71,7 @@ impl NondeterministicAutomaton {
         use rsonpath_syntax::{Index, Selector};
         use std::collections::hash_map::Entry;
 
-        let mut string_pattern_cache: HashMap<&'q JsonString, Rc<StringPattern>> = HashMap::new();
+        let mut string_pattern_cache: HashMap<&'q JsonString, Arc<StringPattern>> = HashMap::new();
 
         let states_result: Result<Vec<NfaState>, CompilerError> = query
             .segments()
@@ -87,7 +87,7 @@ impl NondeterministicAutomaton {
                             let pattern = match string_pattern_cache.entry(name) {
                                 Entry::Occupied(pat) => pat.get().clone(),
                                 Entry::Vacant(entry) => {
-                                    let pat = Rc::new(StringPattern::new(name));
+                                    let pat = Arc::new(StringPattern::new(name));
                                     entry.insert(pat.clone());
                                     pat
                                 }
@@ -242,10 +242,10 @@ mod tests {
 
         let expected_automaton = NondeterministicAutomaton {
             ordered_states: vec![
-                NfaState::Direct(Transition::Member(Rc::new(StringPattern::new(&label_a)))),
-                NfaState::Direct(Transition::Member(Rc::new(StringPattern::new(&label_b)))),
-                NfaState::Recursive(Transition::Member(Rc::new(StringPattern::new(&label_c)))),
-                NfaState::Recursive(Transition::Member(Rc::new(StringPattern::new(&label_d)))),
+                NfaState::Direct(Transition::Member(Arc::new(StringPattern::new(&label_a)))),
+                NfaState::Direct(Transition::Member(Arc::new(StringPattern::new(&label_b)))),
+                NfaState::Recursive(Transition::Member(Arc::new(StringPattern::new(&label_c)))),
+                NfaState::Recursive(Transition::Member(Arc::new(StringPattern::new(&label_d)))),
                 NfaState::Direct(Transition::Wildcard),
                 NfaState::Direct(Transition::Wildcard),
                 NfaState::Recursive(Transition::Wildcard),

crates/rsonpath-lib/src/engine/head_skipping.rs

@@ -1,7 +1,8 @@
 //! Engine decorator that performs **head skipping** – an extremely optimized search for
 //! the first matching member name in a query starting with a self-looping state.
 //! This happens in queries starting with a descendant selector.
-use std::rc::Rc;
+
+use std::sync::Arc;
 
 use crate::{
     automaton::{Automaton, State},
@@ -67,7 +68,7 @@ pub(super) struct HeadSkip<'b, I, V, const N: usize> {
     bytes: &'b I,
     state: State,
     is_accepting: bool,
-    member_name: Rc<StringPattern>,
+    member_name: Arc<StringPattern>,
     simd: V,
 }
 

crates/rsonpath-lib/src/engine/main.rs

@@ -69,12 +69,15 @@ use smallvec::{smallvec, SmallVec};
 ///
 /// The engine is stateless, meaning that it can be executed
 /// on any number of separate inputs, even on separate threads.
-#[derive(Debug)]
+
+#[derive(Clone, Debug)]
 pub struct MainEngine {
     automaton: Automaton,
     simd: SimdConfiguration,
 }
 
+static_assertions::assert_impl_all!(MainEngine: Send, Sync);
+
 impl Compiler for MainEngine {
     type E = Self;