progress

3 files changed, 70 insertions, 82 deletions

diff --git a/azalea-brigadier/src/builder/argument_builder.rs b/azalea-brigadier/src/builder/argument_builder.rs
index 19706a22..bd2a2c15 100644
--- a/azalea-brigadier/src/builder/argument_builder.rs
+++ b/azalea-brigadier/src/builder/argument_builder.rs
@@ -5,27 +5,25 @@ use crate::{
     tree::{command_node::CommandNode, root_command_node::RootCommandNode},
 };
 
-pub struct BaseArgumentBuilder<S, T>
+pub struct BaseArgumentBuilder<'a, S, T>
 where
-    T: ArgumentBuilder<S, T>,
+    S: Sized,
+    T: Sized,
 {
-    arguments: RootCommandNode<S>,
-    command: Option<dyn Command<S>>,
-    requirement: dyn Fn(&S) -> bool,
-    target: Option<dyn CommandNode<S>>,
-    modifier: Option<dyn RedirectModifier<S>>,
+    arguments: RootCommandNode<'a, S, T>,
+    command: Option<&'a dyn Command<S, T>>,
+    requirement: &'a dyn Fn(&S) -> bool,
+    target: Option<&'a dyn CommandNode<S, T>>,
+    modifier: Option<&'a dyn RedirectModifier<S, T>>,
     forks: bool,
 }
 
 pub trait ArgumentBuilder<S, T> {
-    fn build(self) -> dyn CommandNode<S>;
+    fn build(self) -> dyn CommandNode<S, T>;
 }
 
-impl<S, T> BaseArgumentBuilder<S, T>
-where
-    T: ArgumentBuilder<S, T>,
-{
-    pub fn then(&mut self, command: dyn CommandNode<S>) -> Result<&mut T, String> {
+impl<S, T> BaseArgumentBuilder<'_, S, T> {
+    pub fn then(&mut self, command: dyn CommandNode<S, T>) -> Result<&mut T, String> {
         if self.target.is_some() {
             return Err("Cannot add children to a redirected node".to_string());
         }
@@ -33,20 +31,20 @@ where
         Ok(self)
     }
 
-    pub fn arguments(&self) -> &Vec<dyn CommandNode<S>> {
+    pub fn arguments(&self) -> &Vec<&dyn CommandNode<S, T>> {
         &self.arguments.get_children()
     }
 
-    pub fn executes(&mut self, command: dyn Command<S>) -> &mut T {
+    pub fn executes(&mut self, command: dyn Command<S, T>) -> &mut T {
         self.command = command;
         self
     }
 
-    pub fn command(&self) -> dyn Command<S> {
+    pub fn command(&self) -> dyn Command<S, T> {
         self.command
     }
 
-    pub fn requires(&mut self, requirement: dyn Fn(&S) -> bool) -> &mut T {
+    pub fn requires(&mut self, requirement: &dyn Fn(&S) -> bool) -> &mut T {
         self.requirement = requirement;
         self
     }
@@ -55,14 +53,14 @@ where
         self.requirement
     }
 
-    pub fn redirect(&mut self, target: dyn CommandNode<S>) -> &mut T {
+    pub fn redirect(&mut self, target: &dyn CommandNode<S, T>) -> &mut T {
         self.forward(target, None, false)
     }
 
     pub fn redirect_modifier(
         &mut self,
-        target: dyn CommandNode<S>,
-        modifier: dyn SingleRedirectModifier<S>,
+        target: &dyn CommandNode<S, T>,
+        modifier: &dyn SingleRedirectModifier<S, T>,
     ) -> &mut T {
         // forward(target, modifier == null ? null : o -> Collections.singleton(modifier.apply(o)), false);
         self.forward(target, modifier.map(|m| |o| vec![m.apply(o)]), false)
@@ -70,16 +68,16 @@ where
 
     pub fn fork(
         &mut self,
-        target: dyn CommandNode<S>,
-        modifier: dyn RedirectModifier<S>,
+        target: &dyn CommandNode<S, T>,
+        modifier: &dyn RedirectModifier<S, T>,
     ) -> &mut T {
         self.forward(target, Some(modifier), true)
     }
 
     pub fn forward(
         &mut self,
-        target: dyn CommandNode<S>,
-        modifier: Option<dyn RedirectModifier<S>>,
+        target: &dyn CommandNode<S, T>,
+        modifier: Option<&dyn RedirectModifier<S, T>>,
         fork: bool,
     ) -> Result<&mut T, String> {
         if !self.arguments.get_children().is_empty() {
@@ -91,11 +89,11 @@ where
         Ok(self)
     }
 
-    pub fn get_redirect(&self) -> Option<&dyn CommandNode<S>> {
+    pub fn get_redirect(&self) -> Option<&dyn CommandNode<S, T>> {
         self.target.as_ref()
     }
 
-    pub fn get_redirect_modifier(&self) -> Option<&dyn RedirectModifier<S>> {
+    pub fn get_redirect_modifier(&self) -> Option<&dyn RedirectModifier<S, T>> {
         self.modifier.as_ref()
     }
 
diff --git a/azalea-brigadier/src/builder/literal_argument_builder.rs b/azalea-brigadier/src/builder/literal_argument_builder.rs
index e69de29b..cf9f1ee9 100644
--- a/azalea-brigadier/src/builder/literal_argument_builder.rs
+++ b/azalea-brigadier/src/builder/literal_argument_builder.rs
@@ -0,0 +1,32 @@
+use crate::tree::literal_command_node::LiteralCommandNode;
+
+use super::argument_builder::BaseArgumentBuilder;
+
+pub struct LiteralArgumentBuilder<'a, S, T> {
+    literal: String,
+
+    pub base: BaseArgumentBuilder<'a, S, T>,
+}
+
+impl<'a, S, T> LiteralArgumentBuilder<'a, S, T> {
+    pub fn new(literal: String) -> Self {
+        Self {
+            literal,
+            base: BaseArgumentBuilder::default(),
+        }
+    }
+
+    pub fn literal(name: String) -> Self {
+        Self::new(name)
+    }
+
+    pub fn build(self) -> LiteralCommandNode<'a, S, T> {
+        let result = LiteralCommandNode::new(self.literal, self.base);
+
+        for argument in self.base.arguments {
+            result.add_child(argument);
+        }
+
+        result
+    }
+}
diff --git a/azalea-brigadier/src/builder/required_argument_builder.rs b/azalea-brigadier/src/builder/required_argument_builder.rs
index 3ec613c4..6f6fa8eb 100644
--- a/azalea-brigadier/src/builder/required_argument_builder.rs
+++ b/azalea-brigadier/src/builder/required_argument_builder.rs
@@ -1,92 +1,50 @@
 use crate::{
-    arguments::argument_type::ArgumentType,
     suggestion::suggestion_provider::SuggestionProvider,
     tree::{argument_command_node::ArgumentCommandNode, command_node::BaseCommandNode},
 };
 
 use super::argument_builder::BaseArgumentBuilder;
 
-// private RequiredArgumentBuilder(final String name, final ArgumentType<T> type) {
-// 	this.name = name;
-// 	this.type = type;
-// }
-
-// public static <S, T> RequiredArgumentBuilder<S, T> argument(final String name, final ArgumentType<T> type) {
-// 	return new RequiredArgumentBuilder<>(name, type);
-// }
-
-// public RequiredArgumentBuilder<S, T> suggests(final SuggestionProvider<S> provider) {
-// 	this.suggestionsProvider = provider;
-// 	return getThis();
-// }
-
-// public SuggestionProvider<S> getSuggestionsProvider() {
-// 	return suggestionsProvider;
-// }
-
-// @Override
-// protected RequiredArgumentBuilder<S, T> getThis() {
-// 	return this;
-// }
-
-// public ArgumentType<T> getType() {
-// 	return type;
-// }
-
-// public String getName() {
-// 	return name;
-// }
-
-// public ArgumentCommandNode<S, T> build() {
-// 	final ArgumentCommandNode<S, T> result = new ArgumentCommandNode<>(getName(), getType(), getCommand(), getRequirement(), getRedirect(), getRedirectModifier(), isFork(), getSuggestionsProvider());
-
-// 	for (final CommandNode<S> argument : getArguments()) {
-// 		result.addChild(argument);
-// 	}
-
-// 	return result;
-// }
-
-pub struct RequiredArgumentBuilder<S, T> {
+pub struct RequiredArgumentBuilder<'a, S, T> {
     // private final String name;
     // private final ArgumentType<T> type;
     // private SuggestionProvider<S> suggestionsProvider = null;
     name: String,
-    type_: dyn ArgumentType<T>,
-    suggestions_provider: Option<dyn SuggestionProvider<S>>,
+    type_: &'a T,
+    suggestions_provider: Option<&'a dyn SuggestionProvider<S, T>>,
 
-    pub base: BaseArgumentBuilder<S, T>,
+    pub base: BaseArgumentBuilder<'a, S, T>,
 }
 
-impl<S, T> RequiredArgumentBuilder<S, T> {
-    pub fn new(name: String, type_: dyn ArgumentType<T>) -> Self {
+impl<'a, S, T> RequiredArgumentBuilder<'a, S, T> {
+    pub fn new(name: String, type_: T) -> Self {
         Self {
             name,
-            type_,
+            type_: &type_,
             suggestions_provider: None,
             base: BaseArgumentBuilder::new(name, type_),
         }
     }
 
-    pub fn argument(name: String, type_: dyn ArgumentType<T>) -> Self {
+    pub fn argument(name: String, type_: T) -> Self {
         Self::new(name, type_)
     }
 
-    pub fn suggests(mut self, provider: dyn SuggestionProvider<S>) -> Self {
+    pub fn suggests(mut self, provider: &dyn SuggestionProvider<S, T>) -> Self {
         self.suggestions_provider = Some(provider);
         self
     }
 
-    pub fn suggestions_provider(&self) -> Option<&dyn SuggestionProvider<S>> {
+    pub fn suggestions_provider(&self) -> Option<&dyn SuggestionProvider<S, T>> {
         self.suggestions_provider.as_ref()
     }
 
-    pub fn get_type(&self) -> &dyn ArgumentType<T> {
-        &self.type_
+    pub fn get_type(&self) -> &T {
+        self.type_
     }
 
     pub fn name(&self) -> &str {
-        &self.name
+        self.name
     }
 
     // final ArgumentCommandNode<S, T> result = new ArgumentCommandNode<>(getName(), getType(), getCommand(), getRequirement(), getRedirect(), getRedirectModifier(), isFork(), getSuggestionsProvider());
@@ -96,7 +54,7 @@ impl<S, T> RequiredArgumentBuilder<S, T> {
     // }
 
     // return result;
-    pub fn build(self) -> ArgumentCommandNode<S, T> {
+    pub fn build(self) -> ArgumentCommandNode<'a, S, T> {
         let result = ArgumentCommandNode {
             name: self.name,
             type_: &self.type_,