From a1afbb6031527c1db5831fc8e916bc0ecce633b4 Mon Sep 17 00:00:00 2001
From: mat <github@matdoes.dev>
Date: Sat, 1 Jan 2022 23:55:19 -0600
Subject: start adding packet macros

---
 Cargo.lock | 26 ++++++++++++++++++++++++--
 1 file changed, 24 insertions(+), 2 deletions(-)

(limited to 'Cargo.lock')

diff --git a/Cargo.lock b/Cargo.lock
index c037630d..eca4d4fa 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -118,6 +118,9 @@ dependencies = [
  "azalea-nbt",
  "byteorder",
  "bytes",
+ "num-derive",
+ "num-traits",
+ "packet-macros",
  "serde",
  "serde_json",
  "thiserror",
@@ -172,6 +175,15 @@ version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c4872d67bab6358e59559027aa3b9157c53d9358c51423c17554809a8858e0f8"
 
+[[package]]
+name = "casey"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fabe85130dda9cf267715582ce6cf1ab581c8dfe3cb33f7065fee0f14e3fea14"
+dependencies = [
+ "syn",
+]
+
 [[package]]
 name = "cast"
 version = "0.2.7"
@@ -676,6 +688,16 @@ version = "11.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0ab1bc2a289d34bd04a330323ac98a1b4bc82c9d9fcb1e66b63caa84da26b575"
 
+[[package]]
+name = "packet-macros"
+version = "0.1.0"
+dependencies = [
+ "casey",
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
 [[package]]
 name = "parking_lot"
 version = "0.11.2"
@@ -755,9 +777,9 @@ checksum = "ed0cfbc8191465bed66e1718596ee0b0b35d5ee1f41c5df2189d0fe8bde535ba"
 
 [[package]]
 name = "proc-macro2"
-version = "1.0.32"
+version = "1.0.36"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ba508cc11742c0dc5c1659771673afbab7a0efab23aa17e854cbab0837ed0b43"
+checksum = "c7342d5883fbccae1cc37a2353b09c87c9b0f3afd73f5fb9bba687a1f733b029"
 dependencies = [
  "unicode-xid",
 ]
-- 
cgit v1.2.3


From d959fb2d0cc4d8ad97eae86666876e22b2e50613 Mon Sep 17 00:00:00 2001
From: mat <github@matdoes.dev>
Date: Sun, 9 Jan 2022 00:14:39 -0600
Subject: add string_reader

---
 Cargo.lock                                         |   4 +
 Cargo.toml                                         |   1 +
 .../src/arguments/bool_argument_type.rs            |   8 +
 azalea-brigadier/src/arguments/mod.rs              |   1 +
 azalea-brigadier/src/builder/mod.rs                |   0
 azalea-brigadier/src/context/mod.rs                |   0
 azalea-brigadier/src/exceptions/mod.rs             |   0
 azalea-brigadier/src/immutable_string_reader.rs    |  10 +
 azalea-brigadier/src/lib.rs                        |  18 ++
 azalea-brigadier/src/message.rs                    |   1 +
 azalea-brigadier/src/string_reader.rs              | 277 +++++++++++++++++++++
 azalea-brigadier/src/suggestion/mod.rs             |   0
 azalea-brigadier/src/tree/mod.rs                   |   0
 13 files changed, 320 insertions(+)
 create mode 100644 azalea-brigadier/src/arguments/mod.rs
 create mode 100644 azalea-brigadier/src/builder/mod.rs
 create mode 100644 azalea-brigadier/src/context/mod.rs
 create mode 100644 azalea-brigadier/src/exceptions/mod.rs
 create mode 100644 azalea-brigadier/src/suggestion/mod.rs
 create mode 100644 azalea-brigadier/src/tree/mod.rs

(limited to 'Cargo.lock')

diff --git a/Cargo.lock b/Cargo.lock
index eca4d4fa..67259fef 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -67,6 +67,10 @@ dependencies = [
  "uuid",
 ]
 
+[[package]]
+name = "azalea-brigadier"
+version = "0.1.0"
+
 [[package]]
 name = "azalea-chat"
 version = "0.1.0"
diff --git a/Cargo.toml b/Cargo.toml
index d22c326b..7f958207 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -8,4 +8,5 @@ members = [
   "azalea-core",
   "azalea-auth",
   "azalea-nbt",
+  "azalea-brigadier",
 ]
diff --git a/azalea-brigadier/src/arguments/bool_argument_type.rs b/azalea-brigadier/src/arguments/bool_argument_type.rs
index e69de29b..d4a33517 100644
--- a/azalea-brigadier/src/arguments/bool_argument_type.rs
+++ b/azalea-brigadier/src/arguments/bool_argument_type.rs
@@ -0,0 +1,8 @@
+struct BoolArgumentType {
+	// private static final Collection<String> EXAMPLES = Arrays.asList("true", "false");
+	const EXAMPLES: &'static [&'static str] = &["true", "false"];
+}
+
+impl ArgumentType for BoolArgumentType {
+	
+}
\ No newline at end of file
diff --git a/azalea-brigadier/src/arguments/mod.rs b/azalea-brigadier/src/arguments/mod.rs
new file mode 100644
index 00000000..18d01d88
--- /dev/null
+++ b/azalea-brigadier/src/arguments/mod.rs
@@ -0,0 +1 @@
+mod argument_type;
diff --git a/azalea-brigadier/src/builder/mod.rs b/azalea-brigadier/src/builder/mod.rs
new file mode 100644
index 00000000..e69de29b
diff --git a/azalea-brigadier/src/context/mod.rs b/azalea-brigadier/src/context/mod.rs
new file mode 100644
index 00000000..e69de29b
diff --git a/azalea-brigadier/src/exceptions/mod.rs b/azalea-brigadier/src/exceptions/mod.rs
new file mode 100644
index 00000000..e69de29b
diff --git a/azalea-brigadier/src/immutable_string_reader.rs b/azalea-brigadier/src/immutable_string_reader.rs
index e69de29b..2e067ace 100644
--- a/azalea-brigadier/src/immutable_string_reader.rs
+++ b/azalea-brigadier/src/immutable_string_reader.rs
@@ -0,0 +1,10 @@
+pub trait ImmutableStringReader {
+    fn remaining_length(&self) -> usize;
+    fn total_length(&self) -> usize;
+    fn get_read(&self) -> &str;
+    fn remaining(&self) -> &str;
+    fn can_read_length(&self, length: usize) -> bool;
+    fn can_read(&self) -> bool;
+    fn peek(&self) -> char;
+    fn peek_offset(&self, offset: usize) -> char;
+}
diff --git a/azalea-brigadier/src/lib.rs b/azalea-brigadier/src/lib.rs
index 1b4a90c9..d0966de3 100644
--- a/azalea-brigadier/src/lib.rs
+++ b/azalea-brigadier/src/lib.rs
@@ -1,3 +1,21 @@
+mod ambiguity_consumer;
+mod arguments;
+mod builder;
+mod command;
+mod command_dispatcher;
+mod context;
+mod exceptions;
+mod immutable_string_reader;
+mod literal_message;
+mod message;
+mod parse_results;
+mod redirect_modifier;
+mod result_consumer;
+mod single_redirect_modifier;
+mod string_reader;
+mod suggestion;
+mod tree;
+
 #[cfg(test)]
 mod tests {
     #[test]
diff --git a/azalea-brigadier/src/message.rs b/azalea-brigadier/src/message.rs
index e69de29b..8b137891 100644
--- a/azalea-brigadier/src/message.rs
+++ b/azalea-brigadier/src/message.rs
@@ -0,0 +1 @@
+
diff --git a/azalea-brigadier/src/string_reader.rs b/azalea-brigadier/src/string_reader.rs
index e69de29b..376cc711 100644
--- a/azalea-brigadier/src/string_reader.rs
+++ b/azalea-brigadier/src/string_reader.rs
@@ -0,0 +1,277 @@
+use crate::immutable_string_reader::ImmutableStringReader;
+use std::str::FromStr;
+
+#[derive(Clone)]
+struct StringReader<'a> {
+    pub string: &'a str,
+    pub cursor: usize,
+}
+
+const SYNTAX_ESCAPE: char = '\\';
+const SYNTAX_DOUBLE_QUOTE: char = '"';
+const SYNTAX_SINGLE_QUOTE: char = '\'';
+
+impl<'a> From<&'a str> for &StringReader<'a> {
+    fn from(string: &'a str) -> &StringReader<'a> {
+        &StringReader { string, cursor: 0 }
+    }
+}
+
+impl ImmutableStringReader for StringReader<'_> {
+    fn remaining_length(&self) -> usize {
+        self.string.len() - self.cursor
+    }
+
+    fn total_length(&self) -> usize {
+        self.string.len()
+    }
+
+    fn get_read(&self) -> &str {
+        &self.string[self.cursor..]
+    }
+
+    fn remaining(&self) -> &str {
+        &self.string[self.cursor..]
+    }
+
+    fn can_read_length(&self, length: usize) -> bool {
+        self.cursor + length <= self.string.len()
+    }
+
+    fn can_read(&self) -> bool {
+        self.can_read_length(1)
+    }
+
+    fn peek(&self) -> char {
+        self.string.chars().nth(self.cursor).unwrap()
+    }
+
+    fn peek_offset(&self, offset: usize) -> char {
+        self.string.chars().nth(self.cursor + offset).unwrap()
+    }
+}
+
+impl StringReader<'_> {
+    fn read(&mut self) -> char {
+        let c = self.peek();
+        self.cursor += 1;
+        c
+    }
+
+    fn skip(&mut self) {
+        self.cursor += 1;
+    }
+
+    fn is_allowed_number(c: char) -> bool {
+        c >= '0' && c <= '9' || c == '.' || c == '-'
+    }
+
+    fn is_quoted_string_start(c: char) -> bool {
+        c == SYNTAX_DOUBLE_QUOTE || c == SYNTAX_SINGLE_QUOTE
+    }
+
+    fn skip_whitespace(&mut self) {
+        while self.can_read() && self.peek().is_whitespace() {
+            self.skip();
+        }
+    }
+
+    fn read_int(&self) -> Result<(), CommandSyntaxException> {
+        let start = self.cursor;
+        while self.can_read() && StringReader::<'_>::is_allowed_number(self.peek()) {
+            self.skip();
+        }
+        let number = &self.string[start..self.cursor];
+        if number.is_empty() {
+            return Err(CommandSyntaxException::BUILT_IN_EXCEPTIONS
+                .reader_expected_int()
+                .create_with_context(self));
+        }
+        let result = i32::from_str(number);
+        if result.is_err() {
+            self.cursor = start;
+            return Err(CommandSyntaxException::BUILT_IN_EXCEPTIONS
+                .reader_invalid_int()
+                .create_with_context(self, number));
+        }
+
+        Ok(())
+    }
+
+    fn read_long(&self) -> Result<(), CommandSyntaxException> {
+        let start = self.cursor;
+        while self.can_read() && StringReader::<'_>::is_allowed_number(self.peek()) {
+            self.skip();
+        }
+        let number = &self.string[start..self.cursor];
+        if number.is_empty() {
+            return Err(CommandSyntaxException::BUILT_IN_EXCEPTIONS
+                .reader_expected_long()
+                .create_with_context(self));
+        }
+        let result = i64::from_str(number);
+        if result.is_err() {
+            self.cursor = start;
+            return Err(CommandSyntaxException::BUILT_IN_EXCEPTIONS
+                .reader_invalid_long()
+                .create_with_context(self, number));
+        }
+
+        Ok(())
+    }
+
+    fn read_double(&self) -> Result<(), CommandSyntaxException> {
+        let start = self.cursor;
+        while self.can_read() && StringReader::<'_>::is_allowed_number(self.peek()) {
+            self.skip();
+        }
+        let number = &self.string[start..self.cursor];
+        if number.is_empty() {
+            return Err(CommandSyntaxException::BUILT_IN_EXCEPTIONS
+                .reader_expected_double()
+                .create_with_context(self));
+        }
+        let result = f64::from_str(number);
+        if result.is_err() {
+            self.cursor = start;
+            return Err(CommandSyntaxException::BUILT_IN_EXCEPTIONS
+                .reader_invalid_double()
+                .create_with_context(self, number));
+        }
+
+        Ok(())
+    }
+
+    fn read_float(&self) -> Result<(), CommandSyntaxException> {
+        let start = self.cursor;
+        while self.can_read() && StringReader::<'_>::is_allowed_number(self.peek()) {
+            self.skip();
+        }
+        let number = &self.string[start..self.cursor];
+        if number.is_empty() {
+            return Err(CommandSyntaxException::BUILT_IN_EXCEPTIONS
+                .reader_expected_float()
+                .create_with_context(self));
+        }
+        let result = f32::from_str(number);
+        if result.is_err() {
+            self.cursor = start;
+            return Err(CommandSyntaxException::BUILT_IN_EXCEPTIONS
+                .reader_invalid_float()
+                .create_with_context(self, number));
+        }
+
+        Ok(())
+    }
+
+    fn is_allowed_in_unquoted_string(c: char) -> bool {
+        c >= '0' && c <= '9'
+            || c >= 'A' && c <= 'Z'
+            || c >= 'a' && c <= 'z'
+            || c == '_'
+            || c == '-'
+            || c == '.'
+            || c == '+'
+    }
+
+    fn read_unquoted_string(&self) -> &str {
+        let start = self.cursor;
+        while self.can_read() && StringReader::<'_>::is_allowed_in_unquoted_string(self.peek()) {
+            self.skip();
+        }
+        &self.string[start..self.cursor]
+    }
+
+    fn read_quoted_string(&self) -> Result<&str, CommandSyntaxException> {
+        if !self.can_read() {
+            return "";
+        }
+        let next = self.peek();
+        if !StringReader::<'_>::is_quoted_string_start(next) {
+            return Err(CommandSyntaxException::BUILT_IN_EXCEPTIONS
+                .reader_expected_start_of_quote()
+                .create_with_context(self));
+        }
+        self.skip();
+        self.read_string_until(next)
+    }
+
+    fn read_string_until(&self, terminator: char) -> Result<String, CommandSynatxException> {
+        let result = String::new();
+        let mut escaped = false;
+        while self.can_read() {
+            let c = self.read();
+            if escaped {
+                if c == terminator || c == SYNTAX_ESCAPE {
+                    result.push(c);
+                    escaped = false;
+                } else {
+                    self.cursor -= 1;
+                    return Err(CommandSyntaxException::BUILT_IN_EXCEPTIONS
+                        .reader_invalid_escape()
+                        .create_with_context(self, c));
+                }
+            } else if c == SYNTAX_ESCAPE {
+                escaped = true;
+            } else if c == terminator {
+                return Ok(result);
+            } else {
+                result.push(c);
+            }
+        }
+
+        Err(CommandSyntaxException::BUILT_IN_EXCEPTIONS
+            .reader_expected_end_of_quote()
+            .create_with_context(self))
+    }
+
+    fn read_string(&self) -> Result<String, CommandSyntaxException> {
+        // if (!canRead()) {
+        //     return "";
+        // }
+        // final char next = peek();
+        // if (isQuotedStringStart(next)) {
+        //     skip();
+        //     return readStringUntil(next);
+        // }
+        // return readUnquotedString();
+        if !self.can_read() {
+            return Ok(String::new());
+        }
+        let next = self.peek();
+        if StringReader::<'_>::is_quoted_string_start(next) {
+            self.skip();
+            return self.read_string_until(next);
+        }
+        Ok(self.read_unquoted_string().to_string())
+    }
+
+	fn read_boolean(&self) -> Result<bool, CommandSyntaxException> {
+		let start = self.cursor;
+		let value = self.read_string()?;
+		if value.is_empty() {
+			return Err(CommandSyntaxException::BUILT_IN_EXCEPTIONS
+				.reader_expected_bool()
+				.create_with_context(self));
+		}
+
+		if value == "true" {
+			return Ok(true);
+		} else if value == "false" {
+			return Ok(false);
+		} else {
+			self.cursor = start;
+			return Err(CommandSyntaxException::BUILT_IN_EXCEPTIONS
+				.reader_invalid_bool()
+				.create_with_context(self, value));
+		}
+	}
+
+	fn expect(&self, c: char) -> Result<(), CommandSyntaxException> {
+		if !self.can_read() || self.peek() != c {
+			return Err(CommandSyntaxException::BUILT_IN_EXCEPTIONS
+				.reader_expected_symbol()
+				.create_with_context(self, c));
+		}
+		self.skip();
+	}
diff --git a/azalea-brigadier/src/suggestion/mod.rs b/azalea-brigadier/src/suggestion/mod.rs
new file mode 100644
index 00000000..e69de29b
diff --git a/azalea-brigadier/src/tree/mod.rs b/azalea-brigadier/src/tree/mod.rs
new file mode 100644
index 00000000..e69de29b
-- 
cgit v1.2.3


From 315f2258190b33c63df7797a97178019f5aea02b Mon Sep 17 00:00:00 2001
From: mat <github@matdoes.dev>
Date: Sun, 9 Jan 2022 22:33:45 -0600
Subject: add some more stuff from brigadier

---
 .gitignore                                         |   1 +
 Cargo.lock                                         |   3 +
 azalea-brigadier/Cargo.toml                        |   3 +-
 azalea-brigadier/src/arguments/argument_type.rs    |   4 +-
 .../src/arguments/bool_argument_type.rs            |  25 ++-
 azalea-brigadier/src/arguments/mod.rs              |   6 +
 azalea-brigadier/src/builder/argument_builder.rs   | 106 ++++++++++++
 azalea-brigadier/src/builder/mod.rs                |   3 +
 azalea-brigadier/src/command.rs                    |  10 ++
 azalea-brigadier/src/command_dispatcher.rs         |  23 +++
 azalea-brigadier/src/context/command_context.rs    |  87 ++++++++++
 .../src/context/command_context_builder.rs         | 180 +++++++++++++++++++++
 azalea-brigadier/src/context/parsed_argument.rs    |  24 +++
 .../src/context/parsed_command_node.rs             |  22 +++
 azalea-brigadier/src/context/string_range.rs       |  45 ++++++
 azalea-brigadier/src/context/suggestion_context.rs |   6 +
 azalea-brigadier/src/lib.rs                        |   3 +
 azalea-brigadier/src/redirect_modifier.rs          |   8 +
 azalea-brigadier/src/single_redirect_modifier.rs   |   8 +
 .../src/suggestion/suggestion_provider.rs          |  14 ++
 azalea-brigadier/src/tree/argument_command_node.rs | 118 ++++++++++++++
 azalea-brigadier/src/tree/command_node.rs          |  52 ++++++
 azalea-brigadier/src/tree/literal_command_node.rs  |  96 +++++++++++
 azalea-brigadier/src/tree/mod.rs                   |   4 +
 azalea-brigadier/src/tree/root_command_node.rs     |  61 +++++++
 25 files changed, 902 insertions(+), 10 deletions(-)

(limited to 'Cargo.lock')

diff --git a/.gitignore b/.gitignore
index ea8c4bf7..f97818c7 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1 +1,2 @@
 /target
+/doc
\ No newline at end of file
diff --git a/Cargo.lock b/Cargo.lock
index 67259fef..0eeb6520 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -70,6 +70,9 @@ dependencies = [
 [[package]]
 name = "azalea-brigadier"
 version = "0.1.0"
+dependencies = [
+ "lazy_static",
+]
 
 [[package]]
 name = "azalea-chat"
diff --git a/azalea-brigadier/Cargo.toml b/azalea-brigadier/Cargo.toml
index c617ffb1..3694a4b7 100644
--- a/azalea-brigadier/Cargo.toml
+++ b/azalea-brigadier/Cargo.toml
@@ -1,8 +1,9 @@
 [package]
+edition = "2021"
 name = "azalea-brigadier"
 version = "0.1.0"
-edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
+lazy_static = "^1.4"
diff --git a/azalea-brigadier/src/arguments/argument_type.rs b/azalea-brigadier/src/arguments/argument_type.rs
index 4c48d6bb..34d57285 100644
--- a/azalea-brigadier/src/arguments/argument_type.rs
+++ b/azalea-brigadier/src/arguments/argument_type.rs
@@ -5,7 +5,7 @@ use crate::{
     suggestion::{suggestions::Suggestions, suggestions_builder::SuggestionsBuilder},
 };
 
-pub trait ArgumentType<T> {
+pub trait ArgumentType {
     // T parse(StringReader reader) throws CommandSyntaxException;
 
     // default <S> CompletableFuture<Suggestions> listSuggestions(final CommandContext<S> context, final SuggestionsBuilder builder) {
@@ -16,7 +16,7 @@ pub trait ArgumentType<T> {
     //     return Collections.emptyList();
     // }
 
-    fn parse(reader: &mut StringReader) -> Result<T, CommandSyntaxException>;
+    fn parse<T>(reader: &mut StringReader) -> Result<T, CommandSyntaxException>;
 
     fn list_suggestions<S>(
         context: &CommandContext<S>,
diff --git a/azalea-brigadier/src/arguments/bool_argument_type.rs b/azalea-brigadier/src/arguments/bool_argument_type.rs
index d4a33517..f4c03373 100644
--- a/azalea-brigadier/src/arguments/bool_argument_type.rs
+++ b/azalea-brigadier/src/arguments/bool_argument_type.rs
@@ -1,8 +1,19 @@
-struct BoolArgumentType {
-	// private static final Collection<String> EXAMPLES = Arrays.asList("true", "false");
-	const EXAMPLES: &'static [&'static str] = &["true", "false"];
-}
+use crate::context::command_context::CommandContext;
+
+use super::argument_type::ArgumentType;
+
+struct BoolArgumentType {}
+
+impl ArgumentType for BoolArgumentType {}
 
-impl ArgumentType for BoolArgumentType {
-	
-}
\ No newline at end of file
+impl BoolArgumentType {
+    const EXAMPLES: &'static [&'static str] = &["true", "false"];
+
+    fn bool() -> Self {
+        Self {}
+    }
+
+    fn get_bool<S>(context: CommandContext<S>, name: String) {
+        context.get_argument::<bool>(name)
+    }
+}
diff --git a/azalea-brigadier/src/arguments/mod.rs b/azalea-brigadier/src/arguments/mod.rs
index 50b0f09b..487c5db7 100644
--- a/azalea-brigadier/src/arguments/mod.rs
+++ b/azalea-brigadier/src/arguments/mod.rs
@@ -1 +1,7 @@
 pub mod argument_type;
+pub mod bool_argument_type;
+pub mod double_argument_type;
+pub mod float_argument_type;
+pub mod integer_argument_type;
+pub mod long_argument_type;
+pub mod string_argument_type;
diff --git a/azalea-brigadier/src/builder/argument_builder.rs b/azalea-brigadier/src/builder/argument_builder.rs
index e69de29b..8a64a9e4 100644
--- a/azalea-brigadier/src/builder/argument_builder.rs
+++ b/azalea-brigadier/src/builder/argument_builder.rs
@@ -0,0 +1,106 @@
+use crate::{
+    command::Command,
+    redirect_modifier::RedirectModifier,
+    single_redirect_modifier::SingleRedirectModifier,
+    tree::{command_node::CommandNode, root_command_node::RootCommandNode},
+};
+
+pub struct BaseArgumentBuilder<S, T>
+where
+    T: ArgumentBuilder<S, T>,
+{
+    arguments: RootCommandNode<S>,
+    command: dyn Command<S>,
+    requirement: dyn Fn(&S) -> bool,
+    target: Option<dyn CommandNode<S>>,
+    modifier: Option<dyn RedirectModifier<S>>,
+    forks: bool,
+}
+
+pub trait ArgumentBuilder<S, T> {
+    fn this() -> T;
+    fn build(self) -> dyn CommandNode<S>;
+}
+
+impl<S, T> BaseArgumentBuilder<S, T>
+where
+    T: ArgumentBuilder<S, T>,
+{
+    pub fn then(&mut self, command: dyn CommandNode<S>) -> Result<&mut T, String> {
+        if self.target.is_some() {
+            return Err("Cannot add children to a redirected node".to_string());
+        }
+        self.command = command;
+        Ok(self)
+    }
+
+    pub fn arguments(&self) -> &Vec<dyn CommandNode<S>> {
+        &self.arguments.get_children()
+    }
+
+    pub fn executes(&mut self, command: dyn Command<S>) -> &mut T {
+        self.command = command;
+        self
+    }
+
+    pub fn command(&self) -> dyn Command<S> {
+        self.command
+    }
+
+    pub fn requires(&mut self, requirement: dyn Fn(&S) -> bool) -> &mut T {
+        self.requirement = requirement;
+        self
+    }
+
+    pub fn requirement(&self) -> dyn Fn(&S) -> bool {
+        self.requirement
+    }
+
+    pub fn redirect(&mut self, target: dyn CommandNode<S>) -> &mut T {
+        self.forward(target, None, false)
+    }
+
+    pub fn redirect_modifier(
+        &mut self,
+        target: dyn CommandNode<S>,
+        modifier: dyn SingleRedirectModifier<S>,
+    ) -> &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)
+    }
+
+    pub fn fork(
+        &mut self,
+        target: dyn CommandNode<S>,
+        modifier: dyn RedirectModifier<S>,
+    ) -> &mut T {
+        self.forward(target, Some(modifier), true)
+    }
+
+    pub fn forward(
+        &mut self,
+        target: dyn CommandNode<S>,
+        modifier: Option<dyn RedirectModifier<S>>,
+        fork: bool,
+    ) -> Result<&mut T, String> {
+        if !self.arguments.get_children().is_empty() {
+            return Err("Cannot forward a node with children".to_string());
+        }
+        self.target = Some(target);
+        self.modifier = modifier;
+        self.forks = fork;
+        Ok(self)
+    }
+
+    pub fn redirect(&self) -> Option<&dyn CommandNode<S>> {
+        self.target.as_ref()
+    }
+
+    pub fn redirect_modifier(&self) -> Option<&dyn RedirectModifier<S>> {
+        self.modifier.as_ref()
+    }
+
+    pub fn is_fork(&self) -> bool {
+        self.forks
+    }
+}
diff --git a/azalea-brigadier/src/builder/mod.rs b/azalea-brigadier/src/builder/mod.rs
index e69de29b..26f2f644 100644
--- a/azalea-brigadier/src/builder/mod.rs
+++ b/azalea-brigadier/src/builder/mod.rs
@@ -0,0 +1,3 @@
+pub mod argument_builder;
+pub mod literal_argument_builder;
+pub mod required_argument_builder;
diff --git a/azalea-brigadier/src/command.rs b/azalea-brigadier/src/command.rs
index e69de29b..a76454b7 100644
--- a/azalea-brigadier/src/command.rs
+++ b/azalea-brigadier/src/command.rs
@@ -0,0 +1,10 @@
+use crate::{
+    context::command_context::CommandContext,
+    exceptions::command_syntax_exception::CommandSyntaxException,
+};
+
+pub const SINGLE_SUCCESS: i32 = 1;
+
+pub trait Command<S> {
+    fn run(&self, context: &mut CommandContext<S>) -> Result<i32, CommandSyntaxException>;
+}
diff --git a/azalea-brigadier/src/command_dispatcher.rs b/azalea-brigadier/src/command_dispatcher.rs
index e69de29b..c476a39b 100644
--- a/azalea-brigadier/src/command_dispatcher.rs
+++ b/azalea-brigadier/src/command_dispatcher.rs
@@ -0,0 +1,23 @@
+/// The core command dispatcher, for registering, parsing, and executing commands.
+/// The `S` generic is a custom "source" type, such as a user or originator of a command
+pub struct CommandDispatcher<S> {
+    root: RootCommandNode<S>,
+}
+
+impl<S> CommandDispatcher<S> {
+    /// The string required to separate individual arguments in an input string
+    ///
+    /// See: [`ARGUMENT_SEPARATOR_CHAR`]
+    const ARGUMENT_SEPARATOR: &'static str = " ";
+
+    /// The char required to separate individual arguments in an input string
+    ///
+    /// See: [`ARGUMENT_SEPARATOR`]
+    const ARGUMENT_SEPARATOR_CHAR: char = ' ';
+
+    const USAGE_OPTIONAL_OPEN: &'static str = "[";
+    const USAGE_OPTIONAL_CLOSE: &'static str = "]";
+    const USAGE_REQUIRED_OPEN: &'static str = "(";
+    const USAGE_REQUIRED_CLOSE: &'static str = ")";
+    const USAGE_OR: &'static str = "|";
+}
diff --git a/azalea-brigadier/src/context/command_context.rs b/azalea-brigadier/src/context/command_context.rs
index ddbb447e..c6210a88 100644
--- a/azalea-brigadier/src/context/command_context.rs
+++ b/azalea-brigadier/src/context/command_context.rs
@@ -1,3 +1,90 @@
+use super::{
+    parsed_argument::ParsedArgument, parsed_command_node::ParsedCommandNode,
+    string_range::StringRange,
+};
+use crate::{
+    arguments::argument_type::ArgumentType, command::Command, redirect_modifier::RedirectModifier,
+    tree::command_node::CommandNode,
+};
+use std::collections::HashMap;
+
 pub struct CommandContext<S> {
     source: S,
+    input: String,
+    command: dyn Command<S>,
+    arguments: HashMap<String, ParsedArgument<S, dyn ArgumentType>>,
+    root_node: dyn CommandNode<S>,
+    nodes: Vec<ParsedCommandNode<S>>,
+    range: StringRange,
+    child: Option<CommandContext<S>>,
+    modifier: Option<dyn RedirectModifier<S>>,
+    forks: bool,
+}
+
+impl<S> CommandContext<S> {
+    pub fn clone_for(&self, source: S) -> Self {
+        if self.source == source {
+            return self.clone();
+        }
+        Self {
+            source,
+            input: self.input.clone(),
+            command: self.command.clone(),
+            arguments: self.arguments.clone(),
+            root_node: self.root_node.clone(),
+            nodes: self.nodes.clone(),
+            range: self.range.clone(),
+            child: self.child.clone(),
+            modifier: self.modifier.clone(),
+            forks: self.forks,
+        }
+    }
+
+    fn child(&self) -> &Option<CommandContext<S>> {
+        &self.child
+    }
+
+    fn last_child(&self) -> &CommandContext<S> {
+        let mut result = self;
+        while result.child.is_some() {
+            result = result.child.as_ref().unwrap();
+        }
+        result
+    }
+
+    fn command(&self) -> &dyn Command<S> {
+        &self.command
+    }
+
+    fn source(&self) -> &S {
+        &self.source
+    }
+
+    // public <V> V getArgument(final String name, final Class<V> clazz) {
+    //     final ParsedArgument<S, ?> argument = arguments.get(name);
+
+    //     if (argument == null) {
+    //         throw new IllegalArgumentException("No such argument '" + name + "' exists on this command");
+    //     }
+
+    //     final Object result = argument.getResult();
+    //     if (PRIMITIVE_TO_WRAPPER.getOrDefault(clazz, clazz).isAssignableFrom(result.getClass())) {
+    //         return (V) result;
+    //     } else {
+    //         throw new IllegalArgumentException("Argument '" + name + "' is defined as " + result.getClass().getSimpleName() + ", not " + clazz);
+    //     }
+    // }
+    fn get_argument<V>(&self, name: &str) -> Result<V, String> {
+        let argument = self.arguments.get(name);
+
+        if argument.is_none() {
+            return Err(format!(
+                "No such argument '{}' exists on this command",
+                name
+            ));
+        }
+
+        let result = argument.unwrap().result();
+        Ok(result)
+    }
 }
diff --git a/azalea-brigadier/src/context/command_context_builder.rs b/azalea-brigadier/src/context/command_context_builder.rs
index e69de29b..e74b5b1c 100644
--- a/azalea-brigadier/src/context/command_context_builder.rs
+++ b/azalea-brigadier/src/context/command_context_builder.rs
@@ -0,0 +1,180 @@
+use std::collections::HashMap;
+
+use crate::{
+    arguments::argument_type::ArgumentType, command::Command,
+    command_dispatcher::CommandDispatcher, redirect_modifier::RedirectModifier,
+    tree::command_node::CommandNode,
+};
+
+use super::{
+    command_context::CommandContext, parsed_argument::ParsedArgument,
+    parsed_command_node::ParsedCommandNode, string_range::StringRange,
+    suggestion_context::SuggestionContext,
+};
+
+// public class CommandContextBuilder<S> {
+//     private final Map<String, ParsedArgument<S, ?>> arguments = new LinkedHashMap<>();
+//     private final CommandNode<S> rootNode;
+//     private final List<ParsedCommandNode<S>> nodes = new ArrayList<>();
+//     private final CommandDispatcher<S> dispatcher;
+//     private S source;
+//     private Command<S> command;
+//     private CommandContextBuilder<S> child;
+//     private StringRange range;
+//     private RedirectModifier<S> modifier = null;
+//     private boolean forks;
+
+#[derive(Clone)]
+pub struct CommandContextBuilder<S> {
+    arguments: HashMap<String, ParsedArgument<S, dyn ArgumentType>>,
+    root_node: dyn CommandNode<S>,
+    nodes: Vec<ParsedCommandNode<S>>,
+    dispatcher: CommandDispatcher<S>,
+    source: S,
+    command: Box<dyn Command<S>>,
+    child: Option<CommandContextBuilder<S>>,
+    range: StringRange,
+    modifier: Option<Box<dyn RedirectModifier<S>>>,
+    forks: bool,
+}
+
+// public CommandContextBuilder(final CommandDispatcher<S> dispatcher, final S source, final CommandNode<S> rootNode, final int start) {
+// 	this.rootNode = rootNode;
+// 	this.dispatcher = dispatcher;
+// 	this.source = source;
+// 	this.range = StringRange.at(start);
+// }
+
+impl<S> CommandContextBuilder<S> {
+    pub fn new(
+        dispatcher: CommandDispatcher<S>,
+        source: S,
+        root_node: dyn CommandNode<S>,
+        start: usize,
+    ) -> Self {
+        Self {
+            root_node,
+            dispatcher,
+            source,
+            range: StringRange::at(start),
+            ..Default::default()
+        }
+    }
+
+    pub fn with_source(mut self, source: S) -> Self {
+        self.source = source;
+        self
+    }
+
+    pub fn source(&self) -> &S {
+        &self.source
+    }
+
+    pub fn root_node(&self) -> &dyn CommandNode<S> {
+        &self.root_node
+    }
+
+    pub fn with_argument(
+        mut self,
+        name: String,
+        argument: ParsedArgument<S, dyn ArgumentType>,
+    ) -> Self {
+        self.arguments.insert(name, argument);
+        self
+    }
+
+    pub fn arguments(&self) -> &HashMap<String, ParsedArgument<S, dyn ArgumentType>> {
+        &self.arguments
+    }
+
+    pub fn with_command(mut self, command: Box<dyn Command<S>>) -> Self {
+        self.command = command;
+        self
+    }
+
+    pub fn with_node(mut self, node: dyn CommandNode<S>, range: StringRange) -> Self {
+        self.nodes.push(ParsedCommandNode::new(node, range));
+        self.range = StringRange::encompassing(&self.range, &range);
+        self.modifier = node.redirect_modifier();
+        self.forks = node.is_fork();
+        self
+    }
+
+    pub fn with_child(mut self, child: CommandContextBuilder<S>) -> Self {
+        self.child = Some(child);
+        self
+    }
+
+    pub fn child(&self) -> Option<&CommandContextBuilder<S>> {
+        self.child.as_ref()
+    }
+
+    pub fn last_child(&self) -> Option<&CommandContextBuilder<S>> {
+        let mut result = self;
+        while let Some(child) = result.child() {
+            result = child;
+        }
+        Some(result)
+    }
+
+    pub fn command(&self) -> &dyn Command<S> {
+        &*self.command
+    }
+
+    pub fn nodes(&self) -> &Vec<ParsedCommandNode<S>> {
+        &self.nodes
+    }
+
+    pub fn build(self, input: &str) -> CommandContext<S> {
+        CommandContext {
+            source: self.source,
+            input,
+            arguments: self.arguments,
+            command: self.command,
+            root_node: self.root_node,
+            nodes: self.nodes,
+            range: self.range,
+            child: self.child.map(|child| child.build(input)),
+            modifier: self.modifier,
+            forks: self.forks,
+        }
+    }
+
+    pub fn dispatcher(&self) -> &CommandDispatcher<S> {
+        &self.dispatcher
+    }
+
+    pub fn range(&self) -> &StringRange {
+        &self.range
+    }
+
+    pub fn find_suggestion_context(&self, cursor: i32) -> Result<SuggestionContext<S>, String> {
+        if self.range.start() <= cursor {
+            if self.range.end() < cursor {
+                if let Some(child) = self.child() {
+                    child.find_suggestion_context(cursor);
+                } else if !self.nodes.is_empty() {
+                    let last = self.nodes.last().unwrap();
+                    let end = last.range().end() + 1;
+                    return SuggestionContext::new(last.node(), end);
+                } else {
+                    return SuggestionContext::new(self.root_node, self.range.start());
+                }
+            } else {
+                let prev = self.root_node;
+                for node in &self.nodes {
+                    let node_range = node.range();
+                    if node_range.start() <= cursor && cursor <= node_range.end() {
+                        return SuggestionContext::new(prev, node_range.start());
+                    }
+                    prev = node.node();
+                }
+                if prev.is_none() {
+                    return Err(String::from("Can't find node before cursor"));
+                }
+                return SuggestionContext::new(prev.unwrap(), self.range.start());
+            }
+        }
+        Err(String::from("Can't find node before cursor"))
+    }
+}
diff --git a/azalea-brigadier/src/context/parsed_argument.rs b/azalea-brigadier/src/context/parsed_argument.rs
index e69de29b..5f9c2cdb 100644
--- a/azalea-brigadier/src/context/parsed_argument.rs
+++ b/azalea-brigadier/src/context/parsed_argument.rs
@@ -0,0 +1,24 @@
+use super::string_range::StringRange;
+
+#[derive(PartialEq, Eq, Hash)]
+pub struct ParsedArgument<S, T> {
+    range: StringRange,
+    result: T,
+}
+
+impl<S, T> ParsedArgument<S, T> {
+    fn new(start: usize, end: usize, result: T) -> Self {
+        Self {
+            range: StringRange::between(start, end),
+            result,
+        }
+    }
+
+    fn range(&self) -> &StringRange {
+        &self.range
+    }
+
+    fn result(&self) -> &T {
+        &self.result
+    }
+}
diff --git a/azalea-brigadier/src/context/parsed_command_node.rs b/azalea-brigadier/src/context/parsed_command_node.rs
index e69de29b..98e99959 100644
--- a/azalea-brigadier/src/context/parsed_command_node.rs
+++ b/azalea-brigadier/src/context/parsed_command_node.rs
@@ -0,0 +1,22 @@
+use super::string_range::StringRange;
+use crate::tree::command_node::CommandNode;
+
+#[derive(Hash, PartialEq, Eq, Debug, Clone)]
+pub struct ParsedCommandNode<S> {
+    node: dyn CommandNode<S>,
+    range: StringRange,
+}
+
+impl<S> ParsedCommandNode<S> {
+    fn new(node: dyn CommandNode<S>, range: StringRange) -> Self {
+        Self { node, range }
+    }
+
+    fn node(&self) -> &dyn CommandNode<S> {
+        &self.node
+    }
+
+    fn range(&self) -> &StringRange {
+        &self.range
+    }
+}
diff --git a/azalea-brigadier/src/context/string_range.rs b/azalea-brigadier/src/context/string_range.rs
index e69de29b..d775ab68 100644
--- a/azalea-brigadier/src/context/string_range.rs
+++ b/azalea-brigadier/src/context/string_range.rs
@@ -0,0 +1,45 @@
+use std::cmp;
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct StringRange {
+    start: usize,
+    end: usize,
+}
+
+impl StringRange {
+    pub fn new(start: usize, end: usize) -> Self {
+        Self { start, end }
+    }
+
+    pub fn at(pos: usize) -> Self {
+        Self::new(pos, pos)
+    }
+
+    pub fn between(start: usize, end: usize) -> Self {
+        Self::new(start, end)
+    }
+
+    pub fn encompassing(a: &Self, b: &Self) -> Self {
+        Self::new(cmp::min(a.start, b.start), cmp::max(a.end, b.end))
+    }
+
+    pub fn start(&self) -> usize {
+        self.start
+    }
+
+    pub fn end(&self) -> usize {
+        self.end
+    }
+
+    pub fn get(&self, reader: &str) -> &str {
+        &reader[self.start..self.end]
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.start == self.end
+    }
+
+    pub fn length(&self) -> usize {
+        self.end - self.start
+    }
+}
diff --git a/azalea-brigadier/src/context/suggestion_context.rs b/azalea-brigadier/src/context/suggestion_context.rs
index e69de29b..540a5f23 100644
--- a/azalea-brigadier/src/context/suggestion_context.rs
+++ b/azalea-brigadier/src/context/suggestion_context.rs
@@ -0,0 +1,6 @@
+use crate::tree::command_node::CommandNode;
+
+pub struct SuggestionContext<S> {
+    parent: dyn CommandNode<S>,
+    start_pos: usize,
+}
diff --git a/azalea-brigadier/src/lib.rs b/azalea-brigadier/src/lib.rs
index d0966de3..b2345abb 100644
--- a/azalea-brigadier/src/lib.rs
+++ b/azalea-brigadier/src/lib.rs
@@ -1,3 +1,6 @@
+#[macro_use]
+extern crate lazy_static;
+
 mod ambiguity_consumer;
 mod arguments;
 mod builder;
diff --git a/azalea-brigadier/src/redirect_modifier.rs b/azalea-brigadier/src/redirect_modifier.rs
index e69de29b..cfefd120 100644
--- a/azalea-brigadier/src/redirect_modifier.rs
+++ b/azalea-brigadier/src/redirect_modifier.rs
@@ -0,0 +1,8 @@
+use crate::{
+    context::command_context::CommandContext,
+    exceptions::command_syntax_exception::CommandSyntaxException,
+};
+
+pub trait RedirectModifier<S> {
+    fn apply(&self, context: CommandContext<S>) -> Result<Vec<S>, CommandSyntaxException>;
+}
diff --git a/azalea-brigadier/src/single_redirect_modifier.rs b/azalea-brigadier/src/single_redirect_modifier.rs
index e69de29b..dd63244d 100644
--- a/azalea-brigadier/src/single_redirect_modifier.rs
+++ b/azalea-brigadier/src/single_redirect_modifier.rs
@@ -0,0 +1,8 @@
+use crate::{
+    context::command_context::CommandContext,
+    exceptions::command_syntax_exception::CommandSyntaxException,
+};
+
+pub trait SingleRedirectModifier<S> {
+    fn apply(&self, context: CommandContext<S>) -> Result<S, CommandSyntaxException>;
+}
diff --git a/azalea-brigadier/src/suggestion/suggestion_provider.rs b/azalea-brigadier/src/suggestion/suggestion_provider.rs
index e69de29b..3027d460 100644
--- a/azalea-brigadier/src/suggestion/suggestion_provider.rs
+++ b/azalea-brigadier/src/suggestion/suggestion_provider.rs
@@ -0,0 +1,14 @@
+use crate::{
+    context::command_context::CommandContext,
+    exceptions::command_syntax_exception::CommandSyntaxException,
+};
+
+use super::{suggestions::Suggestions, suggestions_builder::SuggestionsBuilder};
+
+pub trait SuggestionProvider<S> {
+    fn suggestions(
+        &self,
+        context: &CommandContext<S>,
+        builder: &SuggestionsBuilder,
+    ) -> Result<Suggestions, CommandSyntaxException>;
+}
diff --git a/azalea-brigadier/src/tree/argument_command_node.rs b/azalea-brigadier/src/tree/argument_command_node.rs
index e69de29b..df7d3f5c 100644
--- a/azalea-brigadier/src/tree/argument_command_node.rs
+++ b/azalea-brigadier/src/tree/argument_command_node.rs
@@ -0,0 +1,118 @@
+use std::fmt::{Display, Formatter};
+
+use crate::{
+    arguments::argument_type::ArgumentType,
+    context::{
+        command_context::CommandContext, command_context_builder::CommandContextBuilder,
+        parsed_argument::ParsedArgument,
+    },
+    exceptions::command_syntax_exception::CommandSyntaxException,
+    string_reader::StringReader,
+    suggestion::{
+        suggestion_provider::SuggestionProvider, suggestions::Suggestions,
+        suggestions_builder::SuggestionsBuilder,
+    },
+};
+
+use super::command_node::{BaseCommandNode, CommandNode};
+
+const USAGE_ARGUMENT_OPEN: &str = "<";
+const USAGE_ARGUMENT_CLOSE: &str = ">";
+
+#[derive(Hash, PartialEq, Eq, Debug, Clone)]
+pub struct ArgumentCommandNode<S, T> {
+    name: String,
+    type_: dyn ArgumentType,
+    custom_suggestions: dyn SuggestionProvider<S>,
+    // Since Rust doesn't have extending, we put the struct this is extending as the "base" field
+    pub base: BaseCommandNode<S>,
+}
+
+impl<S, T> ArgumentCommandNode<S, T> {
+    fn get_type(&self) -> &dyn ArgumentType {
+        &self.type_
+    }
+
+    fn custom_suggestions(&self) -> &dyn SuggestionProvider<S> {
+        &self.custom_suggestions
+    }
+}
+
+impl<S, T> CommandNode<S> for ArgumentCommandNode<S, T> {
+    fn name(&self) -> &str {
+        &self.name
+    }
+
+    fn parse(
+        &self,
+        reader: StringReader,
+        context_builder: CommandContextBuilder<S>,
+    ) -> Result<(), CommandSyntaxException> {
+        // final int start = reader.getCursor();
+        // final T result = type.parse(reader);
+        // final ParsedArgument<S, T> parsed = new ParsedArgument<>(start, reader.getCursor(), result);
+
+        // contextBuilder.withArgument(name, parsed);
+        // contextBuilder.withNode(this, parsed.getRange());
+
+        let start = reader.get_cursor();
+        let result = self.get_type().parse(reader)?;
+        let parsed = ParsedArgument::new(start, reader.get_cursor(), result);
+
+        context_builder.with_argument(&self.name, parsed);
+        context_builder.with_node(self, parsed.get_range());
+
+        Ok(())
+    }
+
+    fn list_suggestions(
+        &self,
+        context: CommandContext<S>,
+        builder: SuggestionsBuilder,
+    ) -> Result<Suggestions, CommandSyntaxException> {
+        if self.custom_suggestions.is_none() {
+            self.get_type().list_suggestions(context, builder)
+        } else {
+            self.custom_suggestions.get_suggestions(context, builder)
+        }
+    }
+
+    fn is_valid_input(&self, input: &str) -> bool {
+        let reader = StringReader::new(input);
+        let result = self.get_type().parse(reader);
+        if result.is_ok() {
+            return !reader.can_read() || reader.peek() == ' ';
+        } else {
+            return false;
+        }
+    }
+
+    fn usage_text(&self) -> &str {
+        USAGE_ARGUMENT_OPEN + self.name + USAGE_ARGUMENT_CLOSE
+    }
+
+    fn create_builder(&self) -> RequiredArgumentBuilder<S, T> {
+        let builder = RequiredArgumentBuilder::argument(&self.name, &self.type_);
+        builder.requires(self.base.get_requirement());
+        builder.forward(
+            self.base.get_redirect(),
+            self.base.get_redirect_modifier(),
+            self.base.is_fork(),
+        );
+        builder.suggests(self.custom_suggestions());
+        if self.base.get_command() != None {
+            builder.executes(self.base.get_command().unwrap());
+        }
+        builder
+    }
+
+    fn get_examples(&self) -> Vec<String> {
+        self.type_.get_examples()
+    }
+}
+
+impl Display for ArgumentCommandNode<String, String> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "<argument {}: {}>", self.name, self.type_)
+    }
+}
diff --git a/azalea-brigadier/src/tree/command_node.rs b/azalea-brigadier/src/tree/command_node.rs
index e69de29b..286820b9 100644
--- a/azalea-brigadier/src/tree/command_node.rs
+++ b/azalea-brigadier/src/tree/command_node.rs
@@ -0,0 +1,52 @@
+use std::collections::HashMap;
+
+use crate::{
+    builder::argument_builder::ArgumentBuilder,
+    command::Command,
+    context::{command_context::CommandContext, command_context_builder::CommandContextBuilder},
+    exceptions::command_syntax_exception::CommandSyntaxException,
+    redirect_modifier::RedirectModifier,
+    string_reader::StringReader,
+    suggestion::{suggestions::Suggestions, suggestions_builder::SuggestionsBuilder},
+};
+
+use super::{argument_command_node::ArgumentCommandNode, literal_command_node::LiteralCommandNode};
+
+pub struct BaseCommandNode<S> {
+    // private final Map<String, CommandNode<S>> children = new LinkedHashMap<>();
+    // private final Map<String, LiteralCommandNode<S>> literals = new LinkedHashMap<>();
+    // private final Map<String, ArgumentCommandNode<S, ?>> arguments = new LinkedHashMap<>();
+    // private final Predicate<S> requirement;
+    // private final CommandNode<S> redirect;
+    // private final RedirectModifier<S> modifier;
+    // private final boolean forks;
+    // private Command<S> command;
+    children: HashMap<String, dyn CommandNode<S>>,
+    literals: HashMap<String, LiteralCommandNode<S>>,
+    arguments: HashMap<String, ArgumentCommandNode<S, _>>,
+    requirement: Option<dyn Fn(&S) -> bool>,
+    redirect: Option<dyn CommandNode<S>>,
+    modifier: Option<dyn RedirectModifier<S>>,
+    forks: bool,
+    command: Option<dyn Command<S>>,
+}
+
+impl<S> BaseCommandNode<S> {}
+
+pub trait CommandNode<S> {
+    fn name(&self) -> &str;
+    fn usage_text(&self) -> &str;
+    fn parse(
+        &self,
+        reader: StringReader,
+        context_builder: CommandContextBuilder<S>,
+    ) -> Result<(), CommandSyntaxException>;
+    fn list_suggestions(
+        &self,
+        context: CommandContext<S>,
+        builder: SuggestionsBuilder,
+    ) -> Result<Suggestions, CommandSyntaxException>;
+    fn is_valid_input(&self, input: &str) -> bool;
+    fn create_builder<T>(&self) -> dyn ArgumentBuilder<S, T>;
+    fn get_examples(&self) -> Vec<String>;
+}
diff --git a/azalea-brigadier/src/tree/literal_command_node.rs b/azalea-brigadier/src/tree/literal_command_node.rs
index e69de29b..bb0e613c 100644
--- a/azalea-brigadier/src/tree/literal_command_node.rs
+++ b/azalea-brigadier/src/tree/literal_command_node.rs
@@ -0,0 +1,96 @@
+use crate::{
+    context::{command_context::CommandContext, command_context_builder::CommandContextBuilder},
+    exceptions::{
+        builtin_exceptions::BuiltInExceptions, command_syntax_exception::CommandSyntaxException,
+    },
+    string_reader::StringReader,
+    suggestion::{suggestions::Suggestions, suggestions_builder::SuggestionsBuilder},
+};
+
+use super::command_node::{BaseCommandNode, CommandNode};
+
+#[derive(Hash, PartialEq, Eq, Debug, Clone)]
+pub struct LiteralCommandNode<S> {
+    literal: String,
+    literal_lowercase: String,
+    // Since Rust doesn't have extending, we put the struct this is extending as the "base" field
+    pub base: BaseCommandNode<S>,
+}
+
+impl<S> LiteralCommandNode<S> {
+    pub fn literal(&self) -> &String {
+        &self.literal
+    }
+
+    pub fn parse(&self, reader: StringReader) -> i32 {
+        let start = reader.get_cursor();
+        if reader.can_read(self.literal.len()) {
+            let end = start + self.literal.len();
+            if reader.get_string()[start..end].eq(&self.literal) {
+                reader.set_cursor(end);
+                if !reader.can_read() || reader.peek() == ' ' {
+                    return end as i32;
+                } else {
+                    reader.set_cursor(start);
+                }
+            }
+        }
+        -1
+    }
+}
+
+impl<S> CommandNode<S> for LiteralCommandNode<S> {
+    fn name(&self) -> &str {
+        &self.literal
+    }
+
+    fn parse(
+        &self,
+        reader: StringReader,
+        context_builder: CommandContextBuilder<S>,
+    ) -> Result<(), CommandSyntaxException> {
+        let start = reader.get_cursor();
+        let end = self.parse(reader);
+        if end > -1 {
+            return Ok(());
+        }
+
+        Err(BuiltInExceptions::LiteralIncorrect {
+            expected: self.literal(),
+        }
+        .create_with_context(reader))
+    }
+
+    fn list_suggestions(
+        &self,
+        context: CommandContext<S>,
+        builder: SuggestionsBuilder,
+    ) -> Result<Suggestions, CommandSyntaxException> {
+        if self
+            .literal_lowercase
+            .starts_with(&builder.remaining_lowercase())
+        {
+            builder.suggest(self.literal())
+        } else {
+            Suggestions::empty()
+        }
+    }
+
+    fn is_valid_input(&self, input: &str) -> bool {
+        self.parse(StringReader::from(input)) > -1
+    }
+
+    fn usage_text(&self) -> &str {
+        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());
+        if self.command().is_some() {
+            builder.executes(self.command().unwrap());
+        }
+        builder
+    }
+}
diff --git a/azalea-brigadier/src/tree/mod.rs b/azalea-brigadier/src/tree/mod.rs
index e69de29b..3dc22583 100644
--- a/azalea-brigadier/src/tree/mod.rs
+++ b/azalea-brigadier/src/tree/mod.rs
@@ -0,0 +1,4 @@
+pub mod argument_command_node;
+pub mod command_node;
+pub mod literal_command_node;
+pub mod root_command_node;
diff --git a/azalea-brigadier/src/tree/root_command_node.rs b/azalea-brigadier/src/tree/root_command_node.rs
index e69de29b..004ab6a8 100644
--- a/azalea-brigadier/src/tree/root_command_node.rs
+++ b/azalea-brigadier/src/tree/root_command_node.rs
@@ -0,0 +1,61 @@
+use std::fmt::{Display, Formatter};
+
+use crate::{
+    context::{command_context::CommandContext, command_context_builder::CommandContextBuilder},
+    exceptions::{
+        builtin_exceptions::BuiltInExceptions, command_syntax_exception::CommandSyntaxException,
+    },
+    string_reader::StringReader,
+    suggestion::{suggestions::Suggestions, suggestions_builder::SuggestionsBuilder},
+};
+
+use super::command_node::{BaseCommandNode, CommandNode};
+
+#[derive(Hash, PartialEq, Eq, Debug, Clone)]
+pub struct RootCommandNode<S> {
+    // Since Rust doesn't have extending, we put the struct this is extending as the "base" field
+    pub base: BaseCommandNode<S>,
+}
+
+impl<S> CommandNode<S> for RootCommandNode<S> {
+    fn name(&self) -> &str {
+        ""
+    }
+
+    fn parse(
+        &self,
+        reader: StringReader,
+        context_builder: CommandContextBuilder<S>,
+    ) -> Result<(), CommandSyntaxException> {
+    }
+
+    fn list_suggestions(
+        &self,
+        context: CommandContext<S>,
+        builder: SuggestionsBuilder,
+    ) -> Result<Suggestions, CommandSyntaxException> {
+        Suggestions::empty()
+    }
+
+    fn is_valid_input(&self, input: &str) -> bool {
+        false
+    }
+
+    fn usage_text(&self) -> &str {
+        ""
+    }
+
+    fn create_builder(&self) -> () {
+        panic!("Cannot convert root into a builder");
+    }
+
+    fn get_examples(&self) -> Vec<String> {
+        vec![]
+    }
+}
+
+impl Display for RootCommandNode<()> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "<root>")
+    }
+}
-- 
cgit v1.2.3


From 270507736af57aae6801dc9eb3c3132139d0d07b Mon Sep 17 00:00:00 2001
From: Ubuntu <github@matdoes.dev>
Date: Wed, 12 Jan 2022 00:40:43 +0000
Subject: a

---
 Cargo.lock                                         | 28 +++++++
 azalea-brigadier/Cargo.toml                        |  1 +
 azalea-brigadier/README.md                         |  1 +
 azalea-brigadier/src/arguments/argument_type.rs    | 28 +++++--
 .../src/arguments/bool_argument_type.rs            |  1 +
 azalea-brigadier/src/builder/argument_builder.rs   |  8 +-
 .../src/builder/literal_argument_builder.rs        | 15 +++-
 .../src/builder/required_argument_builder.rs       | 11 ++-
 azalea-brigadier/src/command.rs                    |  4 +-
 azalea-brigadier/src/command_dispatcher.rs         | 17 ++++-
 .../src/context/command_context_builder.rs         | 16 +++-
 .../src/context/parsed_command_node.rs             |  9 +++
 azalea-brigadier/src/redirect_modifier.rs          |  5 +-
 .../src/suggestion/integer_suggestion.rs           |  1 +
 azalea-brigadier/src/suggestion/suggestions.rs     | 86 +++++++++++++++++++++-
 .../src/suggestion/suggestions_builder.rs          |  4 +-
 azalea-brigadier/src/tree/argument_command_node.rs | 17 ++++-
 azalea-brigadier/src/tree/command_node.rs          | 59 +++++++++++++--
 azalea-brigadier/src/tree/literal_command_node.rs  | 20 ++++-
 azalea-brigadier/src/tree/root_command_node.rs     | 19 ++++-
 20 files changed, 307 insertions(+), 43 deletions(-)

(limited to 'Cargo.lock')

diff --git a/Cargo.lock b/Cargo.lock
index 0eeb6520..a0ca81fb 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -71,6 +71,7 @@ dependencies = [
 name = "azalea-brigadier"
 version = "0.1.0"
 dependencies = [
+ "dyn-clonable",
  "lazy_static",
 ]
 
@@ -336,6 +337,33 @@ version = "2.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3ee2393c4a91429dffb4bedf19f4d6abf27d8a732c8ce4980305d782e5426d57"
 
+[[package]]
+name = "dyn-clonable"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4e9232f0e607a262ceb9bd5141a3dfb3e4db6994b31989bbfd845878cba59fd4"
+dependencies = [
+ "dyn-clonable-impl",
+ "dyn-clone",
+]
+
+[[package]]
+name = "dyn-clonable-impl"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "558e40ea573c374cf53507fd240b7ee2f5477df7cfebdb97323ec61c719399c5"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "dyn-clone"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ee2626afccd7561a06cf1367e2950c4718ea04565e20fb5029b6c7d8ad09abcf"
+
 [[package]]
 name = "either"
 version = "1.6.1"
diff --git a/azalea-brigadier/Cargo.toml b/azalea-brigadier/Cargo.toml
index 3694a4b7..4e8968d7 100644
--- a/azalea-brigadier/Cargo.toml
+++ b/azalea-brigadier/Cargo.toml
@@ -7,3 +7,4 @@ version = "0.1.0"
 
 [dependencies]
 lazy_static = "^1.4"
+dyn-clonable = "^0.9"
diff --git a/azalea-brigadier/README.md b/azalea-brigadier/README.md
index 92c0d27e..df69b5c0 100644
--- a/azalea-brigadier/README.md
+++ b/azalea-brigadier/README.md
@@ -1,3 +1,4 @@
 # Azalea Brigadier
 
 A Rustier port of Mojang's [Brigadier](https://github.com/Mojang/brigadier) command parsing and dispatching library.
+
diff --git a/azalea-brigadier/src/arguments/argument_type.rs b/azalea-brigadier/src/arguments/argument_type.rs
index 46026735..890cdea0 100644
--- a/azalea-brigadier/src/arguments/argument_type.rs
+++ b/azalea-brigadier/src/arguments/argument_type.rs
@@ -5,11 +5,19 @@ use crate::{
     string_reader::StringReader,
     suggestion::{suggestions::Suggestions, suggestions_builder::SuggestionsBuilder},
 };
+use dyn_clonable::*;
 
-pub trait Types {
+#[clonable]
+// This should be applied to an Enum
+pub trait Types: Clone {
     fn bool(value: bool) -> Self
     where
         Self: Sized;
+
+    /// Get the less specific ArgumentType from this enum
+    fn inner<T>(&self) -> Box<dyn ArgumentType<T>>
+    where
+        Self: Sized;
 }
 
 /*
@@ -25,12 +33,21 @@ enum BrigadierTypes {
 
     Entity(EntityArgumentType)
 }
+
+impl Types for BrigadierTypes {
+    fn inner(&self) -> dyn ArgumentType<dyn Types> {
+        match self {
+            Bool(t) => t,
+            Entity(t) => t
+        }
+    }
+}
 */
 
-pub trait ArgumentType<T>
+#[clonable]
+pub trait ArgumentType<T: ?Sized>: Clone
 where
-    Self: Sized,
-    T: Types + ?Sized,
+    T: Types,
 {
     // T parse(StringReader reader) throws CommandSyntaxException;
 
@@ -42,7 +59,7 @@ where
     //     return Collections.emptyList();
     // }
 
-    fn parse(&self, reader: &mut StringReader) -> Result<T, CommandSyntaxException>;
+    fn parse(&self, reader: &mut StringReader) -> Result<Box<T>, CommandSyntaxException>;
 
     fn list_suggestions<S>(
         &self,
@@ -50,6 +67,7 @@ where
         builder: &mut SuggestionsBuilder,
     ) -> Result<Suggestions, CommandSyntaxException>
     where
+        Self: Sized,
         S: Sized,
         T: Sized;
 
diff --git a/azalea-brigadier/src/arguments/bool_argument_type.rs b/azalea-brigadier/src/arguments/bool_argument_type.rs
index 1237caa0..b04488c1 100644
--- a/azalea-brigadier/src/arguments/bool_argument_type.rs
+++ b/azalea-brigadier/src/arguments/bool_argument_type.rs
@@ -7,6 +7,7 @@ use crate::{
 
 use super::argument_type::{ArgumentType, Types};
 
+#[derive(Clone)]
 pub struct BoolArgumentType {}
 
 impl<T> ArgumentType<T> for BoolArgumentType
diff --git a/azalea-brigadier/src/builder/argument_builder.rs b/azalea-brigadier/src/builder/argument_builder.rs
index bd2a2c15..0360b05a 100644
--- a/azalea-brigadier/src/builder/argument_builder.rs
+++ b/azalea-brigadier/src/builder/argument_builder.rs
@@ -1,4 +1,5 @@
 use crate::{
+    arguments::argument_type::{ArgumentType, Types},
     command::Command,
     redirect_modifier::RedirectModifier,
     single_redirect_modifier::SingleRedirectModifier,
@@ -8,7 +9,7 @@ use crate::{
 pub struct BaseArgumentBuilder<'a, S, T>
 where
     S: Sized,
-    T: Sized,
+    T: Sized + ArgumentType<dyn Types>,
 {
     arguments: RootCommandNode<'a, S, T>,
     command: Option<&'a dyn Command<S, T>>,
@@ -22,7 +23,10 @@ pub trait ArgumentBuilder<S, T> {
     fn build(self) -> dyn CommandNode<S, T>;
 }
 
-impl<S, T> BaseArgumentBuilder<'_, S, T> {
+impl<S, T> BaseArgumentBuilder<'_, S, T>
+where
+    T: ArgumentType<dyn Types>,
+{
     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());
diff --git a/azalea-brigadier/src/builder/literal_argument_builder.rs b/azalea-brigadier/src/builder/literal_argument_builder.rs
index cf9f1ee9..a4cb3f84 100644
--- a/azalea-brigadier/src/builder/literal_argument_builder.rs
+++ b/azalea-brigadier/src/builder/literal_argument_builder.rs
@@ -1,14 +1,23 @@
-use crate::tree::literal_command_node::LiteralCommandNode;
+use crate::{
+    arguments::argument_type::{ArgumentType, Types},
+    tree::literal_command_node::LiteralCommandNode,
+};
 
 use super::argument_builder::BaseArgumentBuilder;
 
-pub struct LiteralArgumentBuilder<'a, S, T> {
+pub struct LiteralArgumentBuilder<'a, S, T>
+where
+    T: ArgumentType<dyn Types>,
+{
     literal: String,
 
     pub base: BaseArgumentBuilder<'a, S, T>,
 }
 
-impl<'a, S, T> LiteralArgumentBuilder<'a, S, T> {
+impl<'a, S, T> LiteralArgumentBuilder<'a, S, T>
+where
+    T: ArgumentType<dyn Types>,
+{
     pub fn new(literal: String) -> Self {
         Self {
             literal,
diff --git a/azalea-brigadier/src/builder/required_argument_builder.rs b/azalea-brigadier/src/builder/required_argument_builder.rs
index 6f6fa8eb..b5f99828 100644
--- a/azalea-brigadier/src/builder/required_argument_builder.rs
+++ b/azalea-brigadier/src/builder/required_argument_builder.rs
@@ -1,11 +1,15 @@
 use crate::{
+    arguments::argument_type::{ArgumentType, Types},
     suggestion::suggestion_provider::SuggestionProvider,
     tree::{argument_command_node::ArgumentCommandNode, command_node::BaseCommandNode},
 };
 
 use super::argument_builder::BaseArgumentBuilder;
 
-pub struct RequiredArgumentBuilder<'a, S, T> {
+pub struct RequiredArgumentBuilder<'a, S, T>
+where
+    T: ArgumentType<dyn Types>,
+{
     // private final String name;
     // private final ArgumentType<T> type;
     // private SuggestionProvider<S> suggestionsProvider = null;
@@ -16,7 +20,10 @@ pub struct RequiredArgumentBuilder<'a, S, T> {
     pub base: BaseArgumentBuilder<'a, S, T>,
 }
 
-impl<'a, S, T> RequiredArgumentBuilder<'a, S, T> {
+impl<'a, S, T> RequiredArgumentBuilder<'a, S, T>
+where
+    T: ArgumentType<dyn Types>,
+{
     pub fn new(name: String, type_: T) -> Self {
         Self {
             name,
diff --git a/azalea-brigadier/src/command.rs b/azalea-brigadier/src/command.rs
index 520c8a52..dcbf3ffd 100644
--- a/azalea-brigadier/src/command.rs
+++ b/azalea-brigadier/src/command.rs
@@ -2,9 +2,11 @@ use crate::{
     context::command_context::CommandContext,
     exceptions::command_syntax_exception::CommandSyntaxException,
 };
+use dyn_clonable::*;
 
 pub const SINGLE_SUCCESS: i32 = 1;
 
-pub trait Command<S, T> {
+#[clonable]
+pub trait Command<S, T>: Clone {
     fn run(&self, context: &mut CommandContext<S, T>) -> Result<i32, CommandSyntaxException>;
 }
diff --git a/azalea-brigadier/src/command_dispatcher.rs b/azalea-brigadier/src/command_dispatcher.rs
index d0351547..f2fc7528 100644
--- a/azalea-brigadier/src/command_dispatcher.rs
+++ b/azalea-brigadier/src/command_dispatcher.rs
@@ -1,13 +1,22 @@
-use crate::tree::root_command_node::RootCommandNode;
+use crate::{
+    arguments::argument_type::{ArgumentType, Types},
+    tree::root_command_node::RootCommandNode,
+};
 
 /// The core command dispatcher, for registering, parsing, and executing commands.
 /// The `S` generic is a custom "source" type, such as a user or originator of a command
-#[derive(Default)]
-pub struct CommandDispatcher<'a, S, T> {
+#[derive(Default, Clone)]
+pub struct CommandDispatcher<'a, S, T>
+where
+    T: ArgumentType<dyn Types>,
+{
     root: RootCommandNode<'a, S, T>,
 }
 
-impl<S, T> CommandDispatcher<'_, S, T> {
+impl<S, T> CommandDispatcher<'_, S, T>
+where
+    T: ArgumentType<dyn Types>,
+{
     /// The string required to separate individual arguments in an input string
     ///
     /// See: [`ARGUMENT_SEPARATOR_CHAR`]
diff --git a/azalea-brigadier/src/context/command_context_builder.rs b/azalea-brigadier/src/context/command_context_builder.rs
index 88e26343..639a97ee 100644
--- a/azalea-brigadier/src/context/command_context_builder.rs
+++ b/azalea-brigadier/src/context/command_context_builder.rs
@@ -1,8 +1,10 @@
 use std::collections::HashMap;
 
 use crate::{
-    arguments::argument_type::ArgumentType, command::Command,
-    command_dispatcher::CommandDispatcher, redirect_modifier::RedirectModifier,
+    arguments::argument_type::{ArgumentType, Types},
+    command::Command,
+    command_dispatcher::CommandDispatcher,
+    redirect_modifier::RedirectModifier,
     tree::command_node::CommandNode,
 };
 
@@ -25,7 +27,10 @@ use super::{
 //     private boolean forks;
 
 #[derive(Clone)]
-pub struct CommandContextBuilder<'a, S, T> {
+pub struct CommandContextBuilder<'a, S, T>
+where
+    T: ArgumentType<dyn Types>,
+{
     arguments: HashMap<String, ParsedArgument<T>>,
     root_node: &'a dyn CommandNode<S, T>,
     nodes: Vec<ParsedCommandNode<S, T>>,
@@ -45,7 +50,10 @@ pub struct CommandContextBuilder<'a, S, T> {
 // 	this.range = StringRange.at(start);
 // }
 
-impl<S, T> CommandContextBuilder<'_, S, T> {
+impl<S, T> CommandContextBuilder<'_, S, T>
+where
+    T: ArgumentType<dyn Types>,
+{
     pub fn new(
         dispatcher: CommandDispatcher<S, T>,
         source: S,
diff --git a/azalea-brigadier/src/context/parsed_command_node.rs b/azalea-brigadier/src/context/parsed_command_node.rs
index 14168a06..c0be355c 100644
--- a/azalea-brigadier/src/context/parsed_command_node.rs
+++ b/azalea-brigadier/src/context/parsed_command_node.rs
@@ -19,3 +19,12 @@ impl<S, T> ParsedCommandNode<S, T> {
         &self.range
     }
 }
+
+impl<S, T> Clone for ParsedCommandNode<S, T> {
+    fn clone_from(&mut self, source: &Self) {
+        Self {
+            node: self.node.clone(),
+            range: self.range.clone(),
+        }
+    }
+}
diff --git a/azalea-brigadier/src/redirect_modifier.rs b/azalea-brigadier/src/redirect_modifier.rs
index fd2e1bf7..fdb0a080 100644
--- a/azalea-brigadier/src/redirect_modifier.rs
+++ b/azalea-brigadier/src/redirect_modifier.rs
@@ -1,8 +1,11 @@
+use dyn_clonable::*;
+
 use crate::{
     context::command_context::CommandContext,
     exceptions::command_syntax_exception::CommandSyntaxException,
 };
 
-pub trait RedirectModifier<S, T> {
+#[clonable]
+pub trait RedirectModifier<S, T>: Clone {
     fn apply(&self, context: CommandContext<S, T>) -> Result<Vec<S>, CommandSyntaxException>;
 }
diff --git a/azalea-brigadier/src/suggestion/integer_suggestion.rs b/azalea-brigadier/src/suggestion/integer_suggestion.rs
index e69de29b..acee2329 100644
--- a/azalea-brigadier/src/suggestion/integer_suggestion.rs
+++ b/azalea-brigadier/src/suggestion/integer_suggestion.rs
@@ -0,0 +1 @@
+pub struct IntegerSuggestion {}
diff --git a/azalea-brigadier/src/suggestion/suggestions.rs b/azalea-brigadier/src/suggestion/suggestions.rs
index 18572d20..778c5de8 100644
--- a/azalea-brigadier/src/suggestion/suggestions.rs
+++ b/azalea-brigadier/src/suggestion/suggestions.rs
@@ -1,8 +1,90 @@
-use std::cmp;
+use std::{cmp, collections::HashSet};
 
 use crate::{context::string_range::StringRange, message::Message};
 
-pub struct Suggestions {}
+use super::suggestion::Suggestion;
+
+#[derive(PartialEq, Eq, Hash, Default)]
+pub struct Suggestions {
+    range: StringRange,
+    suggestions: Vec<Suggestions>,
+}
+
+impl Suggestions {
+    fn range(&self) -> &StringRange {
+        &self.range
+    }
+
+    fn list(&self) -> &Vec<Suggestions> {
+        &self.suggestions
+    }
+
+    fn is_empty(&self) -> bool {
+        self.suggestions.is_empty()
+    }
+
+    fn merge(command: &str, input: &Vec<Suggestions>) {
+        if input.is_empty() {
+            return Self::default();
+        } else if input.len() == 1 {
+            return input.iter().next();
+        }
+        let texts = HashSet::new();
+        for suggestions in input {
+            texts.extend(suggestions.list())
+        }
+        Self::new(command, texts)
+    }
+
+    // public static Suggestions create(final String command, final Collection<Suggestion> suggestions) {
+    //     if (suggestions.isEmpty()) {
+    //         return EMPTY;
+    //     }
+    //     int start = Integer.MAX_VALUE;
+    //     int end = Integer.MIN_VALUE;
+    //     for (final Suggestion suggestion : suggestions) {
+    //         start = Math.min(suggestion.getRange().getStart(), start);
+    //         end = Math.max(suggestion.getRange().getEnd(), end);
+    //     }
+    //     final StringRange range = new StringRange(start, end);
+    //     final Set<Suggestion> texts = new HashSet<>();
+    //     for (final Suggestion suggestion : suggestions) {
+    //         texts.add(suggestion.expand(command, range));
+    //     }
+    //     final List<Suggestion> sorted = new ArrayList<>(texts);
+    //     sorted.sort((a, b) -> a.compareToIgnoreCase(b));
+    //     return new Suggestions(range, sorted);
+    pub fn new(command: String, suggestions: Vec<Suggestion>) -> Self {
+        if suggestions.is_empty() {
+            return Self::default();
+        }
+        let mut start = usize::MAX;
+        let mut end = usize::MIN;
+        for suggestion in suggestions {
+            let start = cmp::min(suggestion.range().start(), start);
+            let end = cmp::max(suggestion.range().end(), end);
+        }
+        let range = StringRange::new(start, end);
+        let texts = HashSet::new();
+        for suggestion in suggestions {
+            texts.insert(suggestion.expand(command, range));
+        }
+        let sorted = texts.sort_by(|a, b| a.compare_ignore_case(b));
+        Suggestions {
+            range,
+            suggestions: sorted,
+        }
+    }
+}
+
+impl Default for Suggestions {
+    fn default() -> Self {
+        Self {
+            range: StringRange::at(0),
+            suggestions: vec![],
+        }
+    }
+}
 
 // #[cfg(test)]
 // mod tests {
diff --git a/azalea-brigadier/src/suggestion/suggestions_builder.rs b/azalea-brigadier/src/suggestion/suggestions_builder.rs
index 7853a3a2..bc8f6f5d 100644
--- a/azalea-brigadier/src/suggestion/suggestions_builder.rs
+++ b/azalea-brigadier/src/suggestion/suggestions_builder.rs
@@ -1,6 +1,8 @@
 use crate::context::string_range::StringRange;
 
-use super::{suggestion::Suggestion, suggestions::Suggestions};
+use super::{
+    integer_suggestion::IntegerSuggestion, suggestion::Suggestion, suggestions::Suggestions,
+};
 
 pub struct SuggestionsBuilder {
     input: String,
diff --git a/azalea-brigadier/src/tree/argument_command_node.rs b/azalea-brigadier/src/tree/argument_command_node.rs
index 647b6c35..3fc1bb50 100644
--- a/azalea-brigadier/src/tree/argument_command_node.rs
+++ b/azalea-brigadier/src/tree/argument_command_node.rs
@@ -21,6 +21,7 @@ use super::command_node::{BaseCommandNode, CommandNode};
 const USAGE_ARGUMENT_OPEN: &str = "<";
 const USAGE_ARGUMENT_CLOSE: &str = ">";
 
+#[derive(Clone)]
 pub struct ArgumentCommandNode<'a, S, T>
 where
     // each argument command node has its own different type
@@ -34,7 +35,10 @@ where
     pub base: BaseCommandNode<'a, S, T>,
 }
 
-impl<S, T> ArgumentCommandNode<'_, S, T> {
+impl<S, T> ArgumentCommandNode<'_, S, T>
+where
+    T: ArgumentType<dyn Types>,
+{
     fn get_type(&self) -> &T {
         &self.type_
     }
@@ -44,7 +48,11 @@ impl<S, T> ArgumentCommandNode<'_, S, T> {
     }
 }
 
-impl<'a, S, T> CommandNode<S, T> for ArgumentCommandNode<'a, S, T> {
+impl<'a, S, T> CommandNode<S, T> for ArgumentCommandNode<'a, S, T>
+where
+    T: ArgumentType<dyn Types> + Clone,
+    S: Clone,
+{
     fn name(&self) -> &str {
         &self.name
     }
@@ -117,7 +125,10 @@ impl<'a, S, T> CommandNode<S, T> for ArgumentCommandNode<'a, S, T> {
     }
 }
 
-impl Display for ArgumentCommandNode<'_, (), (), ()> {
+impl<S, T> Display for ArgumentCommandNode<'_, S, T>
+where
+    T: ArgumentType<dyn Types>,
+{
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         write!(f, "<argument {}: {}>", self.name, self.type_)
     }
diff --git a/azalea-brigadier/src/tree/command_node.rs b/azalea-brigadier/src/tree/command_node.rs
index 8e262f0b..f3be1597 100644
--- a/azalea-brigadier/src/tree/command_node.rs
+++ b/azalea-brigadier/src/tree/command_node.rs
@@ -1,7 +1,6 @@
-use std::collections::HashMap;
-
+use super::{argument_command_node::ArgumentCommandNode, literal_command_node::LiteralCommandNode};
 use crate::{
-    arguments::argument_type::ArgumentType,
+    arguments::argument_type::{ArgumentType, Types},
     builder::argument_builder::ArgumentBuilder,
     command::Command,
     context::{command_context::CommandContext, command_context_builder::CommandContextBuilder},
@@ -10,10 +9,14 @@ use crate::{
     string_reader::StringReader,
     suggestion::{suggestions::Suggestions, suggestions_builder::SuggestionsBuilder},
 };
+use dyn_clonable::*;
+use std::{collections::HashMap, fmt::Debug};
 
-use super::{argument_command_node::ArgumentCommandNode, literal_command_node::LiteralCommandNode};
-
-pub struct BaseCommandNode<'a, S, T> {
+#[derive(Default)]
+pub struct BaseCommandNode<'a, S, T>
+where
+    T: ArgumentType<dyn Types>,
+{
     children: HashMap<String, &'a dyn CommandNode<S, T>>,
     literals: HashMap<String, LiteralCommandNode<'a, S, T>>,
     arguments: HashMap<String, ArgumentCommandNode<'a, S, T>>,
@@ -24,9 +27,49 @@ pub struct BaseCommandNode<'a, S, T> {
     command: Option<&'a dyn Command<S, T>>,
 }
 
-impl<S, T> BaseCommandNode<'_, S, T> {}
+impl<S, T> BaseCommandNode<'_, S, T> where T: ArgumentType<dyn Types> {}
+
+impl<S, T> Clone for BaseCommandNode<'_, S, T>
+where
+    T: ArgumentType<dyn Types>,
+{
+    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, T> Debug for BaseCommandNode<'_, S, T>
+where
+    T: ArgumentType<dyn Types>,
+{
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("BaseCommandNode")
+            .field("children", &self.children)
+            .field("literals", &self.literals)
+            .field("arguments", &self.arguments)
+            .field("requirement", &self.requirement)
+            .field("redirect", &self.redirect)
+            .field("modifier", &self.modifier)
+            .field("forks", &self.forks)
+            .field("command", &self.command)
+            .finish()
+    }
+}
 
-pub trait CommandNode<S, T> {
+#[clonable]
+pub trait CommandNode<S, T>: Clone
+where
+    T: ArgumentType<dyn Types>,
+{
     fn name(&self) -> &str;
     fn usage_text(&self) -> &str;
     fn parse(
diff --git a/azalea-brigadier/src/tree/literal_command_node.rs b/azalea-brigadier/src/tree/literal_command_node.rs
index fe933669..021a3ea6 100644
--- a/azalea-brigadier/src/tree/literal_command_node.rs
+++ b/azalea-brigadier/src/tree/literal_command_node.rs
@@ -1,4 +1,5 @@
 use crate::{
+    arguments::argument_type::{ArgumentType, Types},
     builder::literal_argument_builder::LiteralArgumentBuilder,
     command::Command,
     context::{command_context::CommandContext, command_context_builder::CommandContextBuilder},
@@ -12,15 +13,22 @@ use crate::{
 
 use super::command_node::{BaseCommandNode, CommandNode};
 
-#[derive(Hash, PartialEq, Eq, Debug, Clone)]
-pub struct LiteralCommandNode<'a, S, T> {
+#[derive(Debug, Clone)]
+pub struct LiteralCommandNode<'a, S, T>
+where
+    // each argument command node has its own different type
+    T: ArgumentType<dyn Types>,
+{
     literal: String,
     literal_lowercase: String,
     // Since Rust doesn't have extending, we put the struct this is extending as the "base" field
     pub base: BaseCommandNode<'a, S, T>,
 }
 
-impl<'a, S, T> LiteralCommandNode<'a, S, T> {
+impl<'a, S, T> LiteralCommandNode<'a, S, T>
+where
+    T: ArgumentType<dyn Types>,
+{
     pub fn new(literal: String, base: BaseCommandNode<S, T>) -> Self {
         let literal_lowercase = literal.to_lowercase();
         Self {
@@ -51,7 +59,11 @@ impl<'a, S, T> LiteralCommandNode<'a, S, T> {
     }
 }
 
-impl<S, T> CommandNode<S, T> for LiteralCommandNode<'_, S, T> {
+impl<S, T> CommandNode<S, T> for LiteralCommandNode<'_, S, T>
+where
+    T: ArgumentType<dyn Types> + Clone,
+    S: Clone,
+{
     fn name(&self) -> &str {
         &self.literal
     }
diff --git a/azalea-brigadier/src/tree/root_command_node.rs b/azalea-brigadier/src/tree/root_command_node.rs
index 36787340..ded5fa77 100644
--- a/azalea-brigadier/src/tree/root_command_node.rs
+++ b/azalea-brigadier/src/tree/root_command_node.rs
@@ -1,6 +1,7 @@
 use std::fmt::{Display, Formatter};
 
 use crate::{
+    arguments::argument_type::{ArgumentType, Types},
     context::{command_context::CommandContext, command_context_builder::CommandContextBuilder},
     exceptions::{
         builtin_exceptions::BuiltInExceptions, command_syntax_exception::CommandSyntaxException,
@@ -11,12 +12,21 @@ use crate::{
 
 use super::command_node::{BaseCommandNode, CommandNode};
 
-pub struct RootCommandNode<'a, S, T> {
+#[derive(Clone, Default)]
+pub struct RootCommandNode<'a, S, T>
+where
+    // each argument command node has its own different type
+    T: ArgumentType<dyn Types>,
+{
     // Since Rust doesn't have extending, we put the struct this is extending as the "base" field
     pub base: BaseCommandNode<'a, S, T>,
 }
 
-impl<S, T> CommandNode<S, T> for RootCommandNode<'_, S, T> {
+impl<S, T> CommandNode<S, T> for RootCommandNode<'_, S, T>
+where
+    T: ArgumentType<dyn Types> + Clone,
+    S: Clone,
+{
     fn name(&self) -> &str {
         ""
     }
@@ -53,7 +63,10 @@ impl<S, T> CommandNode<S, T> for RootCommandNode<'_, S, T> {
     }
 }
 
-impl<S, T> Display for RootCommandNode<'_, S, T> {
+impl<S, T> Display for RootCommandNode<'_, S, T>
+where
+    T: ArgumentType<dyn Types>,
+{
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         write!(f, "<root>")
     }
-- 
cgit v1.2.3


From 4ff67d4917ce333232189e86aee09f2d82451fc6 Mon Sep 17 00:00:00 2001
From: mat <github@matdoes.dev>
Date: Thu, 3 Feb 2022 02:16:24 +0000
Subject: a

---
 Cargo.lock                                         | 19 ++++++++
 azalea-brigadier/Cargo.toml                        |  1 +
 .../src/builder/literal_argument_builder.rs        | 17 ++-----
 azalea-brigadier/src/command_dispatcher.rs         |  6 +--
 azalea-brigadier/src/lib.rs                        |  3 ++
 azalea-brigadier/src/tree/argument_command_node.rs | 24 ++++------
 azalea-brigadier/src/tree/command_node.rs          | 56 +++++++---------------
 azalea-brigadier/src/tree/literal_command_node.rs  | 30 ++++++++----
 azalea-brigadier/src/tree/root_command_node.rs     | 19 ++++++--
 9 files changed, 91 insertions(+), 84 deletions(-)

(limited to 'Cargo.lock')

diff --git a/Cargo.lock b/Cargo.lock
index a0ca81fb..d52792ce 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -72,6 +72,7 @@ name = "azalea-brigadier"
 version = "0.1.0"
 dependencies = [
  "dyn-clonable",
+ "enum_dispatch",
  "lazy_static",
 ]
 
@@ -382,6 +383,18 @@ dependencies = [
  "syn",
 ]
 
+[[package]]
+name = "enum_dispatch"
+version = "0.3.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bd53b3fde38a39a06b2e66dc282f3e86191e53bd04cc499929c15742beae3df8"
+dependencies = [
+ "once_cell",
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
 [[package]]
 name = "flate2"
 version = "1.0.22"
@@ -717,6 +730,12 @@ dependencies = [
  "libc",
 ]
 
+[[package]]
+name = "once_cell"
+version = "1.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "da32515d9f6e6e489d7bc9d84c71b060db7247dc035bbe44eac88cf87486d8d5"
+
 [[package]]
 name = "oorandom"
 version = "11.1.3"
diff --git a/azalea-brigadier/Cargo.toml b/azalea-brigadier/Cargo.toml
index 4e8968d7..6dead502 100644
--- a/azalea-brigadier/Cargo.toml
+++ b/azalea-brigadier/Cargo.toml
@@ -8,3 +8,4 @@ version = "0.1.0"
 [dependencies]
 lazy_static = "^1.4"
 dyn-clonable = "^0.9"
+enum_dispatch = "^0.3"
diff --git a/azalea-brigadier/src/builder/literal_argument_builder.rs b/azalea-brigadier/src/builder/literal_argument_builder.rs
index 8250d45d..4a95755c 100644
--- a/azalea-brigadier/src/builder/literal_argument_builder.rs
+++ b/azalea-brigadier/src/builder/literal_argument_builder.rs
@@ -10,11 +10,8 @@ use crate::{
 };
 use std::fmt::Debug;
 
-pub struct LiteralArgumentBuilder<'a, S>
-where
-    ,
-{
-    arguments: RootCommandNode<'a, S>,
+pub struct LiteralArgumentBuilder<S> {
+    arguments: RootCommandNode<S>,
     command: Option<Box<dyn Command<S>>>,
     requirement: Box<dyn Fn(&S) -> bool>,
     target: Option<Box<dyn CommandNodeTrait<S>>>,
@@ -23,10 +20,7 @@ where
     literal: String,
 }
 
-impl<'a, S> LiteralArgumentBuilder<'a, S>
-where
-    ,
-{
+impl<S> LiteralArgumentBuilder<S> {
     pub fn new(literal: String) -> Self {
         Self {
             literal,
@@ -44,10 +38,7 @@ where
     }
 }
 
-impl<'a, S> ArgumentBuilder<S> for LiteralArgumentBuilder<'a, S>
-where
-    ,
-{
+impl<S> ArgumentBuilder<S> for LiteralArgumentBuilder<S> {
     fn build(self) -> Box<dyn CommandNodeTrait<S>> {
         let result = LiteralCommandNode::new(self.literal, self.base.build());
 
diff --git a/azalea-brigadier/src/command_dispatcher.rs b/azalea-brigadier/src/command_dispatcher.rs
index 98288a48..f8ffddff 100644
--- a/azalea-brigadier/src/command_dispatcher.rs
+++ b/azalea-brigadier/src/command_dispatcher.rs
@@ -4,11 +4,11 @@ use std::fmt::Debug;
 /// The core command dispatcher, for registering, parsing, and executing commands.
 /// The `S` generic is a custom "source" type, such as a user or originator of a command
 #[derive(Default, Clone)]
-pub struct CommandDispatcher<'a, S> {
-    root: RootCommandNode<'a, S>,
+pub struct CommandDispatcher<S> {
+    root: RootCommandNode<S>,
 }
 
-impl<S> CommandDispatcher<'_, S> {
+impl<S> CommandDispatcher<S> {
     /// The string required to separate individual arguments in an input string
     ///
     /// See: [`ARGUMENT_SEPARATOR_CHAR`]
diff --git a/azalea-brigadier/src/lib.rs b/azalea-brigadier/src/lib.rs
index b2345abb..a1ac267c 100644
--- a/azalea-brigadier/src/lib.rs
+++ b/azalea-brigadier/src/lib.rs
@@ -1,6 +1,9 @@
 #[macro_use]
 extern crate lazy_static;
 
+#[macro_use]
+extern crate enum_dispatch;
+
 mod ambiguity_consumer;
 mod arguments;
 mod builder;
diff --git a/azalea-brigadier/src/tree/argument_command_node.rs b/azalea-brigadier/src/tree/argument_command_node.rs
index 0997ec17..9d2af14e 100644
--- a/azalea-brigadier/src/tree/argument_command_node.rs
+++ b/azalea-brigadier/src/tree/argument_command_node.rs
@@ -31,18 +31,14 @@ use super::{
 const USAGE_ARGUMENT_OPEN: &str = "<";
 const USAGE_ARGUMENT_CLOSE: &str = ">";
 
-#[derive(Clone, Debug)]
-pub struct ArgumentCommandNode<'a, S> {
+pub struct ArgumentCommandNode<S> {
     name: String,
     type_: Box<dyn ArgumentType<Into = dyn Any>>,
-    custom_suggestions: Option<&'a dyn SuggestionProvider<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>,
+    custom_suggestions: Option<Box<dyn SuggestionProvider<S>>>,
 
     children: HashMap<String, Box<dyn CommandNodeTrait<S>>>,
-    literals: HashMap<String, LiteralCommandNode<'a, S>>,
-    arguments: HashMap<String, ArgumentCommandNode<'a, S>>,
+    literals: HashMap<String, LiteralCommandNode<S>>,
+    arguments: HashMap<String, ArgumentCommandNode<S>>,
     pub requirement: Box<dyn Fn(&S) -> bool>,
     redirect: Option<Box<dyn CommandNodeTrait<S>>>,
     modifier: Option<Box<dyn RedirectModifier<S>>>,
@@ -50,17 +46,17 @@ pub struct ArgumentCommandNode<'a, S> {
     pub command: Option<Box<dyn Command<S>>>,
 }
 
-impl<S> ArgumentCommandNode<'_, S> {
+impl<S> ArgumentCommandNode<S> {
     fn get_type(&self) -> &dyn ArgumentType<Into = dyn Any> {
-        self.type_
+        &*self.type_
     }
 
-    fn custom_suggestions(&self) -> Option<&dyn SuggestionProvider<S>> {
-        self.custom_suggestions
+    fn custom_suggestions(&self) -> &Option<Box<dyn SuggestionProvider<S>>> {
+        &self.custom_suggestions
     }
 }
 
-impl<'a, S> CommandNodeTrait<S> for ArgumentCommandNode<'a, S> {
+impl<S> CommandNodeTrait<S> for ArgumentCommandNode<S> {
     fn name(&self) -> &str {
         &self.name
     }
@@ -173,7 +169,7 @@ impl<'a, S> CommandNodeTrait<S> for ArgumentCommandNode<'a, S> {
     }
 }
 
-impl<S> Display for ArgumentCommandNode<'_, S> {
+impl<S> Display for ArgumentCommandNode<S> {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         write!(f, "<argument {}: {}>", self.name, self.type_)
     }
diff --git a/azalea-brigadier/src/tree/command_node.rs b/azalea-brigadier/src/tree/command_node.rs
index 30907163..207e114e 100644
--- a/azalea-brigadier/src/tree/command_node.rs
+++ b/azalea-brigadier/src/tree/command_node.rs
@@ -15,43 +15,14 @@ use crate::{
 use std::ops::Deref;
 use std::{any::Any, collections::HashMap, fmt::Debug};
 
-enum CommandNodeEnum<'a, S> {
-    Literal(LiteralCommandNode<'a, S>),
-    Argument(ArgumentCommandNode<'a, S>),
-    Root(RootCommandNode<'a, S>),
+#[enum_dispatch(CommandNodeTrait)]
+enum CommandNodeEnum<S> {
+    Literal(LiteralCommandNode<S>),
+    Argument(ArgumentCommandNode<S>),
+    Root(RootCommandNode<S>),
 }
 
-impl<'a, S> Deref for CommandNodeEnum<'a, S> {
-    type Target = dyn CommandNodeTrait<S>;
-
-    fn deref(&self) -> &Self::Target {
-        match self {
-            CommandNodeEnum::Literal(node) => *node as &Self::Target,
-            CommandNodeEnum::Argument(node) => *node as &Self::Target,
-            CommandNodeEnum::Root(node) => *node as &Self::Target,
-        }
-    }
-}
-
-impl<S> From<LiteralCommandNode<'_, S>> for CommandNodeEnum<'_, S> {
-    fn from(node: LiteralCommandNode<'_, S>) -> Self {
-        CommandNodeEnum::Literal(node)
-    }
-}
-
-impl<S> From<ArgumentCommandNode<'_, S>> for CommandNodeEnum<'_, S> {
-    fn from(node: ArgumentCommandNode<'_, S>) -> Self {
-        CommandNodeEnum::Argument(node)
-    }
-}
-
-impl<S> From<RootCommandNode<'_, S>> for CommandNodeEnum<'_, S> {
-    fn from(node: RootCommandNode<'_, S>) -> Self {
-        CommandNodeEnum::Root(node)
-    }
-}
-
-impl<S> CommandNodeEnum<'_, S> {
+impl<S> CommandNodeEnum<S> {
     fn redirect_modifier(&self) -> Option<&dyn RedirectModifier<S>> {
         (*self).modifier.as_ref().map(|modifier| modifier.as_ref())
     }
@@ -92,10 +63,10 @@ impl<S> CommandNodeEnum<'_, S> {
         }
     }
 }
-pub struct BaseCommandNode<'a, S> {
+pub struct BaseCommandNode<S> {
     children: HashMap<String, Box<dyn CommandNodeTrait<S>>>,
-    literals: HashMap<String, LiteralCommandNode<'a, S>>,
-    arguments: HashMap<String, ArgumentCommandNode<'a, S>>,
+    literals: HashMap<String, LiteralCommandNode<S>>,
+    arguments: HashMap<String, ArgumentCommandNode<S>>,
     pub requirement: Box<dyn Fn(&S) -> bool>,
     redirect: Option<Box<dyn CommandNodeTrait<S>>>,
     modifier: Option<Box<dyn RedirectModifier<S>>>,
@@ -118,7 +89,7 @@ pub struct BaseCommandNode<'a, S> {
 //     }
 // }
 
-impl<S> Debug for BaseCommandNode<'_, S> {
+impl<S> Debug for BaseCommandNode<S> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         f.debug_struct("BaseCommandNode")
             .field("children", &self.children)
@@ -133,7 +104,7 @@ impl<S> Debug for BaseCommandNode<'_, S> {
     }
 }
 
-impl<S> Default for BaseCommandNode<'_, S> {
+impl<S> Default for BaseCommandNode<S> {
     fn default() -> Self {
         Self {
             children: HashMap::new(),
@@ -148,6 +119,7 @@ impl<S> Default for BaseCommandNode<'_, S> {
     }
 }
 
+#[enum_dispatch]
 pub trait CommandNodeTrait<S> {
     fn name(&self) -> &str;
     fn usage_text(&self) -> &str;
@@ -164,4 +136,8 @@ pub trait CommandNodeTrait<S> {
     fn is_valid_input(&self, input: &str) -> bool;
     fn create_builder(&self) -> Box<dyn ArgumentBuilder<S>>;
     fn get_examples(&self) -> Vec<String>;
+
+    fn redirect_modifier(&self) -> Option<&dyn RedirectModifier<S>>;
+    fn can_use(&self, source: S) -> bool;
+    fn add_child(&self, node: &Box<dyn CommandNodeTrait<S>>) -> Result<(), String>;
 }
diff --git a/azalea-brigadier/src/tree/literal_command_node.rs b/azalea-brigadier/src/tree/literal_command_node.rs
index 253b6dc5..2db31d97 100644
--- a/azalea-brigadier/src/tree/literal_command_node.rs
+++ b/azalea-brigadier/src/tree/literal_command_node.rs
@@ -3,33 +3,45 @@ use crate::{
     builder::{
         argument_builder::ArgumentBuilder, literal_argument_builder::LiteralArgumentBuilder,
     },
+    command::Command,
     context::{command_context::CommandContext, command_context_builder::CommandContextBuilder},
     exceptions::{
         builtin_exceptions::BuiltInExceptions, command_syntax_exception::CommandSyntaxException,
     },
     immutable_string_reader::ImmutableStringReader,
+    redirect_modifier::RedirectModifier,
     string_reader::StringReader,
     suggestion::{suggestions::Suggestions, suggestions_builder::SuggestionsBuilder},
 };
-use std::fmt::Debug;
+use std::{collections::HashMap, fmt::Debug};
 
-use super::command_node::{BaseCommandNode, CommandNodeTrait};
+use super::{
+    argument_command_node::ArgumentCommandNode,
+    command_node::{BaseCommandNode, CommandNodeTrait},
+};
 
 #[derive(Debug, Clone)]
-pub struct LiteralCommandNode<'a, S> {
+pub struct LiteralCommandNode<S> {
     literal: String,
     literal_lowercase: String,
-    // 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<S>>,
+    arguments: HashMap<String, ArgumentCommandNode<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<'a, S> LiteralCommandNode<'a, S> {
-    pub fn new(literal: String, base: BaseCommandNode<'a, S>) -> Self {
+impl<S> LiteralCommandNode<S> {
+    pub fn new(literal: String) -> Self {
         let literal_lowercase = literal.to_lowercase();
         Self {
             literal,
             literal_lowercase,
-            base,
+            ..Default::default()
         }
     }
 
@@ -54,7 +66,7 @@ impl<'a, S> LiteralCommandNode<'a, S> {
     }
 }
 
-impl<S> CommandNodeTrait<S> for LiteralCommandNode<'_, S> {
+impl<S> CommandNodeTrait<S> for LiteralCommandNode<S> {
     fn name(&self) -> &str {
         &self.literal
     }
diff --git a/azalea-brigadier/src/tree/root_command_node.rs b/azalea-brigadier/src/tree/root_command_node.rs
index 0fcb8d97..6b8bc157 100644
--- a/azalea-brigadier/src/tree/root_command_node.rs
+++ b/azalea-brigadier/src/tree/root_command_node.rs
@@ -6,6 +6,7 @@ use super::{
 use crate::{
     arguments::argument_type::ArgumentType,
     builder::argument_builder::ArgumentBuilder,
+    command::Command,
     context::{command_context::CommandContext, command_context_builder::CommandContextBuilder},
     exceptions::{
         builtin_exceptions::BuiltInExceptions, command_syntax_exception::CommandSyntaxException,
@@ -16,16 +17,24 @@ use crate::{
 };
 use std::{
     any::Any,
+    collections::HashMap,
     fmt::{Debug, Display, Formatter},
 };
 
-#[derive(Clone, Default, Debug)]
-pub struct RootCommandNode<'a, S> {
+#[derive(Default)]
+pub struct RootCommandNode<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<S>>,
+    arguments: HashMap<String, ArgumentCommandNode<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> CommandNodeTrait<S> for RootCommandNode<'_, S> {
+impl<S> CommandNodeTrait<S> for RootCommandNode<S> {
     fn name(&self) -> &str {
         ""
     }
@@ -63,7 +72,7 @@ impl<S> CommandNodeTrait<S> for RootCommandNode<'_, S> {
     }
 }
 
-impl<S> Display for RootCommandNode<'_, S> {
+impl<S> Display for RootCommandNode<S> {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         write!(f, "<root>")
     }
-- 
cgit v1.2.3


From 82ed6baea5c4e0d00f5fc2bbeb45cbb2838a3784 Mon Sep 17 00:00:00 2001
From: mat <github@matdoes.dev>
Date: Sun, 17 Apr 2022 14:03:21 -0500
Subject: Clean up some old stuff

---
 Cargo.lock                   | 50 --------------------------------------------
 azalea-brigadier/Cargo.toml  |  3 ---
 azalea-brigadier/src/main.rs | 38 ---------------------------------
 3 files changed, 91 deletions(-)
 delete mode 100644 azalea-brigadier/src/main.rs

(limited to 'Cargo.lock')

diff --git a/Cargo.lock b/Cargo.lock
index d52792ce..67259fef 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -70,11 +70,6 @@ dependencies = [
 [[package]]
 name = "azalea-brigadier"
 version = "0.1.0"
-dependencies = [
- "dyn-clonable",
- "enum_dispatch",
- "lazy_static",
-]
 
 [[package]]
 name = "azalea-chat"
@@ -338,33 +333,6 @@ version = "2.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3ee2393c4a91429dffb4bedf19f4d6abf27d8a732c8ce4980305d782e5426d57"
 
-[[package]]
-name = "dyn-clonable"
-version = "0.9.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4e9232f0e607a262ceb9bd5141a3dfb3e4db6994b31989bbfd845878cba59fd4"
-dependencies = [
- "dyn-clonable-impl",
- "dyn-clone",
-]
-
-[[package]]
-name = "dyn-clonable-impl"
-version = "0.9.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "558e40ea573c374cf53507fd240b7ee2f5477df7cfebdb97323ec61c719399c5"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
-]
-
-[[package]]
-name = "dyn-clone"
-version = "1.0.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ee2626afccd7561a06cf1367e2950c4718ea04565e20fb5029b6c7d8ad09abcf"
-
 [[package]]
 name = "either"
 version = "1.6.1"
@@ -383,18 +351,6 @@ dependencies = [
  "syn",
 ]
 
-[[package]]
-name = "enum_dispatch"
-version = "0.3.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bd53b3fde38a39a06b2e66dc282f3e86191e53bd04cc499929c15742beae3df8"
-dependencies = [
- "once_cell",
- "proc-macro2",
- "quote",
- "syn",
-]
-
 [[package]]
 name = "flate2"
 version = "1.0.22"
@@ -730,12 +686,6 @@ dependencies = [
  "libc",
 ]
 
-[[package]]
-name = "once_cell"
-version = "1.9.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "da32515d9f6e6e489d7bc9d84c71b060db7247dc035bbe44eac88cf87486d8d5"
-
 [[package]]
 name = "oorandom"
 version = "11.1.3"
diff --git a/azalea-brigadier/Cargo.toml b/azalea-brigadier/Cargo.toml
index 6dead502..a7ebf618 100644
--- a/azalea-brigadier/Cargo.toml
+++ b/azalea-brigadier/Cargo.toml
@@ -6,6 +6,3 @@ version = "0.1.0"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-lazy_static = "^1.4"
-dyn-clonable = "^0.9"
-enum_dispatch = "^0.3"
diff --git a/azalea-brigadier/src/main.rs b/azalea-brigadier/src/main.rs
deleted file mode 100644
index 53f2efa8..00000000
--- a/azalea-brigadier/src/main.rs
+++ /dev/null
@@ -1,38 +0,0 @@
-use std::rc::Rc;
-
-use rust_command_parser::{
-    builder::{literal_argument_builder::literal, required_argument_builder::argument},
-    dispatcher::CommandDispatcher,
-    parsers::integer,
-};
-
-struct CommandSourceStack {
-    player: String,
-}
-
-pub fn main() {
-    let mut dispatcher = CommandDispatcher::<Rc<CommandSourceStack>>::new();
-
-    let source = Rc::new(CommandSourceStack {
-        player: "player".to_string(),
-    });
-
-    dispatcher.register(
-        literal("foo")
-            .then(argument("bar", integer()).executes(|c| {
-                // println!("Bar is {}", get_integer(c, "bar"));
-                2
-            }))
-            .executes(|c| {
-                println!("Called foo with no arguments");
-                1
-            }),
-    );
-
-    let parse = dispatcher.parse("foo 123".to_string().into(), source);
-    println!("{:?}", parse);
-    println!(
-        "{}",
-        CommandDispatcher::<Rc<CommandSourceStack>>::execute(parse).unwrap()
-    );
-}
-- 
cgit v1.2.3


From 751098b636c9aee54b9ca7a465fdaa769f10be4d Mon Sep 17 00:00:00 2001
From: mat <github@matdoes.dev>
Date: Mon, 18 Apr 2022 22:38:53 -0500
Subject: start working on declare commands packet

---
 Cargo.lock                                         |   1 +
 README.md                                          |   6 +-
 azalea-client/src/connect.rs                       |   3 +
 azalea-protocol/Cargo.toml                         |   1 +
 azalea-protocol/src/mc_buf/read.rs                 |   1 -
 .../game/clientbound_declare_commands_packet.rs    | 133 +++++++++++++++------
 azalea-protocol/src/packets/game/mod.rs            |   9 ++
 7 files changed, 113 insertions(+), 41 deletions(-)

(limited to 'Cargo.lock')

diff --git a/Cargo.lock b/Cargo.lock
index 67259fef..8d94c26c 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -117,6 +117,7 @@ dependencies = [
  "async-recursion",
  "async-trait",
  "azalea-auth",
+ "azalea-brigadier",
  "azalea-chat",
  "azalea-core",
  "azalea-nbt",
diff --git a/README.md b/README.md
index 3ae4b307..ed6ed46f 100644
--- a/README.md
+++ b/README.md
@@ -6,8 +6,8 @@ I named this Azalea because it sounds like a cool word and this is a cool librar
 
 ## Goals
 
-- Bypass most anticheats
-- Only support the latest Minecraft version
 - Do everything a vanilla client can do
-- Be fast
 - Be easy to use
+- Bypass most/all anticheats
+- Support the latest Minecraft version
+- Be fast
diff --git a/azalea-client/src/connect.rs b/azalea-client/src/connect.rs
index 7b1da525..bc45a121 100644
--- a/azalea-client/src/connect.rs
+++ b/azalea-client/src/connect.rs
@@ -73,6 +73,9 @@ pub async fn join_server(address: &ServerAddress) -> Result<(), String> {
                 GamePacket::ClientboundChangeDifficultyPacket(p) => {
                     println!("Got difficulty packet {:?}", p);
                 }
+                GamePacket::ClientboundDeclareCommandsPacket(p) => {
+                    println!("Got declare commands packet {:?}", p);
+                }
             },
             Err(e) => {
                 println!("Error: {:?}", e);
diff --git a/azalea-protocol/Cargo.toml b/azalea-protocol/Cargo.toml
index ff3bd9d4..37df8697 100644
--- a/azalea-protocol/Cargo.toml
+++ b/azalea-protocol/Cargo.toml
@@ -10,6 +10,7 @@ async-compression = {version = "^0.3.8", features = ["tokio", "zlib"]}
 async-recursion = "^0.3.2"
 async-trait = "0.1.51"
 azalea-auth = {path = "../azalea-auth"}
+azalea-brigadier = {path = "../azalea-brigadier"}
 azalea-chat = {path = "../azalea-chat"}
 azalea-core = {path = "../azalea-core"}
 azalea-nbt = {path = "../azalea-nbt"}
diff --git a/azalea-protocol/src/mc_buf/read.rs b/azalea-protocol/src/mc_buf/read.rs
index 0fa1d099..20b69238 100644
--- a/azalea-protocol/src/mc_buf/read.rs
+++ b/azalea-protocol/src/mc_buf/read.rs
@@ -2,7 +2,6 @@ use async_trait::async_trait;
 use azalea_core::{
     difficulty::Difficulty, game_type::GameType, resource_location::ResourceLocation,
 };
-use num_traits::FromPrimitive;
 use tokio::io::{AsyncRead, AsyncReadExt};
 
 use super::MAX_STRING_LENGTH;
diff --git a/azalea-protocol/src/packets/game/clientbound_declare_commands_packet.rs b/azalea-protocol/src/packets/game/clientbound_declare_commands_packet.rs
index 1bcf0dd4..1403630d 100644
--- a/azalea-protocol/src/packets/game/clientbound_declare_commands_packet.rs
+++ b/azalea-protocol/src/packets/game/clientbound_declare_commands_packet.rs
@@ -1,37 +1,96 @@
-// use std::hash::Hash;
-
-// use crate::mc_buf::Readable;
-
-// use super::LoginPacket;
-
-// #[derive(Hash, Clone, Debug)]
-// pub struct ClientboundDeclareCommandsPacket {
-//     pub root: RootCommandNode<SharedSuggestionProvider>,
-//     pub public_key: Vec<u8>,
-//     pub nonce: Vec<u8>,
-// }
-
-// impl ClientboundHelloPacket {
-//     pub fn get(self) -> LoginPacket {
-//         LoginPacket::ClientboundHelloPacket(self)
-//     }
-
-//     pub fn write(&self, _buf: &mut Vec<u8>) -> Result<(), std::io::Error> {
-//         panic!("ClientboundHelloPacket::write not implemented")
-//     }
-
-//     pub async fn read<T: tokio::io::AsyncRead + std::marker::Unpin + std::marker::Send>(
-//         buf: &mut T,
-//     ) -> Result<LoginPacket, String> {
-//         let server_id = buf.read_utf_with_len(20).await?;
-//         let public_key = buf.read_byte_array().await?;
-//         let nonce = buf.read_byte_array().await?;
-
-//         Ok(ClientboundHelloPacket {
-//             server_id,
-//             public_key,
-//             nonce,
-//         }
-//         .get())
-//     }
-// }
+use std::hash::Hash;
+
+use async_trait::async_trait;
+use tokio::io::AsyncRead;
+
+use crate::mc_buf::{McBufReadable, Readable};
+
+use super::GamePacket;
+
+#[derive(Hash, Clone, Debug)]
+pub struct ClientboundDeclareCommandsPacket {
+    pub entries: Vec<BrigadierNodeStub>,
+    pub root_index: i32,
+}
+
+impl ClientboundDeclareCommandsPacket {
+    pub fn get(self) -> GamePacket {
+        GamePacket::ClientboundDeclareCommandsPacket(self)
+    }
+
+    pub fn write(&self, _buf: &mut Vec<u8>) -> Result<(), std::io::Error> {
+        panic!("ClientboundDeclareCommandsPacket::write not implemented")
+    }
+
+    pub async fn read<T: tokio::io::AsyncRead + std::marker::Unpin + std::marker::Send>(
+        buf: &mut T,
+    ) -> Result<GamePacket, String> {
+        let node_count = buf.read_varint().await?;
+        println!("node_count: {}", node_count);
+        let mut nodes = Vec::with_capacity(node_count as usize);
+        for _ in 0..node_count {
+            let node = BrigadierNodeStub::read_into(buf).await?;
+            nodes.push(node);
+        }
+        let root_index = buf.read_varint().await?;
+        Ok(GamePacket::ClientboundDeclareCommandsPacket(
+            ClientboundDeclareCommandsPacket {
+                entries: nodes,
+                root_index,
+            },
+        ))
+    }
+}
+
+#[derive(Hash, Debug, Clone)]
+pub struct BrigadierNodeStub {}
+
+// azalea_brigadier::tree::CommandNode
+#[async_trait]
+impl McBufReadable for BrigadierNodeStub {
+    async fn read_into<R>(buf: &mut R) -> Result<Self, String>
+    where
+        R: AsyncRead + std::marker::Unpin + std::marker::Send,
+    {
+        let flags = u8::read_into(buf).await?;
+
+        let node_type = flags & 0x03;
+        let is_executable = flags & 0x04 != 0;
+        let has_redirect = flags & 0x08 != 0;
+        let has_suggestions_type = flags & 0x10 != 0;
+        println!("flags: {}, node_type: {}, is_executable: {}, has_redirect: {}, has_suggestions_type: {}", flags, node_type, is_executable, has_redirect, has_suggestions_type);
+
+        let children = buf.read_int_id_list().await?;
+        println!("children: {:?}", children);
+        let redirect_node = if has_redirect {
+            buf.read_varint().await?
+        } else {
+            0
+        };
+        println!("redirect_node: {}", redirect_node);
+
+        if node_type == 2 {
+            let name = buf.read_utf().await?;
+            println!("name: {}", name);
+
+            let resource_location = if has_suggestions_type {
+                Some(buf.read_resource_location().await?)
+            } else {
+                None
+            };
+            println!(
+                "node_type=2, flags={}, name={}, resource_location={:?}",
+                flags, name, resource_location
+            );
+            return Ok(BrigadierNodeStub {});
+        }
+        if node_type == 1 {
+            let name = buf.read_utf().await?;
+            println!("node_type=1, flags={}, name={}", flags, name);
+            return Ok(BrigadierNodeStub {});
+        }
+        println!("node_type={}, flags={}", node_type, flags);
+        Ok(BrigadierNodeStub {})
+        // return Err("Unknown node type".to_string());
+    }
+}
diff --git a/azalea-protocol/src/packets/game/mod.rs b/azalea-protocol/src/packets/game/mod.rs
index 4efe72fb..1fd47132 100644
--- a/azalea-protocol/src/packets/game/mod.rs
+++ b/azalea-protocol/src/packets/game/mod.rs
@@ -1,5 +1,6 @@
 pub mod clientbound_change_difficulty_packet;
 pub mod clientbound_custom_payload_packet;
+pub mod clientbound_declare_commands_packet;
 pub mod clientbound_login_packet;
 pub mod clientbound_update_view_distance_packet;
 
@@ -22,6 +23,9 @@ where
     ClientboundChangeDifficultyPacket(
         clientbound_change_difficulty_packet::ClientboundChangeDifficultyPacket,
     ),
+    ClientboundDeclareCommandsPacket(
+        clientbound_declare_commands_packet::ClientboundDeclareCommandsPacket,
+    ),
 }
 
 #[async_trait]
@@ -32,6 +36,7 @@ impl ProtocolPacket for GamePacket {
             GamePacket::ClientboundCustomPayloadPacket(_packet) => 0x18,
             GamePacket::ClientboundLoginPacket(_packet) => 0x26,
             GamePacket::ClientboundUpdateViewDistancePacket(_packet) => 0x4a,
+            GamePacket::ClientboundDeclareCommandsPacket(_packet) => 0x12,
         }
     }
 
@@ -41,6 +46,7 @@ impl ProtocolPacket for GamePacket {
             GamePacket::ClientboundCustomPayloadPacket(packet) => packet.write(buf),
             GamePacket::ClientboundLoginPacket(packet) => packet.write(buf),
             GamePacket::ClientboundUpdateViewDistancePacket(packet) => packet.write(buf),
+            GamePacket::ClientboundDeclareCommandsPacket(packet) => packet.write(buf),
         }
     }
 
@@ -63,6 +69,9 @@ impl ProtocolPacket for GamePacket {
                 0x4a => clientbound_update_view_distance_packet::ClientboundUpdateViewDistancePacket
                     ::read(buf)
                     .await?,
+                0x12 => clientbound_declare_commands_packet::ClientboundDeclareCommandsPacket
+                    ::read(buf)
+                    .await?,
                 // _ => return Err(format!("Unknown ServerToClient game packet id: {}", id)),
                 _ => panic!("Unknown ServerToClient game packet id: {}", id),
             },
-- 
cgit v1.2.3


From 248f752748a0033db7f8242ee0ecd73ea8ce8ec9 Mon Sep 17 00:00:00 2001
From: mat <github@matdoes.dev>
Date: Fri, 22 Apr 2022 04:33:58 +0000
Subject: simplify error handling

---
 .gitignore                                         |   0
 .gitpod.yml                                        |   0
 .vscode/settings.json                              |   0
 Cargo.lock                                         |   0
 Cargo.toml                                         |   0
 README.md                                          |   0
 azalea-auth/Cargo.toml                             |   0
 azalea-auth/src/game_profile.rs                    |   0
 azalea-auth/src/lib.rs                             |   0
 azalea-brigadier/Cargo.toml                        |   0
 azalea-brigadier/README.md                         |   0
 azalea-brigadier/src/arguments/argument_type.rs    |   0
 .../src/arguments/integer_argument_type.rs         |   0
 azalea-brigadier/src/arguments/mod.rs              |   0
 azalea-brigadier/src/builder/argument_builder.rs   |   0
 .../src/builder/literal_argument_builder.rs        |   0
 azalea-brigadier/src/builder/mod.rs                |   0
 .../src/builder/required_argument_builder.rs       |   0
 azalea-brigadier/src/command_dispatcher.rs         |   0
 azalea-brigadier/src/context/command_context.rs    |   0
 .../src/context/command_context_builder.rs         |   0
 azalea-brigadier/src/context/mod.rs                |   0
 azalea-brigadier/src/context/parsed_argument.rs    |   0
 .../src/context/parsed_command_node.rs             |   0
 azalea-brigadier/src/context/string_range.rs       |   0
 .../src/exceptions/builtin_exceptions.rs           |   0
 .../src/exceptions/command_syntax_exception.rs     |   0
 azalea-brigadier/src/exceptions/mod.rs             |   0
 azalea-brigadier/src/lib.rs                        |   0
 azalea-brigadier/src/message.rs                    |   0
 azalea-brigadier/src/modifier.rs                   |   0
 azalea-brigadier/src/parse_results.rs              |   0
 azalea-brigadier/src/string_reader.rs              |   0
 azalea-brigadier/src/tree/mod.rs                   |   0
 .../tests/arguments/bool_argument_type_test.rs     |   0
 .../tests/arguments/double_argument_type_test.rs   |   0
 .../tests/arguments/float_argument_type_test.rs    |   0
 .../tests/arguments/integer_argument_type_test.rs  |   0
 .../tests/arguments/long_argument_type_test.rs     |   0
 .../tests/arguments/string_argument_type_test.rs   |   0
 .../tests/builder/argument_builder_test.rs         |   0
 .../tests/builder/literal_argument_builder_test.rs |   0
 .../builder/required_argument_builder_test.rs      |   0
 azalea-brigadier/tests/command_dispatcher_test.rs  |   0
 .../tests/command_dispatcher_usages_test.rs        |   0
 azalea-brigadier/tests/command_suggestions_test.rs |   0
 .../tests/context/command_context_test.rs          |   0
 .../tests/context/parsed_argument_test.rs          |   0
 .../dynamic_command_syntax_exception_type_test.rs  |   0
 .../simple_command_syntax_exception_type_test.rs   |   0
 azalea-brigadier/tests/string_reader_test.rs       |   0
 .../tests/suggestion/suggestion_test.rs            |   0
 .../tests/suggestion/suggestions_builder_test.rs   |   0
 .../tests/suggestion/suggestions_test.rs           |   0
 .../tests/tree/abstract_command_node_test.rs       |   0
 .../tests/tree/argument_command_node_test.rs       |   0
 .../tests/tree/literal_command_node_test.rs        |   0
 .../tests/tree/root_command_node_test.rs           |   0
 azalea-chat/Cargo.toml                             |   0
 azalea-chat/README.md                              |   0
 azalea-chat/src/base_component.rs                  |   0
 azalea-chat/src/component.rs                       |   0
 azalea-chat/src/events.rs                          |   0
 azalea-chat/src/lib.rs                             |   0
 azalea-chat/src/style.rs                           |   0
 azalea-chat/src/text_component.rs                  |   0
 azalea-chat/src/translatable_component.rs          |   0
 azalea-chat/tests/integration_test.rs              |   0
 azalea-client/Cargo.toml                           |   0
 azalea-client/README.md                            |   0
 azalea-client/src/connect.rs                       |   0
 azalea-client/src/crypt.rs                         |   0
 azalea-client/src/lib.rs                           |   0
 azalea-client/src/ping.rs                          |   0
 azalea-core/Cargo.toml                             |   0
 azalea-core/src/difficulty.rs                      |   0
 azalea-core/src/game_type.rs                       |   0
 azalea-core/src/lib.rs                             |   0
 azalea-core/src/resource_location.rs               |   0
 azalea-core/src/serializable_uuid.rs               |   0
 azalea-nbt/Cargo.toml                              |   0
 azalea-nbt/README.md                               |   0
 azalea-nbt/benches/my_benchmark.rs                 |   0
 azalea-nbt/src/decode.rs                           |  34 ++++++++++-----------
 azalea-nbt/src/encode.rs                           |   0
 azalea-nbt/src/error.rs                            |  11 +++++++
 azalea-nbt/src/lib.rs                              |   0
 azalea-nbt/src/tag.rs                              |   0
 azalea-nbt/tests/bigtest.nbt                       | Bin
 azalea-nbt/tests/complex_player.dat                | Bin
 azalea-nbt/tests/hello_world.nbt                   | Bin
 azalea-nbt/tests/inttest.nbt                       | Bin
 azalea-nbt/tests/level.dat                         | Bin
 azalea-nbt/tests/simple_player.dat                 | Bin
 azalea-nbt/tests/stringtest.nbt                    | Bin
 azalea-nbt/tests/tests.rs                          |   0
 azalea-protocol/Cargo.toml                         |   0
 azalea-protocol/README.md                          |   0
 azalea-protocol/packet-macros/Cargo.toml           |   0
 azalea-protocol/packet-macros/src/lib.rs           |   0
 azalea-protocol/src/connect.rs                     |   0
 azalea-protocol/src/lib.rs                         |   0
 azalea-protocol/src/mc_buf/mod.rs                  |   0
 azalea-protocol/src/mc_buf/read.rs                 |   0
 azalea-protocol/src/mc_buf/write.rs                |   0
 .../game/clientbound_change_difficulty_packet.rs   |   0
 .../game/clientbound_custom_payload_packet.rs      |   0
 .../game/clientbound_declare_commands_packet.rs    |   0
 .../src/packets/game/clientbound_login_packet.rs   |   0
 .../game/clientbound_player_abilities_packet.rs    |   0
 .../game/clientbound_set_carried_item_packet.rs    |   0
 .../packets/game/clientbound_update_tags_packet.rs |   0
 .../clientbound_update_view_distance_packet.rs     |   0
 azalea-protocol/src/packets/game/mod.rs            |   0
 .../packets/handshake/client_intention_packet.rs   |   0
 azalea-protocol/src/packets/handshake/mod.rs       |   0
 .../login/clientbound_custom_query_packet.rs       |   0
 .../login/clientbound_game_profile_packet.rs       |   0
 .../src/packets/login/clientbound_hello_packet.rs  |   0
 .../login/clientbound_login_compression_packet.rs  |   0
 azalea-protocol/src/packets/login/mod.rs           |   0
 .../src/packets/login/serverbound_hello_packet.rs  |   0
 azalea-protocol/src/packets/mod.rs                 |   0
 .../status/clientbound_status_response_packet.rs   |   0
 azalea-protocol/src/packets/status/mod.rs          |   0
 .../status/serverbound_status_request_packet.rs    |   0
 azalea-protocol/src/read.rs                        |   0
 azalea-protocol/src/resolver.rs                    |   0
 azalea-protocol/src/write.rs                       |   0
 bot/Cargo.toml                                     |   0
 bot/src/main.rs                                    |   0
 131 files changed, 28 insertions(+), 17 deletions(-)
 mode change 100644 => 100755 .gitignore
 mode change 100644 => 100755 .gitpod.yml
 mode change 100644 => 100755 .vscode/settings.json
 mode change 100644 => 100755 Cargo.lock
 mode change 100644 => 100755 Cargo.toml
 mode change 100644 => 100755 README.md
 mode change 100644 => 100755 azalea-auth/Cargo.toml
 mode change 100644 => 100755 azalea-auth/src/game_profile.rs
 mode change 100644 => 100755 azalea-auth/src/lib.rs
 mode change 100644 => 100755 azalea-brigadier/Cargo.toml
 mode change 100644 => 100755 azalea-brigadier/README.md
 mode change 100644 => 100755 azalea-brigadier/src/arguments/argument_type.rs
 mode change 100644 => 100755 azalea-brigadier/src/arguments/integer_argument_type.rs
 mode change 100644 => 100755 azalea-brigadier/src/arguments/mod.rs
 mode change 100644 => 100755 azalea-brigadier/src/builder/argument_builder.rs
 mode change 100644 => 100755 azalea-brigadier/src/builder/literal_argument_builder.rs
 mode change 100644 => 100755 azalea-brigadier/src/builder/mod.rs
 mode change 100644 => 100755 azalea-brigadier/src/builder/required_argument_builder.rs
 mode change 100644 => 100755 azalea-brigadier/src/command_dispatcher.rs
 mode change 100644 => 100755 azalea-brigadier/src/context/command_context.rs
 mode change 100644 => 100755 azalea-brigadier/src/context/command_context_builder.rs
 mode change 100644 => 100755 azalea-brigadier/src/context/mod.rs
 mode change 100644 => 100755 azalea-brigadier/src/context/parsed_argument.rs
 mode change 100644 => 100755 azalea-brigadier/src/context/parsed_command_node.rs
 mode change 100644 => 100755 azalea-brigadier/src/context/string_range.rs
 mode change 100644 => 100755 azalea-brigadier/src/exceptions/builtin_exceptions.rs
 mode change 100644 => 100755 azalea-brigadier/src/exceptions/command_syntax_exception.rs
 mode change 100644 => 100755 azalea-brigadier/src/exceptions/mod.rs
 mode change 100644 => 100755 azalea-brigadier/src/lib.rs
 mode change 100644 => 100755 azalea-brigadier/src/message.rs
 mode change 100644 => 100755 azalea-brigadier/src/modifier.rs
 mode change 100644 => 100755 azalea-brigadier/src/parse_results.rs
 mode change 100644 => 100755 azalea-brigadier/src/string_reader.rs
 mode change 100644 => 100755 azalea-brigadier/src/tree/mod.rs
 mode change 100644 => 100755 azalea-brigadier/tests/arguments/bool_argument_type_test.rs
 mode change 100644 => 100755 azalea-brigadier/tests/arguments/double_argument_type_test.rs
 mode change 100644 => 100755 azalea-brigadier/tests/arguments/float_argument_type_test.rs
 mode change 100644 => 100755 azalea-brigadier/tests/arguments/integer_argument_type_test.rs
 mode change 100644 => 100755 azalea-brigadier/tests/arguments/long_argument_type_test.rs
 mode change 100644 => 100755 azalea-brigadier/tests/arguments/string_argument_type_test.rs
 mode change 100644 => 100755 azalea-brigadier/tests/builder/argument_builder_test.rs
 mode change 100644 => 100755 azalea-brigadier/tests/builder/literal_argument_builder_test.rs
 mode change 100644 => 100755 azalea-brigadier/tests/builder/required_argument_builder_test.rs
 mode change 100644 => 100755 azalea-brigadier/tests/command_dispatcher_test.rs
 mode change 100644 => 100755 azalea-brigadier/tests/command_dispatcher_usages_test.rs
 mode change 100644 => 100755 azalea-brigadier/tests/command_suggestions_test.rs
 mode change 100644 => 100755 azalea-brigadier/tests/context/command_context_test.rs
 mode change 100644 => 100755 azalea-brigadier/tests/context/parsed_argument_test.rs
 mode change 100644 => 100755 azalea-brigadier/tests/exceptions/dynamic_command_syntax_exception_type_test.rs
 mode change 100644 => 100755 azalea-brigadier/tests/exceptions/simple_command_syntax_exception_type_test.rs
 mode change 100644 => 100755 azalea-brigadier/tests/string_reader_test.rs
 mode change 100644 => 100755 azalea-brigadier/tests/suggestion/suggestion_test.rs
 mode change 100644 => 100755 azalea-brigadier/tests/suggestion/suggestions_builder_test.rs
 mode change 100644 => 100755 azalea-brigadier/tests/suggestion/suggestions_test.rs
 mode change 100644 => 100755 azalea-brigadier/tests/tree/abstract_command_node_test.rs
 mode change 100644 => 100755 azalea-brigadier/tests/tree/argument_command_node_test.rs
 mode change 100644 => 100755 azalea-brigadier/tests/tree/literal_command_node_test.rs
 mode change 100644 => 100755 azalea-brigadier/tests/tree/root_command_node_test.rs
 mode change 100644 => 100755 azalea-chat/Cargo.toml
 mode change 100644 => 100755 azalea-chat/README.md
 mode change 100644 => 100755 azalea-chat/src/base_component.rs
 mode change 100644 => 100755 azalea-chat/src/component.rs
 mode change 100644 => 100755 azalea-chat/src/events.rs
 mode change 100644 => 100755 azalea-chat/src/lib.rs
 mode change 100644 => 100755 azalea-chat/src/style.rs
 mode change 100644 => 100755 azalea-chat/src/text_component.rs
 mode change 100644 => 100755 azalea-chat/src/translatable_component.rs
 mode change 100644 => 100755 azalea-chat/tests/integration_test.rs
 mode change 100644 => 100755 azalea-client/Cargo.toml
 mode change 100644 => 100755 azalea-client/README.md
 mode change 100644 => 100755 azalea-client/src/connect.rs
 mode change 100644 => 100755 azalea-client/src/crypt.rs
 mode change 100644 => 100755 azalea-client/src/lib.rs
 mode change 100644 => 100755 azalea-client/src/ping.rs
 mode change 100644 => 100755 azalea-core/Cargo.toml
 mode change 100644 => 100755 azalea-core/src/difficulty.rs
 mode change 100644 => 100755 azalea-core/src/game_type.rs
 mode change 100644 => 100755 azalea-core/src/lib.rs
 mode change 100644 => 100755 azalea-core/src/resource_location.rs
 mode change 100644 => 100755 azalea-core/src/serializable_uuid.rs
 mode change 100644 => 100755 azalea-nbt/Cargo.toml
 mode change 100644 => 100755 azalea-nbt/README.md
 mode change 100644 => 100755 azalea-nbt/benches/my_benchmark.rs
 mode change 100644 => 100755 azalea-nbt/src/decode.rs
 mode change 100644 => 100755 azalea-nbt/src/encode.rs
 mode change 100644 => 100755 azalea-nbt/src/error.rs
 mode change 100644 => 100755 azalea-nbt/src/lib.rs
 mode change 100644 => 100755 azalea-nbt/src/tag.rs
 mode change 100644 => 100755 azalea-nbt/tests/bigtest.nbt
 mode change 100644 => 100755 azalea-nbt/tests/complex_player.dat
 mode change 100644 => 100755 azalea-nbt/tests/hello_world.nbt
 mode change 100644 => 100755 azalea-nbt/tests/inttest.nbt
 mode change 100644 => 100755 azalea-nbt/tests/level.dat
 mode change 100644 => 100755 azalea-nbt/tests/simple_player.dat
 mode change 100644 => 100755 azalea-nbt/tests/stringtest.nbt
 mode change 100644 => 100755 azalea-nbt/tests/tests.rs
 mode change 100644 => 100755 azalea-protocol/Cargo.toml
 mode change 100644 => 100755 azalea-protocol/README.md
 mode change 100644 => 100755 azalea-protocol/packet-macros/Cargo.toml
 mode change 100644 => 100755 azalea-protocol/packet-macros/src/lib.rs
 mode change 100644 => 100755 azalea-protocol/src/connect.rs
 mode change 100644 => 100755 azalea-protocol/src/lib.rs
 mode change 100644 => 100755 azalea-protocol/src/mc_buf/mod.rs
 mode change 100644 => 100755 azalea-protocol/src/mc_buf/read.rs
 mode change 100644 => 100755 azalea-protocol/src/mc_buf/write.rs
 mode change 100644 => 100755 azalea-protocol/src/packets/game/clientbound_change_difficulty_packet.rs
 mode change 100644 => 100755 azalea-protocol/src/packets/game/clientbound_custom_payload_packet.rs
 mode change 100644 => 100755 azalea-protocol/src/packets/game/clientbound_declare_commands_packet.rs
 mode change 100644 => 100755 azalea-protocol/src/packets/game/clientbound_login_packet.rs
 mode change 100644 => 100755 azalea-protocol/src/packets/game/clientbound_player_abilities_packet.rs
 mode change 100644 => 100755 azalea-protocol/src/packets/game/clientbound_set_carried_item_packet.rs
 mode change 100644 => 100755 azalea-protocol/src/packets/game/clientbound_update_tags_packet.rs
 mode change 100644 => 100755 azalea-protocol/src/packets/game/clientbound_update_view_distance_packet.rs
 mode change 100644 => 100755 azalea-protocol/src/packets/game/mod.rs
 mode change 100644 => 100755 azalea-protocol/src/packets/handshake/client_intention_packet.rs
 mode change 100644 => 100755 azalea-protocol/src/packets/handshake/mod.rs
 mode change 100644 => 100755 azalea-protocol/src/packets/login/clientbound_custom_query_packet.rs
 mode change 100644 => 100755 azalea-protocol/src/packets/login/clientbound_game_profile_packet.rs
 mode change 100644 => 100755 azalea-protocol/src/packets/login/clientbound_hello_packet.rs
 mode change 100644 => 100755 azalea-protocol/src/packets/login/clientbound_login_compression_packet.rs
 mode change 100644 => 100755 azalea-protocol/src/packets/login/mod.rs
 mode change 100644 => 100755 azalea-protocol/src/packets/login/serverbound_hello_packet.rs
 mode change 100644 => 100755 azalea-protocol/src/packets/mod.rs
 mode change 100644 => 100755 azalea-protocol/src/packets/status/clientbound_status_response_packet.rs
 mode change 100644 => 100755 azalea-protocol/src/packets/status/mod.rs
 mode change 100644 => 100755 azalea-protocol/src/packets/status/serverbound_status_request_packet.rs
 mode change 100644 => 100755 azalea-protocol/src/read.rs
 mode change 100644 => 100755 azalea-protocol/src/resolver.rs
 mode change 100644 => 100755 azalea-protocol/src/write.rs
 mode change 100644 => 100755 bot/Cargo.toml
 mode change 100644 => 100755 bot/src/main.rs

(limited to 'Cargo.lock')

diff --git a/.gitignore b/.gitignore
old mode 100644
new mode 100755
diff --git a/.gitpod.yml b/.gitpod.yml
old mode 100644
new mode 100755
diff --git a/.vscode/settings.json b/.vscode/settings.json
old mode 100644
new mode 100755
diff --git a/Cargo.lock b/Cargo.lock
old mode 100644
new mode 100755
diff --git a/Cargo.toml b/Cargo.toml
old mode 100644
new mode 100755
diff --git a/README.md b/README.md
old mode 100644
new mode 100755
diff --git a/azalea-auth/Cargo.toml b/azalea-auth/Cargo.toml
old mode 100644
new mode 100755
diff --git a/azalea-auth/src/game_profile.rs b/azalea-auth/src/game_profile.rs
old mode 100644
new mode 100755
diff --git a/azalea-auth/src/lib.rs b/azalea-auth/src/lib.rs
old mode 100644
new mode 100755
diff --git a/azalea-brigadier/Cargo.toml b/azalea-brigadier/Cargo.toml
old mode 100644
new mode 100755
diff --git a/azalea-brigadier/README.md b/azalea-brigadier/README.md
old mode 100644
new mode 100755
diff --git a/azalea-brigadier/src/arguments/argument_type.rs b/azalea-brigadier/src/arguments/argument_type.rs
old mode 100644
new mode 100755
diff --git a/azalea-brigadier/src/arguments/integer_argument_type.rs b/azalea-brigadier/src/arguments/integer_argument_type.rs
old mode 100644
new mode 100755
diff --git a/azalea-brigadier/src/arguments/mod.rs b/azalea-brigadier/src/arguments/mod.rs
old mode 100644
new mode 100755
diff --git a/azalea-brigadier/src/builder/argument_builder.rs b/azalea-brigadier/src/builder/argument_builder.rs
old mode 100644
new mode 100755
diff --git a/azalea-brigadier/src/builder/literal_argument_builder.rs b/azalea-brigadier/src/builder/literal_argument_builder.rs
old mode 100644
new mode 100755
diff --git a/azalea-brigadier/src/builder/mod.rs b/azalea-brigadier/src/builder/mod.rs
old mode 100644
new mode 100755
diff --git a/azalea-brigadier/src/builder/required_argument_builder.rs b/azalea-brigadier/src/builder/required_argument_builder.rs
old mode 100644
new mode 100755
diff --git a/azalea-brigadier/src/command_dispatcher.rs b/azalea-brigadier/src/command_dispatcher.rs
old mode 100644
new mode 100755
diff --git a/azalea-brigadier/src/context/command_context.rs b/azalea-brigadier/src/context/command_context.rs
old mode 100644
new mode 100755
diff --git a/azalea-brigadier/src/context/command_context_builder.rs b/azalea-brigadier/src/context/command_context_builder.rs
old mode 100644
new mode 100755
diff --git a/azalea-brigadier/src/context/mod.rs b/azalea-brigadier/src/context/mod.rs
old mode 100644
new mode 100755
diff --git a/azalea-brigadier/src/context/parsed_argument.rs b/azalea-brigadier/src/context/parsed_argument.rs
old mode 100644
new mode 100755
diff --git a/azalea-brigadier/src/context/parsed_command_node.rs b/azalea-brigadier/src/context/parsed_command_node.rs
old mode 100644
new mode 100755
diff --git a/azalea-brigadier/src/context/string_range.rs b/azalea-brigadier/src/context/string_range.rs
old mode 100644
new mode 100755
diff --git a/azalea-brigadier/src/exceptions/builtin_exceptions.rs b/azalea-brigadier/src/exceptions/builtin_exceptions.rs
old mode 100644
new mode 100755
diff --git a/azalea-brigadier/src/exceptions/command_syntax_exception.rs b/azalea-brigadier/src/exceptions/command_syntax_exception.rs
old mode 100644
new mode 100755
diff --git a/azalea-brigadier/src/exceptions/mod.rs b/azalea-brigadier/src/exceptions/mod.rs
old mode 100644
new mode 100755
diff --git a/azalea-brigadier/src/lib.rs b/azalea-brigadier/src/lib.rs
old mode 100644
new mode 100755
diff --git a/azalea-brigadier/src/message.rs b/azalea-brigadier/src/message.rs
old mode 100644
new mode 100755
diff --git a/azalea-brigadier/src/modifier.rs b/azalea-brigadier/src/modifier.rs
old mode 100644
new mode 100755
diff --git a/azalea-brigadier/src/parse_results.rs b/azalea-brigadier/src/parse_results.rs
old mode 100644
new mode 100755
diff --git a/azalea-brigadier/src/string_reader.rs b/azalea-brigadier/src/string_reader.rs
old mode 100644
new mode 100755
diff --git a/azalea-brigadier/src/tree/mod.rs b/azalea-brigadier/src/tree/mod.rs
old mode 100644
new mode 100755
diff --git a/azalea-brigadier/tests/arguments/bool_argument_type_test.rs b/azalea-brigadier/tests/arguments/bool_argument_type_test.rs
old mode 100644
new mode 100755
diff --git a/azalea-brigadier/tests/arguments/double_argument_type_test.rs b/azalea-brigadier/tests/arguments/double_argument_type_test.rs
old mode 100644
new mode 100755
diff --git a/azalea-brigadier/tests/arguments/float_argument_type_test.rs b/azalea-brigadier/tests/arguments/float_argument_type_test.rs
old mode 100644
new mode 100755
diff --git a/azalea-brigadier/tests/arguments/integer_argument_type_test.rs b/azalea-brigadier/tests/arguments/integer_argument_type_test.rs
old mode 100644
new mode 100755
diff --git a/azalea-brigadier/tests/arguments/long_argument_type_test.rs b/azalea-brigadier/tests/arguments/long_argument_type_test.rs
old mode 100644
new mode 100755
diff --git a/azalea-brigadier/tests/arguments/string_argument_type_test.rs b/azalea-brigadier/tests/arguments/string_argument_type_test.rs
old mode 100644
new mode 100755
diff --git a/azalea-brigadier/tests/builder/argument_builder_test.rs b/azalea-brigadier/tests/builder/argument_builder_test.rs
old mode 100644
new mode 100755
diff --git a/azalea-brigadier/tests/builder/literal_argument_builder_test.rs b/azalea-brigadier/tests/builder/literal_argument_builder_test.rs
old mode 100644
new mode 100755
diff --git a/azalea-brigadier/tests/builder/required_argument_builder_test.rs b/azalea-brigadier/tests/builder/required_argument_builder_test.rs
old mode 100644
new mode 100755
diff --git a/azalea-brigadier/tests/command_dispatcher_test.rs b/azalea-brigadier/tests/command_dispatcher_test.rs
old mode 100644
new mode 100755
diff --git a/azalea-brigadier/tests/command_dispatcher_usages_test.rs b/azalea-brigadier/tests/command_dispatcher_usages_test.rs
old mode 100644
new mode 100755
diff --git a/azalea-brigadier/tests/command_suggestions_test.rs b/azalea-brigadier/tests/command_suggestions_test.rs
old mode 100644
new mode 100755
diff --git a/azalea-brigadier/tests/context/command_context_test.rs b/azalea-brigadier/tests/context/command_context_test.rs
old mode 100644
new mode 100755
diff --git a/azalea-brigadier/tests/context/parsed_argument_test.rs b/azalea-brigadier/tests/context/parsed_argument_test.rs
old mode 100644
new mode 100755
diff --git a/azalea-brigadier/tests/exceptions/dynamic_command_syntax_exception_type_test.rs b/azalea-brigadier/tests/exceptions/dynamic_command_syntax_exception_type_test.rs
old mode 100644
new mode 100755
diff --git a/azalea-brigadier/tests/exceptions/simple_command_syntax_exception_type_test.rs b/azalea-brigadier/tests/exceptions/simple_command_syntax_exception_type_test.rs
old mode 100644
new mode 100755
diff --git a/azalea-brigadier/tests/string_reader_test.rs b/azalea-brigadier/tests/string_reader_test.rs
old mode 100644
new mode 100755
diff --git a/azalea-brigadier/tests/suggestion/suggestion_test.rs b/azalea-brigadier/tests/suggestion/suggestion_test.rs
old mode 100644
new mode 100755
diff --git a/azalea-brigadier/tests/suggestion/suggestions_builder_test.rs b/azalea-brigadier/tests/suggestion/suggestions_builder_test.rs
old mode 100644
new mode 100755
diff --git a/azalea-brigadier/tests/suggestion/suggestions_test.rs b/azalea-brigadier/tests/suggestion/suggestions_test.rs
old mode 100644
new mode 100755
diff --git a/azalea-brigadier/tests/tree/abstract_command_node_test.rs b/azalea-brigadier/tests/tree/abstract_command_node_test.rs
old mode 100644
new mode 100755
diff --git a/azalea-brigadier/tests/tree/argument_command_node_test.rs b/azalea-brigadier/tests/tree/argument_command_node_test.rs
old mode 100644
new mode 100755
diff --git a/azalea-brigadier/tests/tree/literal_command_node_test.rs b/azalea-brigadier/tests/tree/literal_command_node_test.rs
old mode 100644
new mode 100755
diff --git a/azalea-brigadier/tests/tree/root_command_node_test.rs b/azalea-brigadier/tests/tree/root_command_node_test.rs
old mode 100644
new mode 100755
diff --git a/azalea-chat/Cargo.toml b/azalea-chat/Cargo.toml
old mode 100644
new mode 100755
diff --git a/azalea-chat/README.md b/azalea-chat/README.md
old mode 100644
new mode 100755
diff --git a/azalea-chat/src/base_component.rs b/azalea-chat/src/base_component.rs
old mode 100644
new mode 100755
diff --git a/azalea-chat/src/component.rs b/azalea-chat/src/component.rs
old mode 100644
new mode 100755
diff --git a/azalea-chat/src/events.rs b/azalea-chat/src/events.rs
old mode 100644
new mode 100755
diff --git a/azalea-chat/src/lib.rs b/azalea-chat/src/lib.rs
old mode 100644
new mode 100755
diff --git a/azalea-chat/src/style.rs b/azalea-chat/src/style.rs
old mode 100644
new mode 100755
diff --git a/azalea-chat/src/text_component.rs b/azalea-chat/src/text_component.rs
old mode 100644
new mode 100755
diff --git a/azalea-chat/src/translatable_component.rs b/azalea-chat/src/translatable_component.rs
old mode 100644
new mode 100755
diff --git a/azalea-chat/tests/integration_test.rs b/azalea-chat/tests/integration_test.rs
old mode 100644
new mode 100755
diff --git a/azalea-client/Cargo.toml b/azalea-client/Cargo.toml
old mode 100644
new mode 100755
diff --git a/azalea-client/README.md b/azalea-client/README.md
old mode 100644
new mode 100755
diff --git a/azalea-client/src/connect.rs b/azalea-client/src/connect.rs
old mode 100644
new mode 100755
diff --git a/azalea-client/src/crypt.rs b/azalea-client/src/crypt.rs
old mode 100644
new mode 100755
diff --git a/azalea-client/src/lib.rs b/azalea-client/src/lib.rs
old mode 100644
new mode 100755
diff --git a/azalea-client/src/ping.rs b/azalea-client/src/ping.rs
old mode 100644
new mode 100755
diff --git a/azalea-core/Cargo.toml b/azalea-core/Cargo.toml
old mode 100644
new mode 100755
diff --git a/azalea-core/src/difficulty.rs b/azalea-core/src/difficulty.rs
old mode 100644
new mode 100755
diff --git a/azalea-core/src/game_type.rs b/azalea-core/src/game_type.rs
old mode 100644
new mode 100755
diff --git a/azalea-core/src/lib.rs b/azalea-core/src/lib.rs
old mode 100644
new mode 100755
diff --git a/azalea-core/src/resource_location.rs b/azalea-core/src/resource_location.rs
old mode 100644
new mode 100755
diff --git a/azalea-core/src/serializable_uuid.rs b/azalea-core/src/serializable_uuid.rs
old mode 100644
new mode 100755
diff --git a/azalea-nbt/Cargo.toml b/azalea-nbt/Cargo.toml
old mode 100644
new mode 100755
diff --git a/azalea-nbt/README.md b/azalea-nbt/README.md
old mode 100644
new mode 100755
diff --git a/azalea-nbt/benches/my_benchmark.rs b/azalea-nbt/benches/my_benchmark.rs
old mode 100644
new mode 100755
diff --git a/azalea-nbt/src/decode.rs b/azalea-nbt/src/decode.rs
old mode 100644
new mode 100755
index 41689a46..e4968811
--- a/azalea-nbt/src/decode.rs
+++ b/azalea-nbt/src/decode.rs
@@ -11,13 +11,13 @@ async fn read_string<R>(stream: &mut R) -> Result<String, Error>
 where
     R: AsyncRead + std::marker::Unpin,
 {
-    let length = stream.read_u16().await.map_err(|_| Error::InvalidTag)?;
+    let length = stream.read_u16().await?;
 
     let mut buf = Vec::with_capacity(length as usize);
     for _ in 0..length {
-        buf.push(stream.read_u8().await.map_err(|_| Error::InvalidTag)?);
+        buf.push(stream.read_u8().await?);
     }
-    String::from_utf8(buf).map_err(|_| Error::InvalidTag)
+    Ok(String::from_utf8(buf)?)
 }
 
 impl Tag {
@@ -31,26 +31,26 @@ impl Tag {
             // a TAG_Compound, and is not named despite being in a TAG_Compound
             0 => Tag::End,
             // A single signed byte
-            1 => Tag::Byte(stream.read_i8().await.map_err(|_| Error::InvalidTag)?),
+            1 => Tag::Byte(stream.read_i8().await?),
             // A single signed, big endian 16 bit integer
-            2 => Tag::Short(stream.read_i16().await.map_err(|_| Error::InvalidTag)?),
+            2 => Tag::Short(stream.read_i16().await?),
             // A single signed, big endian 32 bit integer
-            3 => Tag::Int(stream.read_i32().await.map_err(|_| Error::InvalidTag)?),
+            3 => Tag::Int(stream.read_i32().await?),
             // A single signed, big endian 64 bit integer
-            4 => Tag::Long(stream.read_i64().await.map_err(|_| Error::InvalidTag)?),
+            4 => Tag::Long(stream.read_i64().await?),
             // A single, big endian IEEE-754 single-precision floating point
             // number (NaN possible)
-            5 => Tag::Float(stream.read_f32().await.map_err(|_| Error::InvalidTag)?),
+            5 => Tag::Float(stream.read_f32().await?),
             // A single, big endian IEEE-754 double-precision floating point
             // number (NaN possible)
-            6 => Tag::Double(stream.read_f64().await.map_err(|_| Error::InvalidTag)?),
+            6 => Tag::Double(stream.read_f64().await?),
             // A length-prefixed array of signed bytes. The prefix is a signed
             // integer (thus 4 bytes)
             7 => {
-                let length = stream.read_i32().await.map_err(|_| Error::InvalidTag)?;
+                let length = stream.read_i32().await?;
                 let mut bytes = Vec::with_capacity(length as usize);
                 for _ in 0..length {
-                    bytes.push(stream.read_i8().await.map_err(|_| Error::InvalidTag)?);
+                    bytes.push(stream.read_i8().await?);
                 }
                 Tag::ByteArray(bytes)
             }
@@ -67,8 +67,8 @@ impl Tag {
             // another reference implementation by Mojang uses 1 instead;
             // parsers should accept any type if the length is <= 0).
             9 => {
-                let type_id = stream.read_u8().await.map_err(|_| Error::InvalidTag)?;
-                let length = stream.read_i32().await.map_err(|_| Error::InvalidTag)?;
+                let type_id = stream.read_u8().await?;
+                let length = stream.read_i32().await?;
                 let mut list = Vec::with_capacity(length as usize);
                 for _ in 0..length {
                     list.push(Tag::read_known(stream, type_id).await?);
@@ -94,20 +94,20 @@ impl Tag {
             // signed integer (thus 4 bytes) and indicates the number of 4 byte
             // integers.
             11 => {
-                let length = stream.read_i32().await.map_err(|_| Error::InvalidTag)?;
+                let length = stream.read_i32().await?;
                 let mut ints = Vec::with_capacity(length as usize);
                 for _ in 0..length {
-                    ints.push(stream.read_i32().await.map_err(|_| Error::InvalidTag)?);
+                    ints.push(stream.read_i32().await?);
                 }
                 Tag::IntArray(ints)
             }
             // A length-prefixed array of signed longs. The prefix is a signed
             // integer (thus 4 bytes) and indicates the number of 8 byte longs.
             12 => {
-                let length = stream.read_i32().await.map_err(|_| Error::InvalidTag)?;
+                let length = stream.read_i32().await?;
                 let mut longs = Vec::with_capacity(length as usize);
                 for _ in 0..length {
-                    longs.push(stream.read_i64().await.map_err(|_| Error::InvalidTag)?);
+                    longs.push(stream.read_i64().await?);
                 }
                 Tag::LongArray(longs)
             }
diff --git a/azalea-nbt/src/encode.rs b/azalea-nbt/src/encode.rs
old mode 100644
new mode 100755
diff --git a/azalea-nbt/src/error.rs b/azalea-nbt/src/error.rs
old mode 100644
new mode 100755
index 05ff15e0..278d2770
--- a/azalea-nbt/src/error.rs
+++ b/azalea-nbt/src/error.rs
@@ -14,3 +14,14 @@ impl std::fmt::Display for Error {
         }
     }
 }
+
+impl From<std::io::Error> for Error {
+    fn from(err: std::io::Error) -> Self {
+        Error::WriteError
+    }
+}
+impl From<std::string::FromUtf8Error> for Error {
+    fn from(err: std::string::FromUtf8Error) -> Self {
+        Error::WriteError
+    }
+}
\ No newline at end of file
diff --git a/azalea-nbt/src/lib.rs b/azalea-nbt/src/lib.rs
old mode 100644
new mode 100755
diff --git a/azalea-nbt/src/tag.rs b/azalea-nbt/src/tag.rs
old mode 100644
new mode 100755
diff --git a/azalea-nbt/tests/bigtest.nbt b/azalea-nbt/tests/bigtest.nbt
old mode 100644
new mode 100755
diff --git a/azalea-nbt/tests/complex_player.dat b/azalea-nbt/tests/complex_player.dat
old mode 100644
new mode 100755
diff --git a/azalea-nbt/tests/hello_world.nbt b/azalea-nbt/tests/hello_world.nbt
old mode 100644
new mode 100755
diff --git a/azalea-nbt/tests/inttest.nbt b/azalea-nbt/tests/inttest.nbt
old mode 100644
new mode 100755
diff --git a/azalea-nbt/tests/level.dat b/azalea-nbt/tests/level.dat
old mode 100644
new mode 100755
diff --git a/azalea-nbt/tests/simple_player.dat b/azalea-nbt/tests/simple_player.dat
old mode 100644
new mode 100755
diff --git a/azalea-nbt/tests/stringtest.nbt b/azalea-nbt/tests/stringtest.nbt
old mode 100644
new mode 100755
diff --git a/azalea-nbt/tests/tests.rs b/azalea-nbt/tests/tests.rs
old mode 100644
new mode 100755
diff --git a/azalea-protocol/Cargo.toml b/azalea-protocol/Cargo.toml
old mode 100644
new mode 100755
diff --git a/azalea-protocol/README.md b/azalea-protocol/README.md
old mode 100644
new mode 100755
diff --git a/azalea-protocol/packet-macros/Cargo.toml b/azalea-protocol/packet-macros/Cargo.toml
old mode 100644
new mode 100755
diff --git a/azalea-protocol/packet-macros/src/lib.rs b/azalea-protocol/packet-macros/src/lib.rs
old mode 100644
new mode 100755
diff --git a/azalea-protocol/src/connect.rs b/azalea-protocol/src/connect.rs
old mode 100644
new mode 100755
diff --git a/azalea-protocol/src/lib.rs b/azalea-protocol/src/lib.rs
old mode 100644
new mode 100755
diff --git a/azalea-protocol/src/mc_buf/mod.rs b/azalea-protocol/src/mc_buf/mod.rs
old mode 100644
new mode 100755
diff --git a/azalea-protocol/src/mc_buf/read.rs b/azalea-protocol/src/mc_buf/read.rs
old mode 100644
new mode 100755
diff --git a/azalea-protocol/src/mc_buf/write.rs b/azalea-protocol/src/mc_buf/write.rs
old mode 100644
new mode 100755
diff --git a/azalea-protocol/src/packets/game/clientbound_change_difficulty_packet.rs b/azalea-protocol/src/packets/game/clientbound_change_difficulty_packet.rs
old mode 100644
new mode 100755
diff --git a/azalea-protocol/src/packets/game/clientbound_custom_payload_packet.rs b/azalea-protocol/src/packets/game/clientbound_custom_payload_packet.rs
old mode 100644
new mode 100755
diff --git a/azalea-protocol/src/packets/game/clientbound_declare_commands_packet.rs b/azalea-protocol/src/packets/game/clientbound_declare_commands_packet.rs
old mode 100644
new mode 100755
diff --git a/azalea-protocol/src/packets/game/clientbound_login_packet.rs b/azalea-protocol/src/packets/game/clientbound_login_packet.rs
old mode 100644
new mode 100755
diff --git a/azalea-protocol/src/packets/game/clientbound_player_abilities_packet.rs b/azalea-protocol/src/packets/game/clientbound_player_abilities_packet.rs
old mode 100644
new mode 100755
diff --git a/azalea-protocol/src/packets/game/clientbound_set_carried_item_packet.rs b/azalea-protocol/src/packets/game/clientbound_set_carried_item_packet.rs
old mode 100644
new mode 100755
diff --git a/azalea-protocol/src/packets/game/clientbound_update_tags_packet.rs b/azalea-protocol/src/packets/game/clientbound_update_tags_packet.rs
old mode 100644
new mode 100755
diff --git a/azalea-protocol/src/packets/game/clientbound_update_view_distance_packet.rs b/azalea-protocol/src/packets/game/clientbound_update_view_distance_packet.rs
old mode 100644
new mode 100755
diff --git a/azalea-protocol/src/packets/game/mod.rs b/azalea-protocol/src/packets/game/mod.rs
old mode 100644
new mode 100755
diff --git a/azalea-protocol/src/packets/handshake/client_intention_packet.rs b/azalea-protocol/src/packets/handshake/client_intention_packet.rs
old mode 100644
new mode 100755
diff --git a/azalea-protocol/src/packets/handshake/mod.rs b/azalea-protocol/src/packets/handshake/mod.rs
old mode 100644
new mode 100755
diff --git a/azalea-protocol/src/packets/login/clientbound_custom_query_packet.rs b/azalea-protocol/src/packets/login/clientbound_custom_query_packet.rs
old mode 100644
new mode 100755
diff --git a/azalea-protocol/src/packets/login/clientbound_game_profile_packet.rs b/azalea-protocol/src/packets/login/clientbound_game_profile_packet.rs
old mode 100644
new mode 100755
diff --git a/azalea-protocol/src/packets/login/clientbound_hello_packet.rs b/azalea-protocol/src/packets/login/clientbound_hello_packet.rs
old mode 100644
new mode 100755
diff --git a/azalea-protocol/src/packets/login/clientbound_login_compression_packet.rs b/azalea-protocol/src/packets/login/clientbound_login_compression_packet.rs
old mode 100644
new mode 100755
diff --git a/azalea-protocol/src/packets/login/mod.rs b/azalea-protocol/src/packets/login/mod.rs
old mode 100644
new mode 100755
diff --git a/azalea-protocol/src/packets/login/serverbound_hello_packet.rs b/azalea-protocol/src/packets/login/serverbound_hello_packet.rs
old mode 100644
new mode 100755
diff --git a/azalea-protocol/src/packets/mod.rs b/azalea-protocol/src/packets/mod.rs
old mode 100644
new mode 100755
diff --git a/azalea-protocol/src/packets/status/clientbound_status_response_packet.rs b/azalea-protocol/src/packets/status/clientbound_status_response_packet.rs
old mode 100644
new mode 100755
diff --git a/azalea-protocol/src/packets/status/mod.rs b/azalea-protocol/src/packets/status/mod.rs
old mode 100644
new mode 100755
diff --git a/azalea-protocol/src/packets/status/serverbound_status_request_packet.rs b/azalea-protocol/src/packets/status/serverbound_status_request_packet.rs
old mode 100644
new mode 100755
diff --git a/azalea-protocol/src/read.rs b/azalea-protocol/src/read.rs
old mode 100644
new mode 100755
diff --git a/azalea-protocol/src/resolver.rs b/azalea-protocol/src/resolver.rs
old mode 100644
new mode 100755
diff --git a/azalea-protocol/src/write.rs b/azalea-protocol/src/write.rs
old mode 100644
new mode 100755
diff --git a/bot/Cargo.toml b/bot/Cargo.toml
old mode 100644
new mode 100755
diff --git a/bot/src/main.rs b/bot/src/main.rs
old mode 100644
new mode 100755
-- 
cgit v1.2.3


From b43ad19636aa197f145d696f2bb01adf833ddec8 Mon Sep 17 00:00:00 2001
From: mat <github@matdoes.dev>
Date: Sun, 24 Apr 2022 14:44:02 -0500
Subject: remove an unused thing from dependencies

---
 Cargo.lock                               | 10 ----------
 azalea-nbt/src/encode.rs                 |  4 ++--
 azalea-protocol/packet-macros/Cargo.toml |  1 -
 3 files changed, 2 insertions(+), 13 deletions(-)

(limited to 'Cargo.lock')

diff --git a/Cargo.lock b/Cargo.lock
index 8d94c26c..a0d60170 100755
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -180,15 +180,6 @@ version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c4872d67bab6358e59559027aa3b9157c53d9358c51423c17554809a8858e0f8"
 
-[[package]]
-name = "casey"
-version = "0.3.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fabe85130dda9cf267715582ce6cf1ab581c8dfe3cb33f7065fee0f14e3fea14"
-dependencies = [
- "syn",
-]
-
 [[package]]
 name = "cast"
 version = "0.2.7"
@@ -697,7 +688,6 @@ checksum = "0ab1bc2a289d34bd04a330323ac98a1b4bc82c9d9fcb1e66b63caa84da26b575"
 name = "packet-macros"
 version = "0.1.0"
 dependencies = [
- "casey",
  "proc-macro2",
  "quote",
  "syn",
diff --git a/azalea-nbt/src/encode.rs b/azalea-nbt/src/encode.rs
index c765d4a7..0a0237d3 100755
--- a/azalea-nbt/src/encode.rs
+++ b/azalea-nbt/src/encode.rs
@@ -5,6 +5,8 @@ use flate2::write::{GzEncoder, ZlibEncoder};
 use std::collections::HashMap;
 use std::io::Write;
 
+// who needs friends when you've got code that runs in nanoseconds?
+
 #[inline]
 fn write_string(writer: &mut dyn Write, string: &str) -> Result<(), Error> {
     writer.write_i16::<BE>(string.len() as i16)?;
@@ -13,8 +15,6 @@ fn write_string(writer: &mut dyn Write, string: &str) -> Result<(), Error> {
     Ok(())
 }
 
-// who needs friends when you've got code that runs in nanoseconds?
-
 #[inline]
 fn write_compound(
     writer: &mut dyn Write,
diff --git a/azalea-protocol/packet-macros/Cargo.toml b/azalea-protocol/packet-macros/Cargo.toml
index 5a301756..2c0f36d7 100755
--- a/azalea-protocol/packet-macros/Cargo.toml
+++ b/azalea-protocol/packet-macros/Cargo.toml
@@ -8,7 +8,6 @@ proc-macro = true
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-casey = "^0.3.3"
 proc-macro2 = "^1.0.36"
 quote = "^1.0.10"
 syn = "^1.0.82"
-- 
cgit v1.2.3