Switch from `Rc` to `Arc`

3 files changed, 12 insertions, 12 deletions

diff --git a/src/parse/incremental.rs b/src/parse/incremental.rs
index c1da9698..a347f6ca 100644
--- a/src/parse/incremental.rs
+++ b/src/parse/incremental.rs
@@ -1,5 +1,5 @@
 use std::ops::Range;
-use std::rc::Rc;
+use std::sync::Arc;
 
 use crate::syntax::{Green, GreenNode, NodeKind};
 
@@ -78,8 +78,8 @@ impl<'a> Reparser<'a> {
 
 impl Reparser<'_> {
     /// Find the innermost child that is incremental safe.
-    pub fn reparse(&self, green: &mut Rc<GreenNode>) -> Range<usize> {
-        self.reparse_step(Rc::make_mut(green), 0, TokenMode::Markup, true)
+    pub fn reparse(&self, green: &mut Arc<GreenNode>) -> Range<usize> {
+        self.reparse_step(Arc::make_mut(green), 0, TokenMode::Markup, true)
             .unwrap_or_else(|| {
                 *green = parse(self.src);
                 0 .. self.src.len()
@@ -167,7 +167,7 @@ impl Reparser<'_> {
             if last_kind.succession_rule() != SuccessionRule::Unsafe {
                 if let Some(range) = match child {
                     Green::Node(node) => self.reparse_step(
-                        Rc::make_mut(node),
+                        Arc::make_mut(node),
                         first_start,
                         child_mode,
                         outermost,
diff --git a/src/parse/mod.rs b/src/parse/mod.rs
index 38a08ab8..fbace15b 100644
--- a/src/parse/mod.rs
+++ b/src/parse/mod.rs
@@ -12,14 +12,14 @@ pub use resolve::*;
 pub use scanner::*;
 pub use tokens::*;
 
-use std::rc::Rc;
+use std::sync::Arc;
 
 use crate::syntax::ast::{Associativity, BinOp, UnOp};
 use crate::syntax::{ErrorPos, Green, GreenNode, NodeKind};
 use crate::util::EcoString;
 
 /// Parse a source file.
-pub fn parse(src: &str) -> Rc<GreenNode> {
+pub fn parse(src: &str) -> Arc<GreenNode> {
     let mut p = Parser::new(src, TokenMode::Markup);
     markup(&mut p, true);
     match p.finish().into_iter().next() {
diff --git a/src/parse/tokens.rs b/src/parse/tokens.rs
index 27da3b80..970c0dd6 100644
--- a/src/parse/tokens.rs
+++ b/src/parse/tokens.rs
@@ -1,4 +1,4 @@
-use std::rc::Rc;
+use std::sync::Arc;
 
 use super::{
     is_id_continue, is_id_start, is_newline, resolve_hex, resolve_raw, resolve_string,
@@ -321,7 +321,7 @@ impl<'s> Tokens<'s> {
 
         // Special case for empty inline block.
         if backticks == 2 {
-            return NodeKind::Raw(Rc::new(RawNode {
+            return NodeKind::Raw(Arc::new(RawNode {
                 text: EcoString::new(),
                 lang: None,
                 block: false,
@@ -341,7 +341,7 @@ impl<'s> Tokens<'s> {
 
         if found == backticks {
             let end = self.s.index() - found as usize;
-            NodeKind::Raw(Rc::new(resolve_raw(
+            NodeKind::Raw(Arc::new(resolve_raw(
                 column,
                 backticks,
                 self.s.get(start .. end),
@@ -393,7 +393,7 @@ impl<'s> Tokens<'s> {
             };
 
         if terminated {
-            NodeKind::Math(Rc::new(MathNode {
+            NodeKind::Math(Arc::new(MathNode {
                 formula: self.s.get(start .. end).into(),
                 display,
             }))
@@ -581,7 +581,7 @@ mod tests {
     }
 
     fn Raw(text: &str, lang: Option<&str>, block: bool) -> NodeKind {
-        NodeKind::Raw(Rc::new(RawNode {
+        NodeKind::Raw(Arc::new(RawNode {
             text: text.into(),
             lang: lang.map(Into::into),
             block,
@@ -589,7 +589,7 @@ mod tests {
     }
 
     fn Math(formula: &str, display: bool) -> NodeKind {
-        NodeKind::Math(Rc::new(MathNode { formula: formula.into(), display }))
+        NodeKind::Math(Arc::new(MathNode { formula: formula.into(), display }))
     }
 
     fn Str(string: &str) -> NodeKind {