b

4 files changed, 183 insertions, 128 deletions

diff --git a/azalea-brigadier/src/tree/argument_command_node.rs b/azalea-brigadier/src/tree/argument_command_node.rs
index e33c3d3e..0997ec17 100644
--- a/azalea-brigadier/src/tree/argument_command_node.rs
+++ b/azalea-brigadier/src/tree/argument_command_node.rs
@@ -1,17 +1,20 @@
 use std::{
     any::Any,
-    fmt::{Display, Formatter},
+    collections::HashMap,
+    fmt::{Debug, Display, Formatter},
 };
 
 use crate::{
     arguments::argument_type::ArgumentType,
     builder::required_argument_builder::RequiredArgumentBuilder,
+    command::Command,
     context::{
         command_context::CommandContext, command_context_builder::CommandContextBuilder,
         parsed_argument::ParsedArgument,
     },
     exceptions::command_syntax_exception::CommandSyntaxException,
     immutable_string_reader::ImmutableStringReader,
+    redirect_modifier::RedirectModifier,
     string_reader::StringReader,
     suggestion::{
         suggestion_provider::SuggestionProvider, suggestions::Suggestions,
@@ -19,12 +22,16 @@ use crate::{
     },
 };
 
-use super::command_node::{BaseCommandNode, CommandNode};
+use super::{
+    command_node::{BaseCommandNode, CommandNodeTrait},
+    literal_command_node::LiteralCommandNode,
+    root_command_node::RootCommandNode,
+};
 
 const USAGE_ARGUMENT_OPEN: &str = "<";
 const USAGE_ARGUMENT_CLOSE: &str = ">";
 
-#[derive(Clone)]
+#[derive(Clone, Debug)]
 pub struct ArgumentCommandNode<'a, S> {
     name: String,
     type_: Box<dyn ArgumentType<Into = dyn Any>>,
@@ -32,6 +39,15 @@ pub struct ArgumentCommandNode<'a, S> {
     // custom_suggestions: &'a dyn SuggestionProvider<S>,
     // Since Rust doesn't have extending, we put the struct this is extending as the "base" field
     pub base: BaseCommandNode<'a, S>,
+
+    children: HashMap<String, Box<dyn CommandNodeTrait<S>>>,
+    literals: HashMap<String, LiteralCommandNode<'a, S>>,
+    arguments: HashMap<String, ArgumentCommandNode<'a, S>>,
+    pub requirement: Box<dyn Fn(&S) -> bool>,
+    redirect: Option<Box<dyn CommandNodeTrait<S>>>,
+    modifier: Option<Box<dyn RedirectModifier<S>>>,
+    forks: bool,
+    pub command: Option<Box<dyn Command<S>>>,
 }
 
 impl<S> ArgumentCommandNode<'_, S> {
@@ -44,10 +60,7 @@ impl<S> ArgumentCommandNode<'_, S> {
     }
 }
 
-impl<'a, S> CommandNode<S> for ArgumentCommandNode<'a, S>
-where
-    S: Clone,
-{
+impl<'a, S> CommandNodeTrait<S> for ArgumentCommandNode<'a, S> {
     fn name(&self) -> &str {
         &self.name
     }
@@ -119,8 +132,44 @@ where
         self.type_.get_examples()
     }
 
-    fn base(&self) -> &BaseCommandNode<S> {
-        &self.base
+    fn redirect_modifier(&self) -> Option<&dyn RedirectModifier<S>> {
+        self.modifier.as_ref().map(|modifier| modifier.as_ref())
+    }
+
+    fn can_use(&self, source: S) -> bool {
+        (self.requirement)(&source)
+    }
+
+    fn add_child(&self, node: &Box<dyn CommandNodeTrait<S>>) -> Result<(), String> {
+        let dynamic_node = node as &dyn Any;
+        if dynamic_node.is::<RootCommandNode<S>>() {
+            return Err(String::from(
+                "Cannot add a RootCommandNode as a child to any other CommandNode",
+            ));
+        }
+
+        let mut child = self.children.get(node.name());
+        if let Some(child) = child {
+            // We've found something to merge onto
+            if let Some(command) = node.base().command() {
+                child.base_mut().command = Some(*command);
+            }
+            for grandchild in node.base().children().values() {
+                child.base_mut().add_child(&*grandchild)?;
+            }
+            Ok(())
+        } else {
+            self.children.insert(node.name().to_string(), *node);
+
+            if let Some(dynamic_node) = dynamic_node.downcast_ref::<LiteralCommandNode<S>>() {
+                self.literals.insert(node.name().to_string(), *dynamic_node);
+            } else if let Some(dynamic_node) = dynamic_node.downcast_ref::<ArgumentCommandNode<S>>()
+            {
+                self.arguments
+                    .insert(node.name().to_string(), *dynamic_node);
+            }
+            Ok(())
+        }
     }
 }
 
diff --git a/azalea-brigadier/src/tree/command_node.rs b/azalea-brigadier/src/tree/command_node.rs
index f59b1cef..b7801363 100644
--- a/azalea-brigadier/src/tree/command_node.rs
+++ b/azalea-brigadier/src/tree/command_node.rs
@@ -12,117 +12,112 @@ use crate::{
     string_reader::StringReader,
     suggestion::{suggestions::Suggestions, suggestions_builder::SuggestionsBuilder},
 };
-use dyn_clonable::*;
+use std::ops::Deref;
 use std::{any::Any, collections::HashMap, fmt::Debug};
 
-pub struct BaseCommandNode<'a, S> {
-    children: HashMap<String, Box<dyn CommandNode<S>>>,
-    literals: HashMap<String, LiteralCommandNode<'a, S>>,
-    arguments: HashMap<String, ArgumentCommandNode<'a, S>>,
-    requirement: Box<dyn Fn(&S) -> bool>,
-    redirect: Option<Box<dyn CommandNode<S>>>,
-    modifier: Option<Box<dyn RedirectModifier<S>>>,
-    forks: bool,
-    command: Option<Box<dyn Command<S>>>,
+enum CommandNodeEnum<'a, S> {
+    Literal(LiteralCommandNode<'a, S>),
+    Argument(ArgumentCommandNode<'a, S>),
+    Root(RootCommandNode<'a, S>),
 }
 
-impl<S> BaseCommandNode<'_, S> {
-    pub fn command(&self) -> &Option<Box<dyn Command<S>>> {
-        &self.command
+impl<S> Deref for CommandNodeEnum<'_, S> {
+    type Target = dyn CommandNodeTrait<S>;
+
+    fn deref(&self) -> &Self::Target {
+        match self {
+            CommandNodeEnum::Literal(node) => node,
+            CommandNodeEnum::Argument(node) => node,
+            CommandNodeEnum::Root(node) => node,
+        }
     }
+}
 
-    pub fn children(&self) -> &HashMap<String, Box<dyn CommandNode<S>>> {
-        &self.children
+impl<S> From<LiteralCommandNode<'_, S>> for CommandNodeEnum<'_, S> {
+    fn from(node: LiteralCommandNode<'_, S>) -> Self {
+        CommandNodeEnum::Literal(node)
     }
+}
 
-    pub fn child(&self, name: &str) -> Option<&dyn CommandNode<S>> {
-        self.children.get(name).map(|child| child.as_ref())
+impl<S> From<ArgumentCommandNode<'_, S>> for CommandNodeEnum<'_, S> {
+    fn from(node: ArgumentCommandNode<'_, S>) -> Self {
+        CommandNodeEnum::Argument(node)
     }
+}
 
-    pub fn redirect(&self) -> Option<&dyn CommandNode<S>> {
-        self.redirect.as_ref().map(|redirect| redirect.as_ref())
+impl<S> From<RootCommandNode<'_, S>> for CommandNodeEnum<'_, S> {
+    fn from(node: RootCommandNode<'_, S>) -> Self {
+        CommandNodeEnum::Root(node)
     }
+}
 
-    pub fn redirect_modifier(&self) -> Option<&dyn RedirectModifier<S>> {
-        self.modifier.as_ref().map(|modifier| modifier.as_ref())
+impl<S> CommandNodeEnum<'_, S> {
+    fn redirect_modifier(&self) -> Option<&dyn RedirectModifier<S>> {
+        (*self).modifier.as_ref().map(|modifier| modifier.as_ref())
     }
 
-    pub fn can_use(&self, source: S) -> bool {
+    fn can_use(&self, source: S) -> bool {
         (self.requirement)(&source)
     }
 
-    // public void addChild(final CommandNode<S> node) {
-    //     if (node instanceof RootCommandNode) {
-    //         throw new UnsupportedOperationException("Cannot add a RootCommandNode as a child to any other CommandNode");
-    //     }
-
-    //     final CommandNode<S> child = children.get(node.getName());
-    //     if (child != null) {
-    //         // We've found something to merge onto
-    //         if (node.getCommand() != null) {
-    //             child.command = node.getCommand();
-    //         }
-    //         for (final CommandNode<S> grandchild : node.getChildren()) {
-    //             child.addChild(grandchild);
-    //         }
-    //     } else {
-    //         children.put(node.getName(), node);
-    //         if (node instanceof LiteralCommandNode) {
-    //             literals.put(node.getName(), (LiteralCommandNode<S>) node);
-    //         } else if (node instanceof ArgumentCommandNode) {
-    //             arguments.put(node.getName(), (ArgumentCommandNode<S, ?>) node);
-    //         }
-    //     }
-    // }
-
-    pub fn add_child(&self, node: &dyn CommandNode<S>) -> Result<(), String> {
-        if (&node as &dyn Any).is::<RootCommandNode<S>>() {
+    fn add_child(&self, node: &Box<dyn CommandNodeTrait<S>>) -> Result<(), String> {
+        let dynamic_node = node as &dyn Any;
+        if dynamic_node.is::<RootCommandNode<S>>() {
             return Err(String::from(
                 "Cannot add a RootCommandNode as a child to any other CommandNode",
             ));
         }
 
-        let child = self.children.get(node.name());
+        let mut child = self.children.get(node.name());
         if let Some(child) = child {
             // We've found something to merge onto
-            if let Some(command) = node.base.command() {
-                child.command = Some(command);
+            if let Some(command) = node.base().command() {
+                child.base_mut().command = Some(*command);
             }
-            for grandchild in node.children() {
-                child.add_child(grandchild)?;
+            for grandchild in node.base().children().values() {
+                child.base_mut().add_child(&*grandchild)?;
             }
+            Ok(())
         } else {
-            self.children.insert(node.name().to_string(), node);
-            if let Some(literal) =
-                &node.clone_boxed() as &dyn Any as &dyn Any as &LiteralCommandNode<S>
-            {
-                self.literals
-                    .insert(node.name().to_string(), literal.clone_boxed());
-            } else if let Some(argument) =
-                &node.clone_boxed() as &dyn Any as &dyn Any as &ArgumentCommandNode<S>
+            self.children.insert(node.name().to_string(), *node);
+
+            if let Some(dynamic_node) = dynamic_node.downcast_ref::<LiteralCommandNode<S>>() {
+                self.literals.insert(node.name().to_string(), *dynamic_node);
+            } else if let Some(dynamic_node) = dynamic_node.downcast_ref::<ArgumentCommandNode<S>>()
             {
                 self.arguments
-                    .insert(node.name().to_string(), argument.clone_boxed());
+                    .insert(node.name().to_string(), *dynamic_node);
             }
+            Ok(())
         }
     }
 }
-
-impl<S> Clone for BaseCommandNode<'_, S> {
-    fn clone(&self) -> Self {
-        Self {
-            children: self.children.clone(),
-            literals: self.literals.clone(),
-            arguments: self.arguments.clone(),
-            requirement: self.requirement.clone(),
-            redirect: self.redirect.clone(),
-            modifier: self.modifier.clone(),
-            forks: self.forks.clone(),
-            command: self.command.clone(),
-        }
-    }
+pub struct BaseCommandNode<'a, S> {
+    children: HashMap<String, Box<dyn CommandNodeTrait<S>>>,
+    literals: HashMap<String, LiteralCommandNode<'a, S>>,
+    arguments: HashMap<String, ArgumentCommandNode<'a, S>>,
+    pub requirement: Box<dyn Fn(&S) -> bool>,
+    redirect: Option<Box<dyn CommandNodeTrait<S>>>,
+    modifier: Option<Box<dyn RedirectModifier<S>>>,
+    forks: bool,
+    pub command: Option<Box<dyn Command<S>>>,
 }
 
+// impl<S> Clone for BaseCommandNode<'_, S> {
+//     fn clone(&self) -> Self {
+//         Self {
+//             children: self.children.clone(),
+//             literals: self.literals.clone(),
+//             arguments: self.arguments.clone(),
+//             requirement: self.requirement.clone(),
+//             redirect: self.redirect.clone(),
+//             modifier: self.modifier.clone(),
+//             forks: self.forks.clone(),
+//             command: self.command.clone(),
+//         }
+//     }
+// }
+
 impl<S> Debug for BaseCommandNode<'_, S> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         f.debug_struct("BaseCommandNode")
@@ -153,7 +148,7 @@ impl<S> Default for BaseCommandNode<'_, S> {
     }
 }
 
-pub trait CommandNode<S> {
+pub trait CommandNodeTrait<S> {
     fn name(&self) -> &str;
     fn usage_text(&self) -> &str;
     fn parse(
@@ -167,7 +162,6 @@ pub trait CommandNode<S> {
         builder: &SuggestionsBuilder,
     ) -> Result<Suggestions, CommandSyntaxException>;
     fn is_valid_input(&self, input: &str) -> bool;
-    fn create_builder(&self) -> dyn ArgumentBuilder<S, dyn Any>;
+    fn create_builder(&self) -> Box<dyn ArgumentBuilder<S>>;
     fn get_examples(&self) -> Vec<String>;
-    fn base(&self) -> &BaseCommandNode<S>;
 }
diff --git a/azalea-brigadier/src/tree/literal_command_node.rs b/azalea-brigadier/src/tree/literal_command_node.rs
index a722121f..253b6dc5 100644
--- a/azalea-brigadier/src/tree/literal_command_node.rs
+++ b/azalea-brigadier/src/tree/literal_command_node.rs
@@ -1,17 +1,19 @@
 use crate::{
     arguments::argument_type::ArgumentType,
-    builder::literal_argument_builder::LiteralArgumentBuilder,
-    command::Command,
+    builder::{
+        argument_builder::ArgumentBuilder, literal_argument_builder::LiteralArgumentBuilder,
+    },
     context::{command_context::CommandContext, command_context_builder::CommandContextBuilder},
     exceptions::{
         builtin_exceptions::BuiltInExceptions, command_syntax_exception::CommandSyntaxException,
     },
-    redirect_modifier::RedirectModifier,
+    immutable_string_reader::ImmutableStringReader,
     string_reader::StringReader,
     suggestion::{suggestions::Suggestions, suggestions_builder::SuggestionsBuilder},
 };
+use std::fmt::Debug;
 
-use super::command_node::{BaseCommandNode, CommandNode};
+use super::command_node::{BaseCommandNode, CommandNodeTrait};
 
 #[derive(Debug, Clone)]
 pub struct LiteralCommandNode<'a, S> {
@@ -22,7 +24,7 @@ pub struct LiteralCommandNode<'a, S> {
 }
 
 impl<'a, S> LiteralCommandNode<'a, S> {
-    pub fn new(literal: String, base: BaseCommandNode<S>) -> Self {
+    pub fn new(literal: String, base: BaseCommandNode<'a, S>) -> Self {
         let literal_lowercase = literal.to_lowercase();
         Self {
             literal,
@@ -35,16 +37,16 @@ impl<'a, S> LiteralCommandNode<'a, S> {
         &self.literal
     }
 
-    pub fn parse(&self, reader: StringReader) -> i32 {
-        let start = reader.get_cursor();
-        if reader.can_read(self.literal.len()) {
+    pub fn parse(&self, reader: &mut StringReader) -> i32 {
+        let start = reader.cursor();
+        if reader.can_read_length(self.literal.len()) {
             let end = start + self.literal.len();
-            if reader.get_string()[start..end].eq(&self.literal) {
-                reader.set_cursor(end);
+            if reader.string()[start..end].eq(&self.literal) {
+                reader.cursor = end;
                 if !reader.can_read() || reader.peek() == ' ' {
                     return end as i32;
                 } else {
-                    reader.set_cursor(start);
+                    reader.cursor = start;
                 }
             }
         }
@@ -52,27 +54,24 @@ impl<'a, S> LiteralCommandNode<'a, S> {
     }
 }
 
-impl<S> CommandNode<S> for LiteralCommandNode<'_, S>
-where
-    S: Clone,
-{
+impl<S> CommandNodeTrait<S> for LiteralCommandNode<'_, S> {
     fn name(&self) -> &str {
         &self.literal
     }
 
     fn parse(
         &self,
-        reader: StringReader,
+        reader: &mut StringReader<'_>,
         context_builder: CommandContextBuilder<S>,
     ) -> Result<(), CommandSyntaxException> {
-        let start = reader.get_cursor();
+        let start = reader.cursor();
         let end = self.parse(reader);
         if end > -1 {
             return Ok(());
         }
 
         Err(BuiltInExceptions::LiteralIncorrect {
-            expected: self.literal(),
+            expected: self.literal().to_string(),
         }
         .create_with_context(reader))
     }
@@ -80,33 +79,41 @@ where
     fn list_suggestions(
         &self,
         context: CommandContext<S>,
-        builder: SuggestionsBuilder,
+        builder: &SuggestionsBuilder,
     ) -> Result<Suggestions, CommandSyntaxException> {
         if self
             .literal_lowercase
             .starts_with(&builder.remaining_lowercase())
         {
-            builder.suggest(self.literal())
+            Ok(builder.suggest(self.literal()).build())
         } else {
-            Suggestions::empty()
+            Ok(Suggestions::default())
         }
     }
 
     fn is_valid_input(&self, input: &str) -> bool {
-        self.parse(StringReader::from(input)) > -1
+        self.parse(&mut StringReader::from(input)) > -1
     }
 
     fn usage_text(&self) -> &str {
-        self.literal
+        &self.literal
     }
 
-    fn create_builder(&self) -> LiteralArgumentBuilder<S> {
-        let builder = LiteralArgumentBuilder::literal(self.literal());
-        builder.requires(self.requirement());
-        builder.forward(self.redirect(), self.redirect_modifier(), self.is_fork());
+    fn create_builder(&self) -> Box<dyn ArgumentBuilder<S>> {
+        let mut builder = LiteralArgumentBuilder::literal(self.literal().to_string());
+        builder.base.requires(&self.base().requirement);
+        builder.base.forward(
+            self.base.redirect(),
+            self.base.redirect_modifier(),
+            self.base.is_fork(),
+        );
         if self.command().is_some() {
             builder.executes(self.command().unwrap());
         }
         builder
     }
+
+    fn get_examples(&self) -> Vec<String> {
+        todo!()
+    }
 }
diff --git a/azalea-brigadier/src/tree/root_command_node.rs b/azalea-brigadier/src/tree/root_command_node.rs
index c3139a05..0fcb8d97 100644
--- a/azalea-brigadier/src/tree/root_command_node.rs
+++ b/azalea-brigadier/src/tree/root_command_node.rs
@@ -1,44 +1,49 @@
-use std::fmt::{Display, Formatter};
-
+use super::{
+    argument_command_node::ArgumentCommandNode,
+    command_node::{BaseCommandNode, CommandNodeTrait},
+    literal_command_node::LiteralCommandNode,
+};
 use crate::{
     arguments::argument_type::ArgumentType,
+    builder::argument_builder::ArgumentBuilder,
     context::{command_context::CommandContext, command_context_builder::CommandContextBuilder},
     exceptions::{
         builtin_exceptions::BuiltInExceptions, command_syntax_exception::CommandSyntaxException,
     },
+    redirect_modifier::RedirectModifier,
     string_reader::StringReader,
     suggestion::{suggestions::Suggestions, suggestions_builder::SuggestionsBuilder},
 };
+use std::{
+    any::Any,
+    fmt::{Debug, Display, Formatter},
+};
 
-use super::command_node::{BaseCommandNode, CommandNode};
-
-#[derive(Clone, Default)]
+#[derive(Clone, Default, Debug)]
 pub struct RootCommandNode<'a, S> {
     // Since Rust doesn't have extending, we put the struct this is extending as the "base" field
     pub base: BaseCommandNode<'a, S>,
 }
 
-impl<S> CommandNode<S> for RootCommandNode<'_, S>
-where
-    S: Clone,
-{
+impl<S> CommandNodeTrait<S> for RootCommandNode<'_, S> {
     fn name(&self) -> &str {
         ""
     }
 
     fn parse(
         &self,
-        reader: StringReader,
+        reader: &mut StringReader<'_>,
         context_builder: CommandContextBuilder<S>,
     ) -> Result<(), CommandSyntaxException> {
+        Ok(())
     }
 
     fn list_suggestions(
         &self,
         context: CommandContext<S>,
-        builder: SuggestionsBuilder,
+        builder: &SuggestionsBuilder,
     ) -> Result<Suggestions, CommandSyntaxException> {
-        Suggestions::empty()
+        Ok(Suggestions::default())
     }
 
     fn is_valid_input(&self, input: &str) -> bool {
@@ -49,7 +54,7 @@ where
         ""
     }
 
-    fn create_builder(&self) -> () {
+    fn create_builder(&self) -> Box<dyn ArgumentBuilder<S>> {
         panic!("Cannot convert root into a builder");
     }