Simplier recursive impl

Author: zesterer

Cargo.toml

@@ -35,10 +35,6 @@ memoization = []
 # Allows extending chumsky by writing your own parser implementations.
 extension = []
 
-# Make builtin parsers such as `Boxed` use atomic instead of non-atomic internals.
-# TODO: Remove or rework this
-sync = ["spin"]
-
 # Enable Pratt parsing combinator
 pratt = []
 
@@ -66,7 +62,7 @@ docsrs = []
 # An alias of all features that work with the stable compiler.
 # Do not use this feature, its removal is not considered a breaking change and its behaviour may change.
 # If you're working on chumsky and you're adding a feature that does not require nightly support, please add it to this list.
-_test_stable = ["std", "stacker", "memoization", "extension", "sync", "pratt"]
+_test_stable = ["std", "stacker", "memoization", "extension", "pratt"]
 
 [package.metadata.docs.rs]
 all-features = true
@@ -76,7 +72,7 @@ rustdoc-args = ["--cfg", "docsrs"]
 hashbrown = "0.15"
 stacker = { version = "0.1", optional = true }
 regex-automata = { version = "0.3", default-features = false, optional = true, features = ["alloc", "meta", "perf", "unicode", "nfa", "dfa", "hybrid"] }
-spin = { version = "0.9", features = ["once"], default-features = false, optional = true }
+spin = { version = "0.9", features = ["once"], default-features = false }
 lexical = { version = "6.1.1", default-features = false, features = ["parse-integers", "parse-floats", "format"], optional = true }
 either = { version = "1.8.1", optional = true }
 serde = { version = "1.0", default-features = false, optional = true, features = ["derive"] }

examples/mini_ml.rs

@@ -116,7 +116,7 @@ where
     I: BorrowInput<'tokens, Token = Token<'src>, Span = SimpleSpan>,
     // Because this function is generic over the input type, we need the caller to tell us how to create a new input,
     // `I`, from a nested token tree. This function serves that purpose.
-    M: Fn(SimpleSpan, &'tokens [Spanned<Token<'src>>]) -> I + Clone + 'src,
+    M: Fn(SimpleSpan, &'tokens [Spanned<Token<'src>>]) -> I + Clone + Send + Sync + 'src,
 {
     recursive(|expr| {
         let ident = select_ref! { Token::Ident(x) => *x };

examples/nested_spans.rs

@@ -13,7 +13,7 @@ enum Token {
 fn parser<'src, I, M>(make_input: M) -> impl Parser<'src, I, i64>
 where
     I: BorrowInput<'src, Token = Token, Span = SimpleSpan>,
-    M: Fn(SimpleSpan, &'src [(Token, SimpleSpan)]) -> I + Clone + 'src,
+    M: Fn(SimpleSpan, &'src [(Token, SimpleSpan)]) -> I + Send + Sync + Clone + 'src,
 {
     recursive(|expr| {
         let num = select_ref! { Token::Num(x) => *x };

src/recursive.rs

@@ -10,31 +10,6 @@
 
 use super::*;
 
-struct OnceCell<T>(core::cell::Cell<Option<T>>);
-impl<T> OnceCell<T> {
-    pub fn new() -> Self {
-        Self(core::cell::Cell::new(None))
-    }
-    pub fn set(&self, x: T) -> Result<(), ()> {
-        // SAFETY: Function is not reentrant so we have exclusive access to the inner data
-        unsafe {
-            let vacant = (*self.0.as_ptr()).is_none();
-            if vacant {
-                self.0.as_ptr().write(Some(x));
-                Ok(())
-            } else {
-                Err(())
-            }
-        }
-    }
-    #[inline]
-    pub fn get(&self) -> Option<&T> {
-        // SAFETY: We ensure that we never insert twice (so the inner `T` always lives as long as us, if it exists) and
-        // neither function is possibly reentrant so there's no way we can invalidate mut xor shared aliasing
-        unsafe { (*self.0.as_ptr()).as_ref() }
-    }
-}
-
 // TODO: Ensure that this doesn't produce leaks
 enum RecursiveInner<T: ?Sized> {
     Owned(Arc<T>),
@@ -48,7 +23,7 @@ pub type Direct<'src, 'b, I, O, Extra> = DynParser<'src, 'b, I, O, Extra>;
 /// Type for recursive parsers that are defined through a call to [`Recursive::declare`], and as
 /// such require an additional layer of allocation.
 pub struct Indirect<'src, 'b, I: Input<'src>, O, Extra: ParserExtra<'src, I>> {
-    inner: OnceCell<Box<DynParser<'src, 'b, I, O, Extra>>>,
+    inner: spin::Once<Box<DynParser<'src, 'b, I, O, Extra>>>,
 }
 
 /// A parser that can be defined in terms of itself by separating its [declaration](Recursive::declare) from its
@@ -101,22 +76,14 @@ impl<'src, 'b, I: Input<'src>, O, E: ParserExtra<'src, I>> Recursive<Indirect<'s
     pub fn declare() -> Self {
         Recursive {
             inner: RecursiveInner::Owned(Arc::new(Indirect {
-                inner: OnceCell::new(),
+                inner: spin::Once::new(),
             })),
         }
     }
 
     /// Defines the parser after declaring it, allowing it to be used for parsing.
-    // INFO: Clone bound not actually needed, but good to be safe for future compat
-    #[track_caller]
-    pub fn define<P: Parser<'src, I, O, E> + Clone + Send + Sync + 'b>(&mut self, parser: P) {
-        let location = *Location::caller();
-        self.parser()
-            .inner
-            .set(Box::new(parser))
-            .unwrap_or_else(|_| {
-                panic!("recursive parsers can only be defined once, trying to redefine it at {location}")
-            });
+    pub fn define<P: Parser<'src, I, O, E> + Send + Sync + 'b>(&mut self, parser: P) {
+        self.parser().inner.call_once(|| Box::new(parser));
     }
 }
 
@@ -243,7 +210,7 @@ pub fn recursive<'src, 'b, I, O, E, A, F>(f: F) -> Recursive<Direct<'src, 'b, I,
 where
     I: Input<'src>,
     E: ParserExtra<'src, I>,
-    A: Parser<'src, I, O, E> + Clone + Send + Sync + 'b,
+    A: Parser<'src, I, O, E> + Send + Sync + 'b,
     F: FnOnce(Recursive<Direct<'src, 'b, I, O, E>>) -> A,
 {
     let rc = Arc::new_cyclic(|rc| {

src/text.rs

@@ -1101,7 +1101,7 @@ mod tests {
     fn make_ascii_kw_parser<'src, I>(s: I::Slice) -> impl Parser<'src, I, ()>
     where
         I: crate::StrInput<'src>,
-        I::Slice: PartialEq + Clone,
+        I::Slice: PartialEq + Send + Sync + Clone,
         I::Token: crate::Char + fmt::Debug + 'src,
     {
         text::ascii::keyword(s).ignored()
@@ -1110,7 +1110,7 @@ mod tests {
     fn make_unicode_kw_parser<'src, I>(s: I::Slice) -> impl Parser<'src, I, ()>
     where
         I: crate::StrInput<'src>,
-        I::Slice: PartialEq + Clone,
+        I::Slice: PartialEq + Clone + Send + Sync,
         I::Token: crate::Char + fmt::Debug + 'src,
     {
         text::unicode::keyword(s).ignored()