From e4176937f0584a6bcc5aba15abb1e2df6ddf588d Mon Sep 17 00:00:00 2001
From: mat <github@matdoes.dev>
Date: Fri, 5 May 2023 19:37:40 +0000
Subject: remove more unnecessary brigadier cloning!

---
 azalea-brigadier/src/context/command_context_builder.rs | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

(limited to 'azalea-brigadier/src/context')

diff --git a/azalea-brigadier/src/context/command_context_builder.rs b/azalea-brigadier/src/context/command_context_builder.rs
index 7516ab9e..b0677158 100755
--- a/azalea-brigadier/src/context/command_context_builder.rs
+++ b/azalea-brigadier/src/context/command_context_builder.rs
@@ -9,20 +9,20 @@ use crate::{
 };
 use std::{cell::RefCell, collections::HashMap, fmt::Debug, rc::Rc};
 
-pub struct CommandContextBuilder<S> {
+pub struct CommandContextBuilder<'a, S> {
     pub arguments: HashMap<String, ParsedArgument>,
     pub root: Rc<RefCell<CommandNode<S>>>,
     pub nodes: Vec<ParsedCommandNode<S>>,
-    pub dispatcher: Rc<CommandDispatcher<S>>,
+    pub dispatcher: &'a CommandDispatcher<'a, S>,
     pub source: Rc<S>,
     pub command: Command<S>,
-    pub child: Option<Rc<CommandContextBuilder<S>>>,
+    pub child: Option<Rc<CommandContextBuilder<'a, S>>>,
     pub range: StringRange,
     pub modifier: Option<Rc<RedirectModifier<S>>>,
     pub forks: bool,
 }
 
-impl<S> Clone for CommandContextBuilder<S> {
+impl<S> Clone for CommandContextBuilder<'_, S> {
     fn clone(&self) -> Self {
         Self {
             arguments: self.arguments.clone(),
@@ -39,9 +39,9 @@ impl<S> Clone for CommandContextBuilder<S> {
     }
 }
 
-impl<S> CommandContextBuilder<S> {
+impl<'a, S> CommandContextBuilder<'a, S> {
     pub fn new(
-        dispatcher: Rc<CommandDispatcher<S>>,
+        dispatcher: &'a CommandDispatcher<S>,
         source: Rc<S>,
         root_node: Rc<RefCell<CommandNode<S>>>,
         start: usize,
@@ -64,7 +64,7 @@ impl<S> CommandContextBuilder<S> {
         self.command = command.clone();
         self
     }
-    pub fn with_child(&mut self, child: Rc<CommandContextBuilder<S>>) -> &Self {
+    pub fn with_child(&mut self, child: Rc<CommandContextBuilder<'a, S>>) -> &Self {
         self.child = Some(child);
         self
     }
@@ -99,7 +99,7 @@ impl<S> CommandContextBuilder<S> {
     }
 }
 
-impl<S> Debug for CommandContextBuilder<S> {
+impl<S> Debug for CommandContextBuilder<'_, S> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         f.debug_struct("CommandContextBuilder")
             // .field("arguments", &self.arguments)
-- 
cgit v1.2.3


From 12370ab07609bf78baef4ec2302fa4ba44317dae Mon Sep 17 00:00:00 2001
From: mat <git@matdoes.dev>
Date: Fri, 5 May 2023 23:09:57 -0500
Subject: change some things to be Arc+RwLock in brigadier

---
 Cargo.lock                                         |  1 +
 azalea-brigadier/Cargo.toml                        |  1 +
 azalea-brigadier/src/builder/argument_builder.rs   | 14 +++--
 azalea-brigadier/src/command_dispatcher.rs         | 68 +++++++++++-----------
 azalea-brigadier/src/context/command_context.rs    |  6 +-
 .../src/context/command_context_builder.rs         | 18 +++---
 .../src/context/parsed_command_node.rs             |  6 +-
 azalea-brigadier/src/tree/mod.rs                   | 47 +++++++++------
 .../tests/builder/argument_builder_test.rs         | 13 +++--
 azalea-brigadier/tests/command_dispatcher_test.rs  | 25 ++++----
 10 files changed, 111 insertions(+), 88 deletions(-)

(limited to 'azalea-brigadier/src/context')

diff --git a/Cargo.lock b/Cargo.lock
index cb1098cc..dcf982f2 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -233,6 +233,7 @@ version = "0.6.0"
 dependencies = [
  "azalea-buf",
  "azalea-chat",
+ "parking_lot",
 ]
 
 [[package]]
diff --git a/azalea-brigadier/Cargo.toml b/azalea-brigadier/Cargo.toml
index 254ccc83..a1f5966b 100644
--- a/azalea-brigadier/Cargo.toml
+++ b/azalea-brigadier/Cargo.toml
@@ -11,6 +11,7 @@ version = "0.6.0"
 [dependencies]
 azalea-buf = {path = "../azalea-buf", version = "^0.6.0", optional = true}
 azalea-chat = {path = "../azalea-chat", version = "^0.6.0", optional = true}
+parking_lot = "0.12.1"
 
 [features]
 azalea-buf = ["dep:azalea-buf", "dep:azalea-chat"]
diff --git a/azalea-brigadier/src/builder/argument_builder.rs b/azalea-brigadier/src/builder/argument_builder.rs
index cfaff618..a1f3d6ae 100755
--- a/azalea-brigadier/src/builder/argument_builder.rs
+++ b/azalea-brigadier/src/builder/argument_builder.rs
@@ -1,3 +1,5 @@
+use parking_lot::RwLock;
+
 use crate::{
     context::CommandContext,
     modifier::RedirectModifier,
@@ -5,7 +7,7 @@ use crate::{
 };
 
 use super::{literal_argument_builder::Literal, required_argument_builder::Argument};
-use std::{cell::RefCell, fmt::Debug, rc::Rc};
+use std::{fmt::Debug, rc::Rc, sync::Arc};
 
 #[derive(Debug, Clone)]
 pub enum ArgumentBuilderType {
@@ -19,7 +21,7 @@ pub struct ArgumentBuilder<S> {
 
     command: Command<S>,
     requirement: Rc<dyn Fn(Rc<S>) -> bool>,
-    target: Option<Rc<RefCell<CommandNode<S>>>>,
+    target: Option<Arc<RwLock<CommandNode<S>>>>,
 
     forks: bool,
     modifier: Option<Rc<RedirectModifier<S>>>,
@@ -46,7 +48,7 @@ impl<S> ArgumentBuilder<S> {
     }
 
     pub fn then_built(mut self, argument: CommandNode<S>) -> Self {
-        self.arguments.add_child(&Rc::new(RefCell::new(argument)));
+        self.arguments.add_child(&Arc::new(RwLock::new(argument)));
         self
     }
 
@@ -66,13 +68,13 @@ impl<S> ArgumentBuilder<S> {
         self
     }
 
-    pub fn redirect(self, target: Rc<RefCell<CommandNode<S>>>) -> Self {
+    pub fn redirect(self, target: Arc<RwLock<CommandNode<S>>>) -> Self {
         self.forward(target, None, false)
     }
 
     pub fn fork(
         self,
-        target: Rc<RefCell<CommandNode<S>>>,
+        target: Arc<RwLock<CommandNode<S>>>,
         modifier: Rc<RedirectModifier<S>>,
     ) -> Self {
         self.forward(target, Some(modifier), true)
@@ -80,7 +82,7 @@ impl<S> ArgumentBuilder<S> {
 
     pub fn forward(
         mut self,
-        target: Rc<RefCell<CommandNode<S>>>,
+        target: Arc<RwLock<CommandNode<S>>>,
         modifier: Option<Rc<RedirectModifier<S>>>,
         fork: bool,
     ) -> Self {
diff --git a/azalea-brigadier/src/command_dispatcher.rs b/azalea-brigadier/src/command_dispatcher.rs
index 29fadfd1..0d84171e 100755
--- a/azalea-brigadier/src/command_dispatcher.rs
+++ b/azalea-brigadier/src/command_dispatcher.rs
@@ -1,3 +1,5 @@
+use parking_lot::RwLock;
+
 use crate::{
     builder::argument_builder::ArgumentBuilder,
     context::{CommandContext, CommandContextBuilder},
@@ -6,26 +8,27 @@ use crate::{
     string_reader::StringReader,
     tree::CommandNode,
 };
-use std::{cell::RefCell, cmp::Ordering, collections::HashMap, marker::PhantomData, mem, rc::Rc};
+use std::{cmp::Ordering, collections::HashMap, mem, rc::Rc, sync::Arc};
 
 /// The root of the command tree. You need to make this to register commands.
 #[derive(Default)]
-pub struct CommandDispatcher<'a, S> {
-    pub root: Rc<RefCell<CommandNode<S>>>,
-    _marker: PhantomData<(S, &'a ())>,
+pub struct CommandDispatcher<S>
+// where
+//     Self: Sync + Send,
+{
+    pub root: Arc<RwLock<CommandNode<S>>>,
 }
 
-impl<'a, S> CommandDispatcher<'a, S> {
+impl<S> CommandDispatcher<S> {
     pub fn new() -> Self {
         Self {
-            root: Rc::new(RefCell::new(CommandNode::default())),
-            _marker: PhantomData,
+            root: Arc::new(RwLock::new(CommandNode::default())),
         }
     }
 
-    pub fn register(&mut self, node: ArgumentBuilder<S>) -> Rc<RefCell<CommandNode<S>>> {
-        let build = Rc::new(RefCell::new(node.build()));
-        self.root.borrow_mut().add_child(&build);
+    pub fn register(&mut self, node: ArgumentBuilder<S>) -> Arc<RwLock<CommandNode<S>>> {
+        let build = Arc::new(RwLock::new(node.build()));
+        self.root.write().add_child(&build);
         build
     }
 
@@ -34,9 +37,9 @@ impl<'a, S> CommandDispatcher<'a, S> {
         self.parse_nodes(&self.root, &command, context).unwrap()
     }
 
-    fn parse_nodes(
+    fn parse_nodes<'a>(
         &'a self,
-        node: &Rc<RefCell<CommandNode<S>>>,
+        node: &Arc<RwLock<CommandNode<S>>>,
         original_reader: &StringReader,
         context_so_far: CommandContextBuilder<'a, S>,
     ) -> Result<ParseResults<'a, S>, CommandSyntaxException> {
@@ -45,21 +48,18 @@ impl<'a, S> CommandDispatcher<'a, S> {
         let mut potentials: Vec<ParseResults<S>> = vec![];
         let cursor = original_reader.cursor();
 
-        for child in node
-            .borrow()
-            .get_relevant_nodes(&mut original_reader.clone())
-        {
-            if !child.borrow().can_use(source.clone()) {
+        for child in node.read().get_relevant_nodes(&mut original_reader.clone()) {
+            if !child.read().can_use(source.clone()) {
                 continue;
             }
             let mut context = context_so_far.clone();
             let mut reader = original_reader.clone();
 
             let parse_with_context_result =
-                child.borrow().parse_with_context(&mut reader, &mut context);
+                child.read().parse_with_context(&mut reader, &mut context);
             if let Err(ex) = parse_with_context_result {
                 errors.insert(
-                    Rc::new((*child.borrow()).clone()),
+                    Rc::new((*child.read()).clone()),
                     BuiltInExceptions::DispatcherParseException {
                         message: ex.message(),
                     }
@@ -70,7 +70,7 @@ impl<'a, S> CommandDispatcher<'a, S> {
             }
             if reader.can_read() && reader.peek() != ' ' {
                 errors.insert(
-                    Rc::new((*child.borrow()).clone()),
+                    Rc::new((*child.read()).clone()),
                     BuiltInExceptions::DispatcherExpectedArgumentSeparator
                         .create_with_context(&reader),
                 );
@@ -78,14 +78,14 @@ impl<'a, S> CommandDispatcher<'a, S> {
                 continue;
             }
 
-            context.with_command(&child.borrow().command);
-            if reader.can_read_length(if child.borrow().redirect.is_none() {
+            context.with_command(&child.read().command);
+            if reader.can_read_length(if child.read().redirect.is_none() {
                 2
             } else {
                 1
             }) {
                 reader.skip();
-                if let Some(redirect) = &child.borrow().redirect {
+                if let Some(redirect) = &child.read().redirect {
                     let child_context =
                         CommandContextBuilder::new(self, source, redirect.clone(), reader.cursor);
                     let parse = self
@@ -151,30 +151,30 @@ impl<'a, S> CommandDispatcher<'a, S> {
     }
 
     pub fn add_paths(
-        node: Rc<RefCell<CommandNode<S>>>,
-        result: &mut Vec<Vec<Rc<RefCell<CommandNode<S>>>>>,
-        parents: Vec<Rc<RefCell<CommandNode<S>>>>,
+        node: Arc<RwLock<CommandNode<S>>>,
+        result: &mut Vec<Vec<Arc<RwLock<CommandNode<S>>>>>,
+        parents: Vec<Arc<RwLock<CommandNode<S>>>>,
     ) {
         let mut current = parents;
         current.push(node.clone());
         result.push(current.clone());
 
-        for child in node.borrow().children.values() {
+        for child in node.read().children.values() {
             Self::add_paths(child.clone(), result, current.clone());
         }
     }
 
     pub fn get_path(&self, target: CommandNode<S>) -> Vec<String> {
-        let rc_target = Rc::new(RefCell::new(target));
-        let mut nodes: Vec<Vec<Rc<RefCell<CommandNode<S>>>>> = Vec::new();
+        let rc_target = Arc::new(RwLock::new(target));
+        let mut nodes: Vec<Vec<Arc<RwLock<CommandNode<S>>>>> = Vec::new();
         Self::add_paths(self.root.clone(), &mut nodes, vec![]);
 
         for list in nodes {
-            if *list.last().expect("Nothing in list").borrow() == *rc_target.borrow() {
+            if *list.last().expect("Nothing in list").read() == *rc_target.read() {
                 let mut result: Vec<String> = Vec::with_capacity(list.len());
                 for node in list {
-                    if node != self.root {
-                        result.push(node.borrow().name().to_string());
+                    if !Arc::ptr_eq(&node, &self.root) {
+                        result.push(node.read().name().to_string());
                     }
                 }
                 return result;
@@ -183,10 +183,10 @@ impl<'a, S> CommandDispatcher<'a, S> {
         vec![]
     }
 
-    pub fn find_node(&self, path: &[&str]) -> Option<Rc<RefCell<CommandNode<S>>>> {
+    pub fn find_node(&self, path: &[&str]) -> Option<Arc<RwLock<CommandNode<S>>>> {
         let mut node = self.root.clone();
         for name in path {
-            if let Some(child) = node.clone().borrow().child(name) {
+            if let Some(child) = node.clone().read().child(name) {
                 node = child;
             } else {
                 return None;
diff --git a/azalea-brigadier/src/context/command_context.rs b/azalea-brigadier/src/context/command_context.rs
index 98609a6e..88af2002 100755
--- a/azalea-brigadier/src/context/command_context.rs
+++ b/azalea-brigadier/src/context/command_context.rs
@@ -1,9 +1,11 @@
+use parking_lot::RwLock;
+
 use super::{parsed_command_node::ParsedCommandNode, string_range::StringRange, ParsedArgument};
 use crate::{
     modifier::RedirectModifier,
     tree::{Command, CommandNode},
 };
-use std::{any::Any, cell::RefCell, collections::HashMap, fmt::Debug, rc::Rc};
+use std::{any::Any, collections::HashMap, fmt::Debug, rc::Rc, sync::Arc};
 
 /// A built `CommandContextBuilder`.
 pub struct CommandContext<S> {
@@ -11,7 +13,7 @@ pub struct CommandContext<S> {
     pub input: String,
     pub arguments: HashMap<String, ParsedArgument>,
     pub command: Command<S>,
-    pub root_node: Rc<RefCell<CommandNode<S>>>,
+    pub root_node: Arc<RwLock<CommandNode<S>>>,
     pub nodes: Vec<ParsedCommandNode<S>>,
     pub range: StringRange,
     pub child: Option<Rc<CommandContext<S>>>,
diff --git a/azalea-brigadier/src/context/command_context_builder.rs b/azalea-brigadier/src/context/command_context_builder.rs
index b0677158..54063879 100755
--- a/azalea-brigadier/src/context/command_context_builder.rs
+++ b/azalea-brigadier/src/context/command_context_builder.rs
@@ -1,3 +1,5 @@
+use parking_lot::RwLock;
+
 use super::{
     command_context::CommandContext, parsed_command_node::ParsedCommandNode,
     string_range::StringRange, ParsedArgument,
@@ -7,13 +9,13 @@ use crate::{
     modifier::RedirectModifier,
     tree::{Command, CommandNode},
 };
-use std::{cell::RefCell, collections::HashMap, fmt::Debug, rc::Rc};
+use std::{collections::HashMap, fmt::Debug, rc::Rc, sync::Arc};
 
 pub struct CommandContextBuilder<'a, S> {
     pub arguments: HashMap<String, ParsedArgument>,
-    pub root: Rc<RefCell<CommandNode<S>>>,
+    pub root: Arc<RwLock<CommandNode<S>>>,
     pub nodes: Vec<ParsedCommandNode<S>>,
-    pub dispatcher: &'a CommandDispatcher<'a, S>,
+    pub dispatcher: &'a CommandDispatcher<S>,
     pub source: Rc<S>,
     pub command: Command<S>,
     pub child: Option<Rc<CommandContextBuilder<'a, S>>>,
@@ -28,7 +30,7 @@ impl<S> Clone for CommandContextBuilder<'_, S> {
             arguments: self.arguments.clone(),
             root: self.root.clone(),
             nodes: self.nodes.clone(),
-            dispatcher: self.dispatcher.clone(),
+            dispatcher: self.dispatcher,
             source: self.source.clone(),
             command: self.command.clone(),
             child: self.child.clone(),
@@ -43,7 +45,7 @@ impl<'a, S> CommandContextBuilder<'a, S> {
     pub fn new(
         dispatcher: &'a CommandDispatcher<S>,
         source: Rc<S>,
-        root_node: Rc<RefCell<CommandNode<S>>>,
+        root_node: Arc<RwLock<CommandNode<S>>>,
         start: usize,
     ) -> Self {
         Self {
@@ -72,14 +74,14 @@ impl<'a, S> CommandContextBuilder<'a, S> {
         self.arguments.insert(name.to_string(), argument);
         self
     }
-    pub fn with_node(&mut self, node: Rc<RefCell<CommandNode<S>>>, range: StringRange) -> &Self {
+    pub fn with_node(&mut self, node: Arc<RwLock<CommandNode<S>>>, range: StringRange) -> &Self {
         self.nodes.push(ParsedCommandNode {
             node: node.clone(),
             range: range.clone(),
         });
         self.range = StringRange::encompassing(&self.range, &range);
-        self.modifier = node.borrow().modifier.clone();
-        self.forks = node.borrow().forks;
+        self.modifier = node.read().modifier.clone();
+        self.forks = node.read().forks;
         self
     }
 
diff --git a/azalea-brigadier/src/context/parsed_command_node.rs b/azalea-brigadier/src/context/parsed_command_node.rs
index ed49928d..bba5d121 100755
--- a/azalea-brigadier/src/context/parsed_command_node.rs
+++ b/azalea-brigadier/src/context/parsed_command_node.rs
@@ -1,10 +1,12 @@
+use parking_lot::RwLock;
+
 use super::string_range::StringRange;
 use crate::tree::CommandNode;
-use std::{cell::RefCell, rc::Rc};
+use std::sync::Arc;
 
 #[derive(Debug)]
 pub struct ParsedCommandNode<S> {
-    pub node: Rc<RefCell<CommandNode<S>>>,
+    pub node: Arc<RwLock<CommandNode<S>>>,
     pub range: StringRange,
 }
 
diff --git a/azalea-brigadier/src/tree/mod.rs b/azalea-brigadier/src/tree/mod.rs
index bb6af68d..902e288b 100755
--- a/azalea-brigadier/src/tree/mod.rs
+++ b/azalea-brigadier/src/tree/mod.rs
@@ -1,3 +1,5 @@
+use parking_lot::RwLock;
+
 use crate::{
     builder::{
         argument_builder::ArgumentBuilderType, literal_argument_builder::Literal,
@@ -8,7 +10,7 @@ use crate::{
     modifier::RedirectModifier,
     string_reader::StringReader,
 };
-use std::{cell::RefCell, collections::HashMap, fmt::Debug, hash::Hash, ptr, rc::Rc};
+use std::{collections::HashMap, fmt::Debug, hash::Hash, ptr, rc::Rc, sync::Arc};
 
 pub type Command<S> = Option<Rc<dyn Fn(&CommandContext<S>) -> i32>>;
 
@@ -17,13 +19,13 @@ pub type Command<S> = Option<Rc<dyn Fn(&CommandContext<S>) -> i32>>;
 pub struct CommandNode<S> {
     pub value: ArgumentBuilderType,
 
-    pub children: HashMap<String, Rc<RefCell<CommandNode<S>>>>,
-    pub literals: HashMap<String, Rc<RefCell<CommandNode<S>>>>,
-    pub arguments: HashMap<String, Rc<RefCell<CommandNode<S>>>>,
+    pub children: HashMap<String, Arc<RwLock<CommandNode<S>>>>,
+    pub literals: HashMap<String, Arc<RwLock<CommandNode<S>>>>,
+    pub arguments: HashMap<String, Arc<RwLock<CommandNode<S>>>>,
 
     pub command: Command<S>,
     pub requirement: Rc<dyn Fn(Rc<S>) -> bool>,
-    pub redirect: Option<Rc<RefCell<CommandNode<S>>>>,
+    pub redirect: Option<Arc<RwLock<CommandNode<S>>>>,
     pub forks: bool,
     pub modifier: Option<Rc<RedirectModifier<S>>>,
 }
@@ -62,7 +64,7 @@ impl<S> CommandNode<S> {
         }
     }
 
-    pub fn get_relevant_nodes(&self, input: &mut StringReader) -> Vec<Rc<RefCell<CommandNode<S>>>> {
+    pub fn get_relevant_nodes(&self, input: &mut StringReader) -> Vec<Arc<RwLock<CommandNode<S>>>> {
         let literals = &self.literals;
 
         if literals.is_empty() {
@@ -92,20 +94,20 @@ impl<S> CommandNode<S> {
         (self.requirement)(source)
     }
 
-    pub fn add_child(&mut self, node: &Rc<RefCell<CommandNode<S>>>) {
-        let child = self.children.get(node.borrow().name());
+    pub fn add_child(&mut self, node: &Arc<RwLock<CommandNode<S>>>) {
+        let child = self.children.get(node.read().name());
         if let Some(child) = child {
             // We've found something to merge onto
-            if let Some(command) = &node.borrow().command {
-                child.borrow_mut().command = Some(command.clone());
+            if let Some(command) = &node.read().command {
+                child.write().command = Some(command.clone());
             }
-            for grandchild in node.borrow().children.values() {
-                child.borrow_mut().add_child(grandchild);
+            for grandchild in node.read().children.values() {
+                child.write().add_child(grandchild);
             }
         } else {
             self.children
-                .insert(node.borrow().name().to_string(), node.clone());
-            match &node.borrow().value {
+                .insert(node.read().name().to_string(), node.clone());
+            match &node.read().value {
                 ArgumentBuilderType::Literal(literal) => {
                     self.literals.insert(literal.value.clone(), node.clone());
                 }
@@ -123,7 +125,7 @@ impl<S> CommandNode<S> {
         }
     }
 
-    pub fn child(&self, name: &str) -> Option<Rc<RefCell<CommandNode<S>>>> {
+    pub fn child(&self, name: &str) -> Option<Arc<RwLock<CommandNode<S>>>> {
         self.children.get(name).cloned()
     }
 
@@ -142,7 +144,7 @@ impl<S> CommandNode<S> {
                 };
 
                 context_builder.with_argument(&argument.name, parsed.clone());
-                context_builder.with_node(Rc::new(RefCell::new(self.clone())), parsed.range);
+                context_builder.with_node(Arc::new(RwLock::new(self.clone())), parsed.range);
 
                 Ok(())
             }
@@ -152,7 +154,7 @@ impl<S> CommandNode<S> {
 
                 if let Some(end) = end {
                     context_builder.with_node(
-                        Rc::new(RefCell::new(self.clone())),
+                        Arc::new(RwLock::new(self.clone())),
                         StringRange::between(start, end),
                     );
                     return Ok(());
@@ -232,7 +234,7 @@ impl<S> Hash for CommandNode<S> {
         // hash the children
         for (k, v) in &self.children {
             k.hash(state);
-            v.borrow().hash(state);
+            v.read().hash(state);
         }
         // i hope this works because if doesn't then that'll be a problem
         ptr::hash(&self.command, state);
@@ -241,9 +243,16 @@ impl<S> Hash for CommandNode<S> {
 
 impl<S> PartialEq for CommandNode<S> {
     fn eq(&self, other: &Self) -> bool {
-        if self.children != other.children {
+        if self.children.len() != other.children.len() {
             return false;
         }
+        for (k, v) in &self.children {
+            let other_child = other.children.get(k).unwrap();
+            if !Arc::ptr_eq(v, other_child) {
+                return false;
+            }
+        }
+
         if let Some(selfexecutes) = &self.command {
             // idk how to do this better since we can't compare `dyn Fn`s
             if let Some(otherexecutes) = &other.command {
diff --git a/azalea-brigadier/tests/builder/argument_builder_test.rs b/azalea-brigadier/tests/builder/argument_builder_test.rs
index e570c988..ee44f5e6 100755
--- a/azalea-brigadier/tests/builder/argument_builder_test.rs
+++ b/azalea-brigadier/tests/builder/argument_builder_test.rs
@@ -17,13 +17,14 @@ use super::ArgumentBuilder;
 
 //     @Test
 //     public void testArguments() throws Exception {
-//         final RequiredArgumentBuilder<Object, ?> argument = argument("bar", integer());
+//         final RequiredArgumentBuilder<Object, ?> argument = argument("bar",
+// integer());
 
 //         builder.then(argument);
 
 //         assertThat(builder.getArguments(), hasSize(1));
-//         assertThat(builder.getArguments(), hasItem((CommandNode<Object>) argument.build()));
-//     }
+//         assertThat(builder.getArguments(), hasItem((CommandNode<Object>)
+// argument.build()));     }
 
 #[test]
 fn test_arguments() {
@@ -37,7 +38,7 @@ fn test_arguments() {
         .arguments
         .children
         .values()
-        .any(|e| *e.borrow() == *built_argument));
+        .any(|e| *e.read() == *built_argument));
 }
 
 //     @Test
@@ -61,8 +62,8 @@ fn test_arguments() {
 //         builder.then(literal("foo"));
 //     }
 
-//     private static class TestableArgumentBuilder<S> extends ArgumentBuilder<S, TestableArgumentBuilder<S>> {
-//         @Override
+//     private static class TestableArgumentBuilder<S> extends
+// ArgumentBuilder<S, TestableArgumentBuilder<S>> {         @Override
 //         protected TestableArgumentBuilder<S> getThis() {
 //             return this;
 //         }
diff --git a/azalea-brigadier/tests/command_dispatcher_test.rs b/azalea-brigadier/tests/command_dispatcher_test.rs
index e30dd2c1..fb0085ba 100755
--- a/azalea-brigadier/tests/command_dispatcher_test.rs
+++ b/azalea-brigadier/tests/command_dispatcher_test.rs
@@ -251,31 +251,34 @@ fn execute_redirected_multiple_times() {
     let parse = subject.parse(input.into(), Rc::new(CommandSource {}));
     assert_eq!(parse.context.range.get(input), "redirected");
     assert_eq!(parse.context.nodes.len(), 1);
-    assert_eq!(parse.context.root, root);
+    assert_eq!(*parse.context.root.read(), *root.read());
     assert_eq!(parse.context.nodes[0].range, parse.context.range);
-    assert_eq!(parse.context.nodes[0].node, redirect_node);
+    assert_eq!(*parse.context.nodes[0].node.read(), *redirect_node.read());
 
     let child1 = parse.context.child.clone();
     assert!(child1.is_some());
     assert_eq!(child1.clone().unwrap().range.get(input), "redirected");
     assert_eq!(child1.clone().unwrap().nodes.len(), 1);
-    assert_eq!(child1.clone().unwrap().root, root);
+    assert_eq!(*child1.clone().unwrap().root.read(), *root.read());
     assert_eq!(
         child1.clone().unwrap().nodes[0].range,
         child1.clone().unwrap().range
     );
-    assert_eq!(child1.clone().unwrap().nodes[0].node, redirect_node);
+    assert_eq!(
+        *child1.clone().unwrap().nodes[0].node.read(),
+        *redirect_node.read()
+    );
 
     let child2 = child1.unwrap().child.clone();
     assert!(child2.is_some());
     assert_eq!(child2.clone().unwrap().range.get(input), "actual");
     assert_eq!(child2.clone().unwrap().nodes.len(), 1);
-    assert_eq!(child2.clone().unwrap().root, root);
+    assert_eq!(*child2.clone().unwrap().root.read(), *root.read());
     assert_eq!(
         child2.clone().unwrap().nodes[0].range,
         child2.clone().unwrap().range
     );
-    assert_eq!(child2.unwrap().nodes[0].node, concrete_node);
+    assert_eq!(*child2.unwrap().nodes[0].node.read(), *concrete_node.read());
 
     assert_eq!(CommandDispatcher::execute_parsed(parse).unwrap(), 42);
 }
@@ -299,18 +302,18 @@ fn execute_redirected() {
     let parse = subject.parse(input.into(), Rc::new(CommandSource {}));
     assert_eq!(parse.context.range.get(input), "redirected");
     assert_eq!(parse.context.nodes.len(), 1);
-    assert_eq!(parse.context.root, subject.root);
+    assert_eq!(*parse.context.root.read(), *subject.root.read());
     assert_eq!(parse.context.nodes[0].range, parse.context.range);
-    assert_eq!(parse.context.nodes[0].node, redirect_node);
+    assert_eq!(*parse.context.nodes[0].node.read(), *redirect_node.read());
 
     let parent = parse.context.child.clone();
     assert!(parent.is_some());
     let parent = parent.unwrap();
     assert_eq!(parent.range.get(input), "actual");
     assert_eq!(parent.nodes.len(), 1);
-    assert_eq!(parse.context.root, subject.root);
+    assert_eq!(*parse.context.root.read(), *subject.root.read());
     assert_eq!(parent.nodes[0].range, parent.range);
-    assert_eq!(parent.nodes[0].node, concrete_node);
+    assert_eq!(*parent.nodes[0].node.read(), *concrete_node.read());
     assert_eq!(parent.source, Rc::new(CommandSource {}));
 
     assert_eq!(CommandDispatcher::execute_parsed(parse).unwrap(), 2);
@@ -406,5 +409,5 @@ fn get_path() {
 fn find_node_doesnt_exist() {
     let subject = CommandDispatcher::<()>::new();
 
-    assert_eq!(subject.find_node(&["foo", "bar"]), None)
+    assert!(subject.find_node(&["foo", "bar"]).is_none())
 }
-- 
cgit v1.2.3


From f825544e2776ab545ff0a9c674b68183120695cb Mon Sep 17 00:00:00 2001
From: mat <git@matdoes.dev>
Date: Fri, 5 May 2023 23:23:11 -0500
Subject: CommandDispatcher is now Send+Sync

---
 azalea-brigadier/src/builder/argument_builder.rs   | 20 ++++----
 .../src/builder/required_argument_builder.rs       | 13 ++++--
 azalea-brigadier/src/command_dispatcher.rs         | 10 ++--
 azalea-brigadier/src/context/command_context.rs    | 10 ++--
 .../src/context/command_context_builder.rs         | 14 +++---
 azalea-brigadier/src/modifier.rs                   |  4 +-
 azalea-brigadier/src/tree/mod.rs                   | 14 +++---
 azalea-brigadier/tests/command_dispatcher_test.rs  | 54 +++++++++++-----------
 8 files changed, 71 insertions(+), 68 deletions(-)

(limited to 'azalea-brigadier/src/context')

diff --git a/azalea-brigadier/src/builder/argument_builder.rs b/azalea-brigadier/src/builder/argument_builder.rs
index a1f3d6ae..c6f2146a 100755
--- a/azalea-brigadier/src/builder/argument_builder.rs
+++ b/azalea-brigadier/src/builder/argument_builder.rs
@@ -7,7 +7,7 @@ use crate::{
 };
 
 use super::{literal_argument_builder::Literal, required_argument_builder::Argument};
-use std::{fmt::Debug, rc::Rc, sync::Arc};
+use std::{fmt::Debug, sync::Arc};
 
 #[derive(Debug, Clone)]
 pub enum ArgumentBuilderType {
@@ -20,11 +20,11 @@ pub struct ArgumentBuilder<S> {
     arguments: CommandNode<S>,
 
     command: Command<S>,
-    requirement: Rc<dyn Fn(Rc<S>) -> bool>,
+    requirement: Arc<dyn Fn(Arc<S>) -> bool + Send + Sync>,
     target: Option<Arc<RwLock<CommandNode<S>>>>,
 
     forks: bool,
-    modifier: Option<Rc<RedirectModifier<S>>>,
+    modifier: Option<Arc<RedirectModifier<S>>>,
 }
 
 /// A node that isn't yet built.
@@ -36,7 +36,7 @@ impl<S> ArgumentBuilder<S> {
                 ..Default::default()
             },
             command: None,
-            requirement: Rc::new(|_| true),
+            requirement: Arc::new(|_| true),
             forks: false,
             modifier: None,
             target: None,
@@ -54,17 +54,17 @@ impl<S> ArgumentBuilder<S> {
 
     pub fn executes<F>(mut self, f: F) -> Self
     where
-        F: Fn(&CommandContext<S>) -> i32 + 'static,
+        F: Fn(&CommandContext<S>) -> i32 + Send + Sync + 'static,
     {
-        self.command = Some(Rc::new(f));
+        self.command = Some(Arc::new(f));
         self
     }
 
     pub fn requires<F>(mut self, requirement: F) -> Self
     where
-        F: Fn(Rc<S>) -> bool + 'static,
+        F: Fn(Arc<S>) -> bool + Send + Sync + 'static,
     {
-        self.requirement = Rc::new(requirement);
+        self.requirement = Arc::new(requirement);
         self
     }
 
@@ -75,7 +75,7 @@ impl<S> ArgumentBuilder<S> {
     pub fn fork(
         self,
         target: Arc<RwLock<CommandNode<S>>>,
-        modifier: Rc<RedirectModifier<S>>,
+        modifier: Arc<RedirectModifier<S>>,
     ) -> Self {
         self.forward(target, Some(modifier), true)
     }
@@ -83,7 +83,7 @@ impl<S> ArgumentBuilder<S> {
     pub fn forward(
         mut self,
         target: Arc<RwLock<CommandNode<S>>>,
-        modifier: Option<Rc<RedirectModifier<S>>>,
+        modifier: Option<Arc<RedirectModifier<S>>>,
         fork: bool,
     ) -> Self {
         if !self.arguments.children.is_empty() {
diff --git a/azalea-brigadier/src/builder/required_argument_builder.rs b/azalea-brigadier/src/builder/required_argument_builder.rs
index 9d4d9e0a..0363d204 100755
--- a/azalea-brigadier/src/builder/required_argument_builder.rs
+++ b/azalea-brigadier/src/builder/required_argument_builder.rs
@@ -2,17 +2,17 @@ use super::argument_builder::{ArgumentBuilder, ArgumentBuilderType};
 use crate::{
     arguments::ArgumentType, exceptions::CommandSyntaxException, string_reader::StringReader,
 };
-use std::{any::Any, fmt::Debug, rc::Rc};
+use std::{any::Any, fmt::Debug, rc::Rc, sync::Arc};
 
 /// An argument node type. The `T` type parameter is the type of the argument,
 /// which can be anything.
 #[derive(Clone)]
 pub struct Argument {
     pub name: String,
-    parser: Rc<dyn ArgumentType>,
+    parser: Arc<dyn ArgumentType + Send + Sync>,
 }
 impl Argument {
-    pub fn new(name: &str, parser: Rc<dyn ArgumentType>) -> Self {
+    pub fn new(name: &str, parser: Arc<dyn ArgumentType + Send + Sync>) -> Self {
         Self {
             name: name.to_string(),
             parser,
@@ -40,6 +40,9 @@ impl Debug for Argument {
 }
 
 /// Shortcut for creating a new argument builder node.
-pub fn argument<S>(name: &str, parser: impl ArgumentType + 'static) -> ArgumentBuilder<S> {
-    ArgumentBuilder::new(Argument::new(name, Rc::new(parser)).into())
+pub fn argument<S>(
+    name: &str,
+    parser: impl ArgumentType + Send + Sync + 'static,
+) -> ArgumentBuilder<S> {
+    ArgumentBuilder::new(Argument::new(name, Arc::new(parser)).into())
 }
diff --git a/azalea-brigadier/src/command_dispatcher.rs b/azalea-brigadier/src/command_dispatcher.rs
index 0d84171e..384a28dd 100755
--- a/azalea-brigadier/src/command_dispatcher.rs
+++ b/azalea-brigadier/src/command_dispatcher.rs
@@ -13,8 +13,8 @@ use std::{cmp::Ordering, collections::HashMap, mem, rc::Rc, sync::Arc};
 /// The root of the command tree. You need to make this to register commands.
 #[derive(Default)]
 pub struct CommandDispatcher<S>
-// where
-//     Self: Sync + Send,
+where
+    Self: Sync + Send,
 {
     pub root: Arc<RwLock<CommandNode<S>>>,
 }
@@ -32,7 +32,7 @@ impl<S> CommandDispatcher<S> {
         build
     }
 
-    pub fn parse(&self, command: StringReader, source: Rc<S>) -> ParseResults<S> {
+    pub fn parse(&self, command: StringReader, source: Arc<S>) -> ParseResults<S> {
         let context = CommandContextBuilder::new(self, source, self.root.clone(), command.cursor());
         self.parse_nodes(&self.root, &command, context).unwrap()
     }
@@ -91,7 +91,7 @@ impl<S> CommandDispatcher<S> {
                     let parse = self
                         .parse_nodes(redirect, &reader, child_context)
                         .expect("Parsing nodes failed");
-                    context.with_child(Rc::new(parse.context));
+                    context.with_child(Arc::new(parse.context));
                     return Ok(ParseResults {
                         context,
                         reader: parse.reader,
@@ -144,7 +144,7 @@ impl<S> CommandDispatcher<S> {
     pub fn execute(
         &self,
         input: StringReader,
-        source: Rc<S>,
+        source: Arc<S>,
     ) -> Result<i32, CommandSyntaxException> {
         let parse = self.parse(input, source);
         Self::execute_parsed(parse)
diff --git a/azalea-brigadier/src/context/command_context.rs b/azalea-brigadier/src/context/command_context.rs
index 88af2002..1734bb05 100755
--- a/azalea-brigadier/src/context/command_context.rs
+++ b/azalea-brigadier/src/context/command_context.rs
@@ -9,15 +9,15 @@ use std::{any::Any, collections::HashMap, fmt::Debug, rc::Rc, sync::Arc};
 
 /// A built `CommandContextBuilder`.
 pub struct CommandContext<S> {
-    pub source: Rc<S>,
+    pub source: Arc<S>,
     pub input: String,
     pub arguments: HashMap<String, ParsedArgument>,
     pub command: Command<S>,
     pub root_node: Arc<RwLock<CommandNode<S>>>,
     pub nodes: Vec<ParsedCommandNode<S>>,
     pub range: StringRange,
-    pub child: Option<Rc<CommandContext<S>>>,
-    pub modifier: Option<Rc<RedirectModifier<S>>>,
+    pub child: Option<Arc<CommandContext<S>>>,
+    pub modifier: Option<Arc<RedirectModifier<S>>>,
     pub forks: bool,
 }
 
@@ -56,8 +56,8 @@ impl<S> Debug for CommandContext<S> {
 }
 
 impl<S> CommandContext<S> {
-    pub fn copy_for(&self, source: Rc<S>) -> Self {
-        if Rc::ptr_eq(&source, &self.source) {
+    pub fn copy_for(&self, source: Arc<S>) -> Self {
+        if Arc::ptr_eq(&source, &self.source) {
             return self.clone();
         }
         CommandContext {
diff --git a/azalea-brigadier/src/context/command_context_builder.rs b/azalea-brigadier/src/context/command_context_builder.rs
index 54063879..78088941 100755
--- a/azalea-brigadier/src/context/command_context_builder.rs
+++ b/azalea-brigadier/src/context/command_context_builder.rs
@@ -9,18 +9,18 @@ use crate::{
     modifier::RedirectModifier,
     tree::{Command, CommandNode},
 };
-use std::{collections::HashMap, fmt::Debug, rc::Rc, sync::Arc};
+use std::{collections::HashMap, fmt::Debug, sync::Arc};
 
 pub struct CommandContextBuilder<'a, S> {
     pub arguments: HashMap<String, ParsedArgument>,
     pub root: Arc<RwLock<CommandNode<S>>>,
     pub nodes: Vec<ParsedCommandNode<S>>,
     pub dispatcher: &'a CommandDispatcher<S>,
-    pub source: Rc<S>,
+    pub source: Arc<S>,
     pub command: Command<S>,
-    pub child: Option<Rc<CommandContextBuilder<'a, S>>>,
+    pub child: Option<Arc<CommandContextBuilder<'a, S>>>,
     pub range: StringRange,
-    pub modifier: Option<Rc<RedirectModifier<S>>>,
+    pub modifier: Option<Arc<RedirectModifier<S>>>,
     pub forks: bool,
 }
 
@@ -44,7 +44,7 @@ impl<S> Clone for CommandContextBuilder<'_, S> {
 impl<'a, S> CommandContextBuilder<'a, S> {
     pub fn new(
         dispatcher: &'a CommandDispatcher<S>,
-        source: Rc<S>,
+        source: Arc<S>,
         root_node: Arc<RwLock<CommandNode<S>>>,
         start: usize,
     ) -> Self {
@@ -66,7 +66,7 @@ impl<'a, S> CommandContextBuilder<'a, S> {
         self.command = command.clone();
         self
     }
-    pub fn with_child(&mut self, child: Rc<CommandContextBuilder<'a, S>>) -> &Self {
+    pub fn with_child(&mut self, child: Arc<CommandContextBuilder<'a, S>>) -> &Self {
         self.child = Some(child);
         self
     }
@@ -92,7 +92,7 @@ impl<'a, S> CommandContextBuilder<'a, S> {
             nodes: self.nodes.clone(),
             source: self.source.clone(),
             command: self.command.clone(),
-            child: self.child.clone().map(|c| Rc::new(c.build(input))),
+            child: self.child.clone().map(|c| Arc::new(c.build(input))),
             range: self.range.clone(),
             forks: self.forks,
             modifier: self.modifier.clone(),
diff --git a/azalea-brigadier/src/modifier.rs b/azalea-brigadier/src/modifier.rs
index d40d59f9..bebdd0cb 100755
--- a/azalea-brigadier/src/modifier.rs
+++ b/azalea-brigadier/src/modifier.rs
@@ -1,6 +1,6 @@
-use std::rc::Rc;
+use std::sync::Arc;
 
 use crate::{context::CommandContext, exceptions::CommandSyntaxException};
 
 pub type RedirectModifier<S> =
-    dyn Fn(&CommandContext<S>) -> Result<Vec<Rc<S>>, CommandSyntaxException>;
+    dyn Fn(&CommandContext<S>) -> Result<Vec<Arc<S>>, CommandSyntaxException> + Send + Sync;
diff --git a/azalea-brigadier/src/tree/mod.rs b/azalea-brigadier/src/tree/mod.rs
index 902e288b..cec972dc 100755
--- a/azalea-brigadier/src/tree/mod.rs
+++ b/azalea-brigadier/src/tree/mod.rs
@@ -10,9 +10,9 @@ use crate::{
     modifier::RedirectModifier,
     string_reader::StringReader,
 };
-use std::{collections::HashMap, fmt::Debug, hash::Hash, ptr, rc::Rc, sync::Arc};
+use std::{collections::HashMap, fmt::Debug, hash::Hash, ptr, sync::Arc};
 
-pub type Command<S> = Option<Rc<dyn Fn(&CommandContext<S>) -> i32>>;
+pub type Command<S> = Option<Arc<dyn Fn(&CommandContext<S>) -> i32 + Send + Sync>>;
 
 /// An ArgumentBuilder that has been built.
 #[non_exhaustive]
@@ -24,10 +24,10 @@ pub struct CommandNode<S> {
     pub arguments: HashMap<String, Arc<RwLock<CommandNode<S>>>>,
 
     pub command: Command<S>,
-    pub requirement: Rc<dyn Fn(Rc<S>) -> bool>,
+    pub requirement: Arc<dyn Fn(Arc<S>) -> bool + Send + Sync>,
     pub redirect: Option<Arc<RwLock<CommandNode<S>>>>,
     pub forks: bool,
-    pub modifier: Option<Rc<RedirectModifier<S>>>,
+    pub modifier: Option<Arc<RedirectModifier<S>>>,
 }
 
 impl<S> Clone for CommandNode<S> {
@@ -90,7 +90,7 @@ impl<S> CommandNode<S> {
         }
     }
 
-    pub fn can_use(&self, source: Rc<S>) -> bool {
+    pub fn can_use(&self, source: Arc<S>) -> bool {
         (self.requirement)(source)
     }
 
@@ -221,7 +221,7 @@ impl<S> Default for CommandNode<S> {
             arguments: HashMap::new(),
 
             command: None,
-            requirement: Rc::new(|_| true),
+            requirement: Arc::new(|_| true),
             redirect: None,
             forks: false,
             modifier: None,
@@ -257,7 +257,7 @@ impl<S> PartialEq for CommandNode<S> {
             // idk how to do this better since we can't compare `dyn Fn`s
             if let Some(otherexecutes) = &other.command {
                 #[allow(clippy::vtable_address_comparisons)]
-                if !Rc::ptr_eq(selfexecutes, otherexecutes) {
+                if !Arc::ptr_eq(selfexecutes, otherexecutes) {
                     return false;
                 }
             } else {
diff --git a/azalea-brigadier/tests/command_dispatcher_test.rs b/azalea-brigadier/tests/command_dispatcher_test.rs
index fb0085ba..4479cfa2 100755
--- a/azalea-brigadier/tests/command_dispatcher_test.rs
+++ b/azalea-brigadier/tests/command_dispatcher_test.rs
@@ -1,4 +1,4 @@
-use std::rc::Rc;
+use std::sync::Arc;
 
 use azalea_brigadier::{
     arguments::integer_argument_type::integer,
@@ -25,7 +25,7 @@ fn create_and_execute_command() {
 
     assert_eq!(
         subject
-            .execute("foo".into(), Rc::new(CommandSource {}))
+            .execute("foo".into(), Arc::new(CommandSource {}))
             .unwrap(),
         42
     );
@@ -38,7 +38,7 @@ fn create_and_execute_offset_command() {
 
     assert_eq!(
         subject
-            .execute(input_with_offset("/foo", 1), Rc::new(CommandSource {}))
+            .execute(input_with_offset("/foo", 1), Arc::new(CommandSource {}))
             .unwrap(),
         42
     );
@@ -52,13 +52,13 @@ fn create_and_merge_commands() {
 
     assert_eq!(
         subject
-            .execute("base foo".into(), Rc::new(CommandSource {}))
+            .execute("base foo".into(), Arc::new(CommandSource {}))
             .unwrap(),
         42
     );
     assert_eq!(
         subject
-            .execute("base bar".into(), Rc::new(CommandSource {}))
+            .execute("base bar".into(), Arc::new(CommandSource {}))
             .unwrap(),
         42
     );
@@ -70,7 +70,7 @@ fn execute_unknown_command() {
     subject.register(literal("bar"));
     subject.register(literal("baz"));
 
-    let execute_result = subject.execute("foo".into(), Rc::new(CommandSource {}));
+    let execute_result = subject.execute("foo".into(), Arc::new(CommandSource {}));
 
     let err = execute_result.err().unwrap();
     match err.type_ {
@@ -85,7 +85,7 @@ fn execute_impermissible_command() {
     let mut subject = CommandDispatcher::new();
     subject.register(literal("foo").requires(|_| false));
 
-    let execute_result = subject.execute("foo".into(), Rc::new(CommandSource {}));
+    let execute_result = subject.execute("foo".into(), Arc::new(CommandSource {}));
 
     let err = execute_result.err().unwrap();
     match err.type_ {
@@ -100,7 +100,7 @@ fn execute_empty_command() {
     let mut subject = CommandDispatcher::new();
     subject.register(literal(""));
 
-    let execute_result = subject.execute("".into(), Rc::new(CommandSource {}));
+    let execute_result = subject.execute("".into(), Arc::new(CommandSource {}));
 
     let err = execute_result.err().unwrap();
     match err.type_ {
@@ -115,7 +115,7 @@ fn execute_unknown_subcommand() {
     let mut subject = CommandDispatcher::new();
     subject.register(literal("foo").executes(|_| 42));
 
-    let execute_result = subject.execute("foo bar".into(), Rc::new(CommandSource {}));
+    let execute_result = subject.execute("foo bar".into(), Arc::new(CommandSource {}));
 
     let err = execute_result.err().unwrap();
     match err.type_ {
@@ -130,7 +130,7 @@ fn execute_incorrect_literal() {
     let mut subject = CommandDispatcher::new();
     subject.register(literal("foo").executes(|_| 42).then(literal("bar")));
 
-    let execute_result = subject.execute("foo baz".into(), Rc::new(CommandSource {}));
+    let execute_result = subject.execute("foo baz".into(), Arc::new(CommandSource {}));
 
     let err = execute_result.err().unwrap();
     match err.type_ {
@@ -150,7 +150,7 @@ fn execute_ambiguous_incorrect_argument() {
             .then(literal("baz")),
     );
 
-    let execute_result = subject.execute("foo unknown".into(), Rc::new(CommandSource {}));
+    let execute_result = subject.execute("foo unknown".into(), Arc::new(CommandSource {}));
 
     let err = execute_result.err().unwrap();
     match err.type_ {
@@ -174,7 +174,7 @@ fn execute_subcommand() {
 
     assert_eq!(
         subject
-            .execute("foo =".into(), Rc::new(CommandSource {}))
+            .execute("foo =".into(), Arc::new(CommandSource {}))
             .unwrap(),
         100
     );
@@ -185,7 +185,7 @@ fn parse_incomplete_literal() {
     let mut subject = CommandDispatcher::new();
     subject.register(literal("foo").then(literal("bar").executes(|_| 42)));
 
-    let parse = subject.parse("foo ".into(), Rc::new(CommandSource {}));
+    let parse = subject.parse("foo ".into(), Arc::new(CommandSource {}));
     assert_eq!(parse.reader.remaining(), " ");
     assert_eq!(parse.context.nodes.len(), 1);
 }
@@ -195,7 +195,7 @@ fn parse_incomplete_argument() {
     let mut subject = CommandDispatcher::new();
     subject.register(literal("foo").then(argument("bar", integer()).executes(|_| 42)));
 
-    let parse = subject.parse("foo ".into(), Rc::new(CommandSource {}));
+    let parse = subject.parse("foo ".into(), Arc::new(CommandSource {}));
     assert_eq!(parse.reader.remaining(), " ");
     assert_eq!(parse.context.nodes.len(), 1);
 }
@@ -212,7 +212,7 @@ fn execute_ambiguious_parent_subcommand() {
 
     assert_eq!(
         subject
-            .execute("test 1 2".into(), Rc::new(CommandSource {}))
+            .execute("test 1 2".into(), Arc::new(CommandSource {}))
             .unwrap(),
         100
     );
@@ -232,7 +232,7 @@ fn execute_ambiguious_parent_subcommand_via_redirect() {
 
     assert_eq!(
         subject
-            .execute("redirect 1 2".into(), Rc::new(CommandSource {}))
+            .execute("redirect 1 2".into(), Arc::new(CommandSource {}))
             .unwrap(),
         100
     );
@@ -248,7 +248,7 @@ fn execute_redirected_multiple_times() {
 
     let input = "redirected redirected actual";
 
-    let parse = subject.parse(input.into(), Rc::new(CommandSource {}));
+    let parse = subject.parse(input.into(), Arc::new(CommandSource {}));
     assert_eq!(parse.context.range.get(input), "redirected");
     assert_eq!(parse.context.nodes.len(), 1);
     assert_eq!(*parse.context.root.read(), *root.read());
@@ -287,19 +287,19 @@ fn execute_redirected_multiple_times() {
 fn execute_redirected() {
     let mut subject = CommandDispatcher::new();
 
-    let source1 = Rc::new(CommandSource {});
-    let source2 = Rc::new(CommandSource {});
+    let source1 = Arc::new(CommandSource {});
+    let source2 = Arc::new(CommandSource {});
 
-    let modifier = move |_: &CommandContext<CommandSource>| -> Result<Vec<Rc<CommandSource>>, CommandSyntaxException> {
+    let modifier = move |_: &CommandContext<CommandSource>| -> Result<Vec<Arc<CommandSource>>, CommandSyntaxException> {
             Ok(vec![source1.clone(), source2.clone()])
         };
 
     let concrete_node = subject.register(literal("actual").executes(|_| 42));
     let redirect_node =
-        subject.register(literal("redirected").fork(subject.root.clone(), Rc::new(modifier)));
+        subject.register(literal("redirected").fork(subject.root.clone(), Arc::new(modifier)));
 
     let input = "redirected actual";
-    let parse = subject.parse(input.into(), Rc::new(CommandSource {}));
+    let parse = subject.parse(input.into(), Arc::new(CommandSource {}));
     assert_eq!(parse.context.range.get(input), "redirected");
     assert_eq!(parse.context.nodes.len(), 1);
     assert_eq!(*parse.context.root.read(), *subject.root.read());
@@ -314,7 +314,7 @@ fn execute_redirected() {
     assert_eq!(*parse.context.root.read(), *subject.root.read());
     assert_eq!(parent.nodes[0].range, parent.range);
     assert_eq!(*parent.nodes[0].node.read(), *concrete_node.read());
-    assert_eq!(parent.source, Rc::new(CommandSource {}));
+    assert_eq!(parent.source, Arc::new(CommandSource {}));
 
     assert_eq!(CommandDispatcher::execute_parsed(parse).unwrap(), 2);
 }
@@ -329,7 +329,7 @@ fn execute_orphaned_subcommand() {
             .executes(|_| 42),
     );
 
-    let result = subject.execute("foo 5".into(), Rc::new(CommandSource {}));
+    let result = subject.execute("foo 5".into(), Arc::new(CommandSource {}));
     assert!(result.is_err());
     let result = result.unwrap_err();
     assert_eq!(
@@ -348,7 +348,7 @@ fn execute_invalid_other() {
 
     assert_eq!(
         subject
-            .execute("world".into(), Rc::new(CommandSource {}))
+            .execute("world".into(), Arc::new(CommandSource {}))
             .unwrap(),
         42
     );
@@ -364,7 +364,7 @@ fn parse_no_space_separator() {
             .executes(|_| 42),
     );
 
-    let result = subject.execute("foo$".into(), Rc::new(CommandSource {}));
+    let result = subject.execute("foo$".into(), Arc::new(CommandSource {}));
     assert!(result.is_err());
     let result = result.unwrap_err();
     assert_eq!(
@@ -384,7 +384,7 @@ fn execute_invalid_subcommand() {
             .executes(|_| 42),
     );
 
-    let result = subject.execute("foo bar".into(), Rc::new(CommandSource {}));
+    let result = subject.execute("foo bar".into(), Arc::new(CommandSource {}));
     assert!(result.is_err());
     let result = result.unwrap_err();
     // this fails for some reason, i blame mojang
-- 
cgit v1.2.3