a

3 files changed, 48 insertions, 61 deletions

diff --git a/azalea-brigadier/src/builder/argument_builder.rs b/azalea-brigadier/src/builder/argument_builder.rs
index 0360b05a..6355456a 100644
--- a/azalea-brigadier/src/builder/argument_builder.rs
+++ b/azalea-brigadier/src/builder/argument_builder.rs
@@ -1,33 +1,32 @@
 use crate::{
-    arguments::argument_type::{ArgumentType, Types},
+    arguments::argument_type::ArgumentType,
     command::Command,
     redirect_modifier::RedirectModifier,
     single_redirect_modifier::SingleRedirectModifier,
     tree::{command_node::CommandNode, root_command_node::RootCommandNode},
 };
 
-pub struct BaseArgumentBuilder<'a, S, T>
+pub struct BaseArgumentBuilder<'a, S>
 where
     S: Sized,
-    T: Sized + ArgumentType<dyn Types>,
 {
-    arguments: RootCommandNode<'a, S, T>,
-    command: Option<&'a dyn Command<S, T>>,
+    arguments: RootCommandNode<'a, S>,
+    command: Option<&'a dyn Command<S>>,
     requirement: &'a dyn Fn(&S) -> bool,
-    target: Option<&'a dyn CommandNode<S, T>>,
-    modifier: Option<&'a dyn RedirectModifier<S, T>>,
+    target: Option<&'a dyn CommandNode<S>>,
+    modifier: Option<&'a dyn RedirectModifier<S>>,
     forks: bool,
 }
 
-pub trait ArgumentBuilder<S, T> {
-    fn build(self) -> dyn CommandNode<S, T>;
-}
-
-impl<S, T> BaseArgumentBuilder<'_, S, T>
+pub trait ArgumentBuilder<S, T>
 where
-    T: ArgumentType<dyn Types>,
+    T: ArgumentBuilder<S, T>,
 {
-    pub fn then(&mut self, command: dyn CommandNode<S, T>) -> Result<&mut T, String> {
+    fn build(self) -> dyn CommandNode<S>;
+}
+
+impl<S> BaseArgumentBuilder<'_, S> {
+    pub fn then(&mut self, command: dyn CommandNode<S>) -> Result<&mut Self, String> {
         if self.target.is_some() {
             return Err("Cannot add children to a redirected node".to_string());
         }
@@ -35,20 +34,20 @@ where
         Ok(self)
     }
 
-    pub fn arguments(&self) -> &Vec<&dyn CommandNode<S, T>> {
+    pub fn arguments(&self) -> &Vec<&dyn CommandNode<S>> {
         &self.arguments.get_children()
     }
 
-    pub fn executes(&mut self, command: dyn Command<S, T>) -> &mut T {
+    pub fn executes(&mut self, command: dyn Command<S>) -> &mut Self {
         self.command = command;
         self
     }
 
-    pub fn command(&self) -> dyn Command<S, T> {
+    pub fn command(&self) -> dyn Command<S> {
         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 Self {
         self.requirement = requirement;
         self
     }
@@ -57,33 +56,33 @@ where
         self.requirement
     }
 
-    pub fn redirect(&mut self, target: &dyn CommandNode<S, T>) -> &mut T {
+    pub fn redirect(&mut self, target: &dyn CommandNode<S>) -> &mut Self {
         self.forward(target, None, false)
     }
 
     pub fn redirect_modifier(
         &mut self,
-        target: &dyn CommandNode<S, T>,
-        modifier: &dyn SingleRedirectModifier<S, T>,
-    ) -> &mut T {
+        target: &dyn CommandNode<S>,
+        modifier: &dyn SingleRedirectModifier<S>,
+    ) -> &mut Self {
         // forward(target, modifier == null ? null : o -> Collections.singleton(modifier.apply(o)), false);
         self.forward(target, modifier.map(|m| |o| vec![m.apply(o)]), false)
     }
 
     pub fn fork(
         &mut self,
-        target: &dyn CommandNode<S, T>,
-        modifier: &dyn RedirectModifier<S, T>,
-    ) -> &mut T {
+        target: &dyn CommandNode<S>,
+        modifier: &dyn RedirectModifier<S>,
+    ) -> &mut Self {
         self.forward(target, Some(modifier), true)
     }
 
     pub fn forward(
         &mut self,
-        target: &dyn CommandNode<S, T>,
-        modifier: Option<&dyn RedirectModifier<S, T>>,
+        target: &dyn CommandNode<S>,
+        modifier: Option<&dyn RedirectModifier<S>>,
         fork: bool,
-    ) -> Result<&mut T, String> {
+    ) -> Result<&mut Self, String> {
         if !self.arguments.get_children().is_empty() {
             return Err("Cannot forward a node with children".to_string());
         }
@@ -93,11 +92,11 @@ where
         Ok(self)
     }
 
-    pub fn get_redirect(&self) -> Option<&dyn CommandNode<S, T>> {
+    pub fn get_redirect(&self) -> Option<&dyn CommandNode<S>> {
         self.target.as_ref()
     }
 
-    pub fn get_redirect_modifier(&self) -> Option<&dyn RedirectModifier<S, T>> {
+    pub fn get_redirect_modifier(&self) -> Option<&dyn RedirectModifier<S>> {
         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 a4cb3f84..8039dff0 100644
--- a/azalea-brigadier/src/builder/literal_argument_builder.rs
+++ b/azalea-brigadier/src/builder/literal_argument_builder.rs
@@ -1,23 +1,16 @@
 use crate::{
-    arguments::argument_type::{ArgumentType, Types},
-    tree::literal_command_node::LiteralCommandNode,
+    arguments::argument_type::ArgumentType, tree::literal_command_node::LiteralCommandNode,
 };
 
 use super::argument_builder::BaseArgumentBuilder;
 
-pub struct LiteralArgumentBuilder<'a, S, T>
-where
-    T: ArgumentType<dyn Types>,
-{
+pub struct LiteralArgumentBuilder<'a, S> {
     literal: String,
 
-    pub base: BaseArgumentBuilder<'a, S, T>,
+    pub base: BaseArgumentBuilder<'a, S>,
 }
 
-impl<'a, S, T> LiteralArgumentBuilder<'a, S, T>
-where
-    T: ArgumentType<dyn Types>,
-{
+impl<'a, S> LiteralArgumentBuilder<'a, S> {
     pub fn new(literal: String) -> Self {
         Self {
             literal,
@@ -29,7 +22,7 @@ where
         Self::new(name)
     }
 
-    pub fn build(self) -> LiteralCommandNode<'a, S, T> {
+    pub fn build(self) -> LiteralCommandNode<'a, S> {
         let result = LiteralCommandNode::new(self.literal, self.base);
 
         for argument in self.base.arguments {
diff --git a/azalea-brigadier/src/builder/required_argument_builder.rs b/azalea-brigadier/src/builder/required_argument_builder.rs
index b5f99828..29af7f6f 100644
--- a/azalea-brigadier/src/builder/required_argument_builder.rs
+++ b/azalea-brigadier/src/builder/required_argument_builder.rs
@@ -1,30 +1,25 @@
 use crate::{
-    arguments::argument_type::{ArgumentType, Types},
+    arguments::argument_type::ArgumentType,
     suggestion::suggestion_provider::SuggestionProvider,
     tree::{argument_command_node::ArgumentCommandNode, command_node::BaseCommandNode},
 };
+use std::any::Any;
 
 use super::argument_builder::BaseArgumentBuilder;
 
-pub struct RequiredArgumentBuilder<'a, S, T>
-where
-    T: ArgumentType<dyn Types>,
-{
+pub struct RequiredArgumentBuilder<'a, S> {
     // private final String name;
     // private final ArgumentType<T> type;
     // private SuggestionProvider<S> suggestionsProvider = null;
     name: String,
-    type_: &'a T,
-    suggestions_provider: Option<&'a dyn SuggestionProvider<S, T>>,
+    type_: Box<dyn ArgumentType<Into = dyn Any>>,
+    suggestions_provider: Option<&'a dyn SuggestionProvider<S>>,
 
-    pub base: BaseArgumentBuilder<'a, S, T>,
+    pub base: BaseArgumentBuilder<'a, S>,
 }
 
-impl<'a, S, T> RequiredArgumentBuilder<'a, S, T>
-where
-    T: ArgumentType<dyn Types>,
-{
-    pub fn new(name: String, type_: T) -> Self {
+impl<'a, S> RequiredArgumentBuilder<'a, S> {
+    pub fn new(name: String, type_: dyn ArgumentType<Into = dyn Any>) -> Self {
         Self {
             name,
             type_: &type_,
@@ -33,20 +28,20 @@ where
         }
     }
 
-    pub fn argument(name: String, type_: T) -> Self {
+    pub fn argument(name: String, type_: dyn ArgumentType<Into = dyn Any>) -> Self {
         Self::new(name, type_)
     }
 
-    pub fn suggests(mut self, provider: &dyn SuggestionProvider<S, T>) -> Self {
+    pub fn suggests(mut self, provider: &dyn SuggestionProvider<S>) -> Self {
         self.suggestions_provider = Some(provider);
         self
     }
 
-    pub fn suggestions_provider(&self) -> Option<&dyn SuggestionProvider<S, T>> {
+    pub fn suggestions_provider(&self) -> Option<&dyn SuggestionProvider<S>> {
         self.suggestions_provider.as_ref()
     }
 
-    pub fn get_type(&self) -> &T {
+    pub fn get_type(&self) -> &dyn ArgumentType<Into = dyn Any> {
         self.type_
     }
 
@@ -54,14 +49,14 @@ where
         self.name
     }
 
-    // final ArgumentCommandNode<S, T> result = new ArgumentCommandNode<>(getName(), getType(), getCommand(), getRequirement(), getRedirect(), getRedirectModifier(), isFork(), getSuggestionsProvider());
+    // final ArgumentCommandNode<S> result = new ArgumentCommandNode<>(getName(), getType(), getCommand(), getRequirement(), getRedirect(), getRedirectModifier(), isFork(), getSuggestionsProvider());
 
     // for (final CommandNode<S> argument : getArguments()) {
     // 	result.addChild(argument);
     // }
 
     // return result;
-    pub fn build(self) -> ArgumentCommandNode<'a, S, T> {
+    pub fn build(self) -> ArgumentCommandNode<'a, S> {
         let result = ArgumentCommandNode {
             name: self.name,
             type_: &self.type_,