Make send/sync the default for crate abstractions

Author: zesterer

Cargo.toml

@@ -40,7 +40,7 @@ extension = []
 sync = ["spin"]
 
 # Enable Pratt parsing combinator
-pratt = ["unstable"]
+pratt = []
 
 # Allow the use of unstable features (aka features where the API is not settled)
 unstable = []
@@ -66,7 +66,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"]
+_test_stable = ["std", "stacker", "memoization", "extension", "sync", "pratt"]
 
 [package.metadata.docs.rs]
 all-features = true

src/lib.rs

@@ -89,8 +89,8 @@ pub mod prelude {
 use crate::input::InputOwn;
 use alloc::{
     boxed::Box,
-    rc::{self, Rc},
     string::String,
+    sync::{Arc, Weak},
     vec,
     vec::Vec,
 };
@@ -157,9 +157,10 @@ impl<T> Unpin for EmptyPhantom<T> {}
 impl<T> core::panic::UnwindSafe for EmptyPhantom<T> {}
 impl<T> core::panic::RefUnwindSafe for EmptyPhantom<T> {}
 
-pub(crate) type DynParser<'src, 'b, I, O, E> = dyn Parser<'src, I, O, E> + 'b;
+pub(crate) type DynParser<'src, 'b, I, O, E> = dyn Parser<'src, I, O, E> + Send + Sync + 'b;
 #[cfg(feature = "pratt")]
-pub(crate) type DynOperator<'src, 'b, I, O, E> = dyn pratt::Operator<'src, I, O, E> + 'b;
+pub(crate) type DynOperator<'src, 'b, I, O, E> =
+    dyn pratt::Operator<'src, I, O, E> + Send + Sync + 'b;
 
 /// Labels corresponding to a variety of patterns.
 #[derive(Clone, Debug, PartialEq)]
@@ -2201,10 +2202,10 @@ pub trait Parser<'src, I: Input<'src>, O, E: ParserExtra<'src, I> = extra::Defau
     ///
     fn boxed<'b>(self) -> Boxed<'src, 'b, I, O, E>
     where
-        Self: Sized + 'b,
+        Self: Sized + Send + Sync + 'b,
     {
         Boxed {
-            inner: Rc::new(self),
+            inner: Arc::new(self),
         }
     }
 
@@ -2795,12 +2796,11 @@ where
 
 /// See [`Parser::boxed`].
 ///
-/// Due to current implementation details, the inner value is not, in fact, a [`Box`], but is an [`Rc`] to facilitate
-/// efficient cloning. This is likely to change in the future. Unlike [`Box`], [`Rc`] has no size guarantees: although
+/// Due to current implementation details, the inner value is not, in fact, a [`Box`], but is an [`Arc`] to facilitate
+/// efficient cloning. This is likely to change in the future. Unlike [`Box`], [`Arc`] has no size guarantees: although
 /// it is *currently* the same size as a raw pointer.
-// TODO: Don't use an Rc (why?)
 pub struct Boxed<'src, 'b, I: Input<'src>, O, E: ParserExtra<'src, I> = extra::Default> {
-    inner: Rc<DynParser<'src, 'b, I, O, E>>,
+    inner: Arc<DynParser<'src, 'b, I, O, E>>,
 }
 
 impl<'src, I: Input<'src>, O, E: ParserExtra<'src, I>> Clone for Boxed<'src, '_, I, O, E> {

src/pratt.rs

@@ -205,9 +205,9 @@ where
     /// Box this operator, allowing it to be used via dynamic dispatch.
     fn boxed<'a>(self) -> Boxed<'src, 'a, I, O, E>
     where
-        Self: Sized + 'a,
+        Self: Sized + Send + Sync + 'a,
     {
-        Boxed(Rc::new(self))
+        Boxed(Arc::new(self))
     }
 
     #[doc(hidden)]
@@ -317,7 +317,7 @@ where
 }
 
 /// A boxed pratt parser operator. See [`Operator`].
-pub struct Boxed<'src, 'a, I, O, E = extra::Default>(Rc<DynOperator<'src, 'a, I, O, E>>);
+pub struct Boxed<'src, 'a, I, O, E = extra::Default>(Arc<DynOperator<'src, 'a, I, O, E>>);
 
 impl<I, O, E> Clone for Boxed<'_, '_, I, O, E> {
     fn clone(&self) -> Self {

src/recovery.rs

@@ -239,10 +239,10 @@ pub fn nested_delimiters<'src, 'parse, I, O, E, F, const N: usize>(
 ) -> impl Parser<'src, I, O, E> + Clone + 'parse
 where
     I: ValueInput<'src>,
-    I::Token: PartialEq + Clone,
+    I::Token: PartialEq + Clone + Send + Sync,
     E: extra::ParserExtra<'src, I> + 'parse,
     'src: 'parse,
-    F: Fn(I::Span) -> O + Clone + 'parse,
+    F: Fn(I::Span) -> O + Clone + Send + Sync + 'parse,
 {
     // TODO: Does this actually work? TESTS!
     #[allow(clippy::tuple_array_conversions)]

src/recursive.rs

@@ -37,8 +37,8 @@ impl<T> OnceCell<T> {
 
 // TODO: Ensure that this doesn't produce leaks
 enum RecursiveInner<T: ?Sized> {
-    Owned(Rc<T>),
-    Unowned(rc::Weak<T>),
+    Owned(Arc<T>),
+    Unowned(Weak<T>),
 }
 
 /// Type for recursive parsers that are defined through a call to `recursive`, and as such
@@ -100,7 +100,7 @@ impl<'src, 'b, I: Input<'src>, O, E: ParserExtra<'src, I>> Recursive<Indirect<'s
     /// ```
     pub fn declare() -> Self {
         Recursive {
-            inner: RecursiveInner::Owned(Rc::new(Indirect {
+            inner: RecursiveInner::Owned(Arc::new(Indirect {
                 inner: OnceCell::new(),
             })),
         }
@@ -109,7 +109,7 @@ impl<'src, 'b, I: Input<'src>, O, E: ParserExtra<'src, I>> Recursive<Indirect<'s
     /// 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 + 'b>(&mut self, parser: P) {
+    pub fn define<P: Parser<'src, I, O, E> + Clone + Send + Sync + 'b>(&mut self, parser: P) {
         let location = *Location::caller();
         self.parser()
             .inner
@@ -122,7 +122,7 @@ impl<'src, 'b, I: Input<'src>, O, E: ParserExtra<'src, I>> Recursive<Indirect<'s
 
 impl<P: ?Sized> Recursive<P> {
     #[inline]
-    fn parser(&self) -> Rc<P> {
+    fn parser(&self) -> Arc<P> {
         match &self.inner {
             RecursiveInner::Owned(x) => x.clone(),
             RecursiveInner::Unowned(x) => x
@@ -243,11 +243,11 @@ 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 + 'b,
+    A: Parser<'src, I, O, E> + Clone + Send + Sync + 'b,
     F: FnOnce(Recursive<Direct<'src, 'b, I, O, E>>) -> A,
 {
-    let rc = Rc::new_cyclic(|rc| {
-        let rc: rc::Weak<DynParser<'src, 'b, I, O, E>> = rc.clone() as _;
+    let rc = Arc::new_cyclic(|rc| {
+        let rc: Weak<DynParser<'src, 'b, I, O, E>> = rc.clone() as _;
         let parser = Recursive {
             inner: RecursiveInner::Unowned(rc.clone()),
         };

src/text.rs

@@ -251,7 +251,8 @@ where
 /// // ...including none at all!
 /// assert_eq!(whitespace.parse("").into_result(), Ok(()));
 /// ```
-pub fn whitespace<'src, I, E>() -> Repeated<impl Parser<'src, I, (), E> + Copy, (), I, E>
+pub fn whitespace<'src, I, E>(
+) -> Repeated<impl Parser<'src, I, (), E> + Copy + Send + Sync, (), I, E>
 where
     I: StrInput<'src>,
     I::Token: Char + 'src,
@@ -287,7 +288,8 @@ where
 /// // ... but not newlines
 /// assert!(inline_whitespace.at_least(1).parse("\n\r").has_errors());
 /// ```
-pub fn inline_whitespace<'src, I, E>() -> Repeated<impl Parser<'src, I, (), E> + Copy, (), I, E>
+pub fn inline_whitespace<'src, I, E>(
+) -> Repeated<impl Parser<'src, I, (), E> + Copy + Send + Sync, (), I, E>
 where
     I: StrInput<'src>,
     I::Token: Char + 'src,
@@ -335,7 +337,7 @@ where
 /// assert_eq!(newline.parse("\u{2029}").into_result(), Ok(()));
 /// ```
 #[must_use]
-pub fn newline<'src, I, E>() -> impl Parser<'src, I, (), E> + Copy
+pub fn newline<'src, I, E>() -> impl Parser<'src, I, (), E> + Copy + Send + Sync
 where
     I: StrInput<'src>,
     I::Token: Char + 'src,
@@ -398,7 +400,7 @@ where
 #[must_use]
 pub fn digits<'src, I, E>(
     radix: u32,
-) -> Repeated<impl Parser<'src, I, <I as Input<'src>>::Token, E> + Copy, I::Token, I, E>
+) -> Repeated<impl Parser<'src, I, <I as Input<'src>>::Token, E> + Copy + Send + Sync, I::Token, I, E>
 where
     I: StrInput<'src>,
     I::Token: Char + 'src,
@@ -446,10 +448,12 @@ where
 /// ```
 ///
 #[must_use]
-pub fn int<'src, I, E>(radix: u32) -> impl Parser<'src, I, <I as SliceInput<'src>>::Slice, E> + Copy
+pub fn int<'src, I, E>(
+    radix: u32,
+) -> impl Parser<'src, I, <I as SliceInput<'src>>::Slice, E> + Copy + Send + Sync
 where
     I: StrInput<'src>,
-    I::Token: Char + 'src,
+    I::Token: Char + Send + Sync + 'src,
     E: ParserExtra<'src, I>,
     E::Error:
         LabelError<'src, I, TextExpected<'src, I>> + LabelError<'src, I, MaybeRef<'src, I::Token>>,
@@ -486,7 +490,8 @@ pub mod ascii {
     /// An identifier is defined as an ASCII alphabetic character or an underscore followed by any number of alphanumeric
     /// characters or underscores. The regex pattern for it is `[a-zA-Z_][a-zA-Z0-9_]*`.
     #[must_use]
-    pub fn ident<'src, I, E>() -> impl Parser<'src, I, <I as SliceInput<'src>>::Slice, E> + Copy
+    pub fn ident<'src, I, E>(
+    ) -> impl Parser<'src, I, <I as SliceInput<'src>>::Slice, E> + Copy + Send + Sync
     where
         I: StrInput<'src>,
         I::Token: Char + 'src,
@@ -539,12 +544,12 @@ pub mod ascii {
     #[track_caller]
     pub fn keyword<'src, I, S, E>(
         keyword: S,
-    ) -> impl Parser<'src, I, <I as SliceInput<'src>>::Slice, E> + Clone + 'src
+    ) -> impl Parser<'src, I, <I as SliceInput<'src>>::Slice, E> + Clone + Send + Sync + 'src
     where
         I: StrInput<'src>,
         I::Slice: PartialEq,
         I::Token: Char + fmt::Debug + 'src,
-        S: PartialEq<I::Slice> + Clone + 'src,
+        S: PartialEq<I::Slice> + Clone + Send + Sync + 'src,
         E: ParserExtra<'src, I> + 'src,
         E::Error: LabelError<'src, I, TextExpected<'src, I>> + LabelError<'src, I, S>,
     {
@@ -981,7 +986,8 @@ pub mod unicode {
     ///
     /// An identifier is defined as per "Default Identifiers" in [Unicode Standard Annex #31](https://www.unicode.org/reports/tr31/).
     #[must_use]
-    pub fn ident<'src, I, E>() -> impl Parser<'src, I, <I as SliceInput<'src>>::Slice, E> + Copy
+    pub fn ident<'src, I, E>(
+    ) -> impl Parser<'src, I, <I as SliceInput<'src>>::Slice, E> + Copy + Send + Sync
     where
         I: StrInput<'src>,
         I::Token: Char + 'src,
@@ -1028,12 +1034,12 @@ pub mod unicode {
     #[track_caller]
     pub fn keyword<'src, I, S, E>(
         keyword: S,
-    ) -> impl Parser<'src, I, <I as SliceInput<'src>>::Slice, E> + Clone + 'src
+    ) -> impl Parser<'src, I, <I as SliceInput<'src>>::Slice, E> + Clone + Send + Sync + 'src
     where
         I: StrInput<'src>,
         I::Slice: PartialEq,
         I::Token: Char + fmt::Debug + 'src,
-        S: PartialEq<I::Slice> + Clone + 'src,
+        S: PartialEq<I::Slice> + Clone + Send + Sync + 'src,
         E: ParserExtra<'src, I> + 'src,
         E::Error: LabelError<'src, I, TextExpected<'src, I>> + LabelError<'src, I, S>,
     {