diff --git a/src/lexer/byte_string.rs b/src/lexer/byte_string.rs
index 77bd07a..fe29e63 100644
--- a/src/lexer/byte_string.rs
+++ b/src/lexer/byte_string.rs
@@ -11,7 +11,7 @@ use std::str::from_utf8;
 ///
 /// The Trunk lexer and parser work mainly with byte strings because
 /// valid PHP code is not required to be valid UTF-8.
-#[derive(PartialOrd, PartialEq, Eq, Clone)]
+#[derive(PartialOrd, PartialEq, Eq, Clone, Hash)]
 pub struct ByteString {
     pub bytes: Vec<u8>,
     pub length: usize,
diff --git a/src/tree/comment.rs b/src/tree/comment.rs
index 0c0f626..402cdd7 100644
--- a/src/tree/comment.rs
+++ b/src/tree/comment.rs
@@ -4,7 +4,7 @@ use serde::Serialize;
 
 use crate::lexer::byte_string::ByteString;
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case", tag = "type")]
 pub enum CommentFormat {
     SingleLine,
@@ -13,7 +13,7 @@ pub enum CommentFormat {
     Document,
 }
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub struct Comment {
     pub position: usize,
@@ -21,7 +21,7 @@ pub struct Comment {
     pub content: ByteString,
 }
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub struct CommentGroup {
     pub comments: Vec<Comment>,
diff --git a/src/tree/definition/attribute.rs b/src/tree/definition/attribute.rs
index 68a2bb0..4a79a41 100644
--- a/src/tree/definition/attribute.rs
+++ b/src/tree/definition/attribute.rs
@@ -7,7 +7,7 @@ use crate::tree::identifier::Identifier;
 use crate::tree::utils::CommaSeparated;
 use crate::tree::Node;
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub struct AttributeGroupDefinition {
     pub hash_left_bracket: usize,
@@ -15,7 +15,7 @@ pub struct AttributeGroupDefinition {
     pub right_bracket: usize,
 }
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub struct AttributeDefinition {
     pub name: Identifier,
diff --git a/src/tree/definition/class.rs b/src/tree/definition/class.rs
index 37c6a9c..2ee13fb 100644
--- a/src/tree/definition/class.rs
+++ b/src/tree/definition/class.rs
@@ -18,7 +18,7 @@ use crate::tree::token::Keyword;
 use crate::tree::utils::CommaSeparated;
 use crate::tree::Node;
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub struct ClassDefinition {
     pub comments: CommentGroup,
@@ -33,21 +33,21 @@ pub struct ClassDefinition {
     pub body: ClassDefinitionBody,
 }
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub struct ClassDefinitionExtends {
     pub extends: Keyword,
     pub parent: TemplatedIdentifier,
 }
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub struct ClassDefinitionImplements {
     pub implements: Keyword,
     pub interfaces: CommaSeparated<TemplatedIdentifier>,
 }
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub struct ClassDefinitionBody {
     pub left_brace: usize,
@@ -55,7 +55,7 @@ pub struct ClassDefinitionBody {
     pub right_brace: usize,
 }
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case", tag = "type", content = "value")]
 pub enum ClassDefinitionMember {
     Constant(ClassishConstantDefinition),
diff --git a/src/tree/definition/constant.rs b/src/tree/definition/constant.rs
index d832f2b..df451c2 100644
--- a/src/tree/definition/constant.rs
+++ b/src/tree/definition/constant.rs
@@ -11,7 +11,7 @@ use crate::tree::token::Keyword;
 use crate::tree::utils::CommaSeparated;
 use crate::tree::Node;
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub struct ConstantDefinitionEntry {
     pub name: Identifier,
@@ -19,7 +19,7 @@ pub struct ConstantDefinitionEntry {
     pub value: Expression,
 }
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub struct ConstantDefinition {
     pub comments: CommentGroup,
@@ -28,7 +28,7 @@ pub struct ConstantDefinition {
     pub semicolon: usize,
 }
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub struct ClassishConstantDefinition {
     pub comments: CommentGroup,
diff --git a/src/tree/definition/enum.rs b/src/tree/definition/enum.rs
index 8000d41..0c568ca 100644
--- a/src/tree/definition/enum.rs
+++ b/src/tree/definition/enum.rs
@@ -13,14 +13,14 @@ use crate::tree::token::Keyword;
 use crate::tree::utils::CommaSeparated;
 use crate::tree::Node;
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case", tag = "type", content = "data")]
 pub enum EnumDefinition {
     Backed(BackedEnumDefinition),
     Unit(UnitEnumDefinition),
 }
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub struct UnitEnumDefinition {
     pub comments: CommentGroup,
@@ -31,14 +31,14 @@ pub struct UnitEnumDefinition {
     pub body: UnitEnumBodyDefinition,
 }
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub struct EnumImplementsDefinition {
     pub implements: Keyword,
     pub interfaces: CommaSeparated<TemplatedIdentifier>,
 }
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub struct UnitEnumBodyDefinition {
     pub left_brace: usize,
@@ -46,7 +46,7 @@ pub struct UnitEnumBodyDefinition {
     pub right_brace: usize,
 }
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case", tag = "type", content = "value")]
 pub enum UnitEnumMemberDefinition {
     Case(UnitEnumCaseDefinition),
@@ -54,7 +54,7 @@ pub enum UnitEnumMemberDefinition {
     Constant(ClassishConstantDefinition),
 }
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub struct UnitEnumCaseDefinition {
     pub attributes: Vec<AttributeGroupDefinition>,
@@ -63,7 +63,7 @@ pub struct UnitEnumCaseDefinition {
     pub semicolon: usize,
 }
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub struct BackedEnumDefinition {
     pub comments: CommentGroup,
@@ -75,14 +75,14 @@ pub struct BackedEnumDefinition {
     pub body: BackedEnumBodyDefinition,
 }
 
-#[derive(Debug, Clone, Eq, PartialEq, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, Clone, Hash, Eq, PartialEq, Deserialize, Serialize, JsonSchema)]
 #[serde(tag = "type", content = "value")]
 pub enum BackedEnumTypeDefinition {
     String(usize, Identifier),
     Int(usize, Identifier),
 }
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub struct BackedEnumBodyDefinition {
     pub left_brace: usize,
@@ -90,7 +90,7 @@ pub struct BackedEnumBodyDefinition {
     pub right_brace: usize,
 }
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case", tag = "type", content = "value")]
 pub enum BackedEnumMemberDefinition {
     Case(BackedEnumCaseDefinition),
@@ -98,7 +98,7 @@ pub enum BackedEnumMemberDefinition {
     Constant(ClassishConstantDefinition),
 }
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub struct BackedEnumCaseDefinition {
     pub attributes: Vec<AttributeGroupDefinition>,
diff --git a/src/tree/definition/function.rs b/src/tree/definition/function.rs
index 8b701dd..fb16158 100644
--- a/src/tree/definition/function.rs
+++ b/src/tree/definition/function.rs
@@ -16,14 +16,14 @@ use crate::tree::utils::CommaSeparated;
 use crate::tree::variable::Variable;
 use crate::tree::Node;
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub struct FunctionLikeReturnTypeDefinition {
     pub colon: usize,
     pub type_definition: TypeDefinition,
 }
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub struct FunctionLikeParameterDefinition {
     pub comments: CommentGroup,
@@ -34,14 +34,14 @@ pub struct FunctionLikeParameterDefinition {
     pub default: Option<FunctionLikeParameterDefaultValueDefinition>,
 }
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub struct FunctionLikeParameterDefaultValueDefinition {
     pub equals: usize,
     pub value: Expression,
 }
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub struct FunctionLikeParameterListDefinition {
     pub comments: CommentGroup,
@@ -50,7 +50,7 @@ pub struct FunctionLikeParameterListDefinition {
     pub right_parenthesis: usize,
 }
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub struct FunctionDefinition {
     pub comments: CommentGroup,
@@ -63,7 +63,7 @@ pub struct FunctionDefinition {
     pub body: BlockStatement,
 }
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub struct ConstructorParameterDefinition {
     pub attributes: Vec<AttributeGroupDefinition>,
@@ -76,7 +76,7 @@ pub struct ConstructorParameterDefinition {
     pub default: Option<FunctionLikeParameterDefaultValueDefinition>,
 }
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub struct ConstructorParameterListDefinition {
     pub comments: CommentGroup,
@@ -85,7 +85,7 @@ pub struct ConstructorParameterListDefinition {
     pub right_parenthesis: usize,
 }
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub struct AbstractConstructorDefinition {
     pub comments: CommentGroup,
@@ -98,7 +98,7 @@ pub struct AbstractConstructorDefinition {
     pub semicolon: usize,
 }
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub struct ConcreteConstructorDefinition {
     pub comments: CommentGroup,
@@ -111,7 +111,7 @@ pub struct ConcreteConstructorDefinition {
     pub body: BlockStatement,
 }
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub struct MethodTypeConstraintDefinition {
     pub comments: CommentGroup,
@@ -120,7 +120,7 @@ pub struct MethodTypeConstraintDefinition {
     pub type_definition: TypeDefinition,
 }
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub struct MethodTypeConstraintGroupDefinition {
     pub comments: CommentGroup,
@@ -128,7 +128,7 @@ pub struct MethodTypeConstraintGroupDefinition {
     pub constraints: CommaSeparated<MethodTypeConstraintDefinition>,
 }
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub struct AbstractMethodDefinition {
     pub comments: CommentGroup,
@@ -144,7 +144,7 @@ pub struct AbstractMethodDefinition {
     pub semicolon: usize,
 }
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub struct ConcreteMethodDefinition {
     pub comments: CommentGroup,
diff --git a/src/tree/definition/interface.rs b/src/tree/definition/interface.rs
index 1a6520e..f42f81d 100644
--- a/src/tree/definition/interface.rs
+++ b/src/tree/definition/interface.rs
@@ -14,7 +14,7 @@ use crate::tree::token::Keyword;
 use crate::tree::utils::CommaSeparated;
 use crate::tree::Node;
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub struct InterfaceDefinition {
     pub comments: CommentGroup,
@@ -26,14 +26,14 @@ pub struct InterfaceDefinition {
     pub body: InterfaceDefinitionBody,
 }
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub struct InterfaceDefinitionExtends {
     pub extends: Keyword,
     pub parents: CommaSeparated<TemplatedIdentifier>,
 }
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub struct InterfaceDefinitionBody {
     pub left_brace: usize,
@@ -41,7 +41,7 @@ pub struct InterfaceDefinitionBody {
     pub right_brace: usize,
 }
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case", tag = "type", content = "value")]
 pub enum InterfaceDefinitionMember {
     Constant(ClassishConstantDefinition),
diff --git a/src/tree/definition/mod.rs b/src/tree/definition/mod.rs
index 7e88980..b42e08d 100644
--- a/src/tree/definition/mod.rs
+++ b/src/tree/definition/mod.rs
@@ -25,14 +25,14 @@ pub mod template;
 pub mod r#type;
 pub mod r#use;
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub struct DefinitionTree {
     pub definitions: Vec<Definition>,
     pub eof: usize,
 }
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case", tag = "type", content = "value")]
 pub enum Definition {
     Namespace(Box<NamespaceDefinition>),
diff --git a/src/tree/definition/modifier.rs b/src/tree/definition/modifier.rs
index 82ce6ef..552e50b 100644
--- a/src/tree/definition/modifier.rs
+++ b/src/tree/definition/modifier.rs
@@ -4,7 +4,7 @@ use serde::Serialize;
 
 use crate::tree::Node;
 
-#[derive(Debug, Clone, Eq, PartialEq, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, Clone, Hash, Eq, PartialEq, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case", tag = "type")]
 pub enum Visibility {
     Public,
@@ -12,7 +12,7 @@ pub enum Visibility {
     Private,
 }
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case", tag = "type", content = "value")]
 pub enum VisibilityModifierDefinition {
     Public(usize),
@@ -20,7 +20,7 @@ pub enum VisibilityModifierDefinition {
     Private(usize),
 }
 
-#[derive(Debug, Clone, Eq, PartialEq, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, Clone, Hash, Eq, PartialEq, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case", tag = "type", content = "value")]
 pub enum PromotedPropertyModifierDefinition {
     Public(usize),
@@ -29,14 +29,14 @@ pub enum PromotedPropertyModifierDefinition {
     Readonly(usize),
 }
 
-#[derive(Debug, Clone, Eq, PartialEq, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, Clone, Hash, Eq, PartialEq, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 #[repr(transparent)]
 pub struct PromotedPropertyModifierDefinitionGroup {
     pub modifiers: Vec<PromotedPropertyModifierDefinition>,
 }
 
-#[derive(Debug, Clone, Eq, PartialEq, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, Clone, Hash, Eq, PartialEq, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case", tag = "type", content = "value")]
 pub enum PropertyModifierDefinition {
     Public(usize),
@@ -46,14 +46,14 @@ pub enum PropertyModifierDefinition {
     Readonly(usize),
 }
 
-#[derive(Debug, Clone, Eq, PartialEq, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, Clone, Hash, Eq, PartialEq, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 #[repr(transparent)]
 pub struct PropertyModifierDefinitionGroup {
     pub modifiers: Vec<PropertyModifierDefinition>,
 }
 
-#[derive(Debug, Clone, Eq, PartialEq, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, Clone, Hash, Eq, PartialEq, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case", tag = "type", content = "value")]
 pub enum MethodModifierDefinition {
     Final(usize),
@@ -64,14 +64,14 @@ pub enum MethodModifierDefinition {
     Private(usize),
 }
 
-#[derive(Debug, Clone, Eq, PartialEq, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, Clone, Hash, Eq, PartialEq, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 #[repr(transparent)]
 pub struct MethodModifierDefinitionGroup {
     pub modifiers: Vec<MethodModifierDefinition>,
 }
 
-#[derive(Debug, Clone, Eq, PartialEq, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, Clone, Hash, Eq, PartialEq, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case", tag = "type", content = "value")]
 pub enum ClassModifierDefinition {
     Final(usize),
@@ -79,14 +79,14 @@ pub enum ClassModifierDefinition {
     Readonly(usize),
 }
 
-#[derive(Debug, Clone, Eq, PartialEq, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, Clone, Hash, Eq, PartialEq, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 #[repr(transparent)]
 pub struct ClassModifierDefinitionGroup {
     pub modifiers: Vec<ClassModifierDefinition>,
 }
 
-#[derive(Debug, Clone, Eq, PartialEq, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, Clone, Hash, Eq, PartialEq, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case", tag = "type", content = "value")]
 pub enum ConstantModifierDefinition {
     Final(usize),
@@ -95,7 +95,7 @@ pub enum ConstantModifierDefinition {
     Private(usize),
 }
 
-#[derive(Debug, Clone, Eq, PartialEq, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, Clone, Hash, Eq, PartialEq, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 #[repr(transparent)]
 pub struct ConstantModifierDefinitionGroup {
diff --git a/src/tree/definition/namespace.rs b/src/tree/definition/namespace.rs
index f82a0b9..785c47a 100644
--- a/src/tree/definition/namespace.rs
+++ b/src/tree/definition/namespace.rs
@@ -7,7 +7,7 @@ use crate::tree::identifier::Identifier;
 use crate::tree::token::Keyword;
 use crate::tree::Node;
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub struct NamespaceDefinition {
     pub namespace: Keyword,
diff --git a/src/tree/definition/property.rs b/src/tree/definition/property.rs
index aed1900..1eaaf3b 100644
--- a/src/tree/definition/property.rs
+++ b/src/tree/definition/property.rs
@@ -9,7 +9,7 @@ use crate::tree::expression::Expression;
 use crate::tree::variable::Variable;
 use crate::tree::Node;
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub struct PropertyDefinition {
     pub attributes: Vec<AttributeGroupDefinition>,
@@ -20,7 +20,7 @@ pub struct PropertyDefinition {
     pub semicolon: usize,
 }
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case", tag = "type", content = "value")]
 pub enum PropertyEntryDefinition {
     Uninitialized {
diff --git a/src/tree/definition/template.rs b/src/tree/definition/template.rs
index 37728df..f26f0b9 100644
--- a/src/tree/definition/template.rs
+++ b/src/tree/definition/template.rs
@@ -9,21 +9,21 @@ use crate::tree::token::Keyword;
 use crate::tree::utils::CommaSeparated;
 use crate::tree::Node;
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub enum TemplateDefinitionVariance {
     Covariance(usize),
     Invaraint,
 }
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub enum TemplateDefinitionTypeConstraint {
     SubType(Keyword, TypeDefinition),
     None,
 }
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub struct TemplateDefinition {
     pub variance: TemplateDefinitionVariance,
@@ -31,7 +31,7 @@ pub struct TemplateDefinition {
     pub constraint: TemplateDefinitionTypeConstraint,
 }
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub struct TemplateGroupDefinition {
     pub comments: CommentGroup,
@@ -40,7 +40,7 @@ pub struct TemplateGroupDefinition {
     pub greater_than: usize,
 }
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub struct TypeTemplateGroupDefinition {
     pub comments: CommentGroup,
diff --git a/src/tree/definition/type.rs b/src/tree/definition/type.rs
index baa2e09..9f7e783 100644
--- a/src/tree/definition/type.rs
+++ b/src/tree/definition/type.rs
@@ -9,7 +9,7 @@ use crate::tree::token::Keyword;
 use crate::tree::utils::CommaSeparated;
 use crate::tree::Node;
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub struct TypeAliasDefinition {
     pub r#type: Keyword,
@@ -19,7 +19,7 @@ pub struct TypeAliasDefinition {
     pub semicolon: usize,
 }
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case", tag = "type", content = "value")]
 pub enum TypeDefinition {
     Identifier(TemplatedIdentifier),
diff --git a/src/tree/definition/use.rs b/src/tree/definition/use.rs
index 6c82f93..f3e4204 100644
--- a/src/tree/definition/use.rs
+++ b/src/tree/definition/use.rs
@@ -6,7 +6,7 @@ use crate::tree::identifier::Identifier;
 use crate::tree::token::Keyword;
 use crate::tree::Node;
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case", tag = "type", content = "value")]
 pub enum UseDefinition {
     Default {
@@ -32,7 +32,7 @@ pub enum UseDefinition {
     },
 }
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub struct UseDefinitionSymbolAlias {
     pub r#as: Keyword,
diff --git a/src/tree/expression/argument.rs b/src/tree/expression/argument.rs
index 9aac7c2..1b1f05d 100644
--- a/src/tree/expression/argument.rs
+++ b/src/tree/expression/argument.rs
@@ -8,7 +8,7 @@ use crate::tree::identifier::Identifier;
 use crate::tree::utils::CommaSeparated;
 use crate::tree::Node;
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case", tag = "type", content = "value")]
 pub enum ArgumentExpression {
     Value {
@@ -33,7 +33,7 @@ pub enum ArgumentExpression {
     },
 }
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub struct ArgumentListExpression {
     pub comments: CommentGroup,
@@ -42,7 +42,7 @@ pub struct ArgumentListExpression {
     pub right_parenthesis: usize,
 }
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub struct ArgumentPlaceholderExpression {
     pub comments: CommentGroup,
diff --git a/src/tree/expression/array.rs b/src/tree/expression/array.rs
index aab8590..ef5e4b6 100644
--- a/src/tree/expression/array.rs
+++ b/src/tree/expression/array.rs
@@ -8,7 +8,7 @@ use crate::tree::token::Keyword;
 use crate::tree::utils::CommaSeparated;
 use crate::tree::Node;
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub struct VecExpression {
     pub comments: CommentGroup,
@@ -18,13 +18,13 @@ pub struct VecExpression {
     pub right_bracket: usize,
 }
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub struct VecElementExpression {
     pub value: Expression,
 }
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub struct DictExpression {
     pub comments: CommentGroup,
@@ -34,7 +34,7 @@ pub struct DictExpression {
     pub right_bracket: usize,
 }
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub struct DictElementExpression {
     pub key: Expression,
@@ -42,7 +42,7 @@ pub struct DictElementExpression {
     pub value: Expression,
 }
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub struct TupleExpression {
     pub comments: CommentGroup,
diff --git a/src/tree/expression/class.rs b/src/tree/expression/class.rs
index f55fbac..62ea182 100644
--- a/src/tree/expression/class.rs
+++ b/src/tree/expression/class.rs
@@ -14,7 +14,7 @@ use crate::tree::expression::argument::ArgumentListExpression;
 use crate::tree::token::Keyword;
 use crate::tree::Node;
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub struct AnonymousClassExpression {
     pub comments: CommentGroup,
@@ -26,7 +26,7 @@ pub struct AnonymousClassExpression {
     pub body: AnonymousClassExpressionBody,
 }
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub struct AnonymousClassExpressionBody {
     pub left_brace: usize,
@@ -34,7 +34,7 @@ pub struct AnonymousClassExpressionBody {
     pub right_brace: usize,
 }
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case", tag = "type", content = "value")]
 pub enum AnonymousClassExpressionMember {
     Constant(ClassishConstantDefinition),
diff --git a/src/tree/expression/construct.rs b/src/tree/expression/construct.rs
index a08b0bc..77ed195 100644
--- a/src/tree/expression/construct.rs
+++ b/src/tree/expression/construct.rs
@@ -7,7 +7,7 @@ use crate::tree::expression::Expression;
 use crate::tree::token::Keyword;
 use crate::tree::Node;
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case", tag = "type", content = "value")]
 pub enum ExitConstructExpression {
     Exit {
diff --git a/src/tree/expression/control_flow.rs b/src/tree/expression/control_flow.rs
index ab62d9e..3a4001b 100644
--- a/src/tree/expression/control_flow.rs
+++ b/src/tree/expression/control_flow.rs
@@ -8,7 +8,7 @@ use crate::tree::token::Keyword;
 use crate::tree::utils::CommaSeparated;
 use crate::tree::Node;
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub struct MatchExpression {
     pub comments: CommentGroup,
@@ -17,7 +17,7 @@ pub struct MatchExpression {
     pub body: MatchBodyExpression,
 }
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub struct MatchBodyExpression {
     pub left_brace: usize,
@@ -25,7 +25,7 @@ pub struct MatchBodyExpression {
     pub right_brace: usize,
 }
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub struct MatchArmExpression {
     pub condition: MatchArmConditionExpression,
@@ -33,7 +33,7 @@ pub struct MatchArmExpression {
     pub expression: Expression,
 }
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub enum MatchArmConditionExpression {
     Expressions(CommaSeparated<Expression>),
diff --git a/src/tree/expression/function.rs b/src/tree/expression/function.rs
index 064016a..34389cc 100644
--- a/src/tree/expression/function.rs
+++ b/src/tree/expression/function.rs
@@ -13,7 +13,7 @@ use crate::tree::utils::CommaSeparated;
 use crate::tree::variable::Variable;
 use crate::tree::Node;
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub struct ArrowFunctionExpression {
     pub comments: CommentGroup,
@@ -26,7 +26,7 @@ pub struct ArrowFunctionExpression {
     pub body: Box<Expression>,
 }
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub struct AnonymousFunctionExpression {
     pub comments: CommentGroup,
@@ -39,7 +39,7 @@ pub struct AnonymousFunctionExpression {
     pub body: BlockStatement,
 }
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub struct AnonymousFunctionUseClauseExpression {
     pub comments: CommentGroup,
@@ -49,7 +49,7 @@ pub struct AnonymousFunctionUseClauseExpression {
     pub right_parenthesis: usize,
 }
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub struct AnonymousFunctionUseClauseVariableExpression {
     pub comments: CommentGroup,
diff --git a/src/tree/expression/generic.rs b/src/tree/expression/generic.rs
index 8c9defe..7dae1c0 100644
--- a/src/tree/expression/generic.rs
+++ b/src/tree/expression/generic.rs
@@ -6,7 +6,7 @@ use crate::tree::definition::r#type::TypeDefinition;
 use crate::tree::utils::CommaSeparated;
 use crate::tree::Node;
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub struct GenericGroupExpression {
     pub double_colon_less_than: usize,
diff --git a/src/tree/expression/literal.rs b/src/tree/expression/literal.rs
index ab024db..609eef5 100644
--- a/src/tree/expression/literal.rs
+++ b/src/tree/expression/literal.rs
@@ -7,7 +7,7 @@ use crate::tree::comment::CommentGroup;
 use crate::tree::token::Keyword;
 use crate::tree::Node;
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case", tag = "type", content = "value")]
 pub enum Literal {
     String(LiteralString),
@@ -18,7 +18,7 @@ pub enum Literal {
     False(LiteralFalse),
 }
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub struct LiteralString {
     pub comments: CommentGroup,
@@ -26,7 +26,7 @@ pub struct LiteralString {
     pub position: usize,
 }
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub struct LiteralInteger {
     pub comments: CommentGroup,
@@ -34,7 +34,7 @@ pub struct LiteralInteger {
     pub position: usize,
 }
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub struct LiteralFloat {
     pub comments: CommentGroup,
@@ -42,21 +42,21 @@ pub struct LiteralFloat {
     pub position: usize,
 }
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub struct LiteralNull {
     pub comments: CommentGroup,
     pub null: Keyword,
 }
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub struct LiteralTrue {
     pub comments: CommentGroup,
     pub r#true: Keyword,
 }
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub struct LiteralFalse {
     pub comments: CommentGroup,
diff --git a/src/tree/expression/magic_constant.rs b/src/tree/expression/magic_constant.rs
index 571ac80..d495060 100644
--- a/src/tree/expression/magic_constant.rs
+++ b/src/tree/expression/magic_constant.rs
@@ -5,7 +5,7 @@ use serde::Serialize;
 use crate::lexer::byte_string::ByteString;
 use crate::tree::Node;
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case", tag = "type", content = "value")]
 pub enum MagicConstant {
     Directory { position: usize, value: ByteString },
diff --git a/src/tree/expression/mod.rs b/src/tree/expression/mod.rs
index f583b44..738bef8 100644
--- a/src/tree/expression/mod.rs
+++ b/src/tree/expression/mod.rs
@@ -45,7 +45,7 @@ pub mod literal;
 pub mod magic_constant;
 pub mod operator;
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case", tag = "type", content = "value")]
 pub enum Expression {
     Parenthesized(ParenthesizedExpression),
@@ -79,7 +79,7 @@ pub enum Expression {
     MagicConstant(MagicConstant),
 }
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub struct ParenthesizedExpression {
     pub comments: CommentGroup,
diff --git a/src/tree/expression/operator.rs b/src/tree/expression/operator.rs
index b502b5e..a04eddf 100644
--- a/src/tree/expression/operator.rs
+++ b/src/tree/expression/operator.rs
@@ -15,7 +15,7 @@ use crate::tree::utils::CommaSeparated;
 use crate::tree::variable::Variable;
 use crate::tree::Node;
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case", tag = "type", content = "value")]
 pub enum ArithmeticOperationExpression {
     Addition {
@@ -84,7 +84,7 @@ pub enum ArithmeticOperationExpression {
     },
 }
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case", tag = "type", content = "value")]
 pub enum AssignmentOperationExpression {
     Assignment {
@@ -173,7 +173,7 @@ pub enum AssignmentOperationExpression {
     },
 }
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case", tag = "type", content = "value")]
 pub enum BitwiseOperationExpression {
     And {
@@ -213,7 +213,7 @@ pub enum BitwiseOperationExpression {
     },
 }
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case", tag = "type", content = "value")]
 pub enum ComparisonOperationExpression {
     Equal {
@@ -272,7 +272,7 @@ pub enum ComparisonOperationExpression {
     },
 }
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case", tag = "type", content = "value")]
 pub enum LogicalOperationExpression {
     And {
@@ -294,7 +294,7 @@ pub enum LogicalOperationExpression {
     },
 }
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case", tag = "type", content = "value")]
 pub enum StringOperationExpression {
     Concat {
@@ -305,7 +305,7 @@ pub enum StringOperationExpression {
     },
 }
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case", tag = "type", content = "value")]
 pub enum ArrayOperationExpression {
     Access {
@@ -339,7 +339,7 @@ pub enum ArrayOperationExpression {
     },
 }
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case", tag = "type", content = "value")]
 pub enum CoalesceOperationExpression {
     Coalesce {
@@ -350,7 +350,7 @@ pub enum CoalesceOperationExpression {
     },
 }
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case", tag = "type", content = "value")]
 pub enum TernaryOperationExpression {
     Ternary {
@@ -376,7 +376,7 @@ pub enum TernaryOperationExpression {
     },
 }
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case", tag = "type", content = "value")]
 pub enum TypeOperationExpression {
     Instanceof {
@@ -405,7 +405,7 @@ pub enum TypeOperationExpression {
     },
 }
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case", tag = "type", content = "value")]
 pub enum GeneratorOperationExpression {
     Yield {
@@ -432,7 +432,7 @@ pub enum GeneratorOperationExpression {
     },
 }
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case", tag = "type", content = "value")]
 pub enum ExceptionOperationExpression {
     Throw {
@@ -442,7 +442,7 @@ pub enum ExceptionOperationExpression {
     },
 }
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case", tag = "type", content = "value")]
 pub enum ObjectOperationExpression {
     Clone {
@@ -488,14 +488,14 @@ pub enum ObjectOperationExpression {
     },
 }
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case", tag = "type", content = "value")]
 pub enum ClassOperationInitializationClassExpression {
     Identifier(Identifier),
     Variable(Variable),
 }
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case", tag = "type", content = "value")]
 pub enum ClassOperationExpression {
     Initialization {
@@ -540,7 +540,7 @@ pub enum ClassOperationExpression {
     },
 }
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case", tag = "type", content = "value")]
 pub enum FunctionOperationExpression {
     Call {
@@ -557,7 +557,7 @@ pub enum FunctionOperationExpression {
     },
 }
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case", tag = "type", content = "value")]
 pub enum AsyncOperationExpression {
     Async {
@@ -579,7 +579,7 @@ pub enum AsyncOperationExpression {
     },
 }
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case", tag = "type", content = "value")]
 pub enum RangeOperationExpression {
     Between {
diff --git a/src/tree/identifier.rs b/src/tree/identifier.rs
index df419b6..751f551 100644
--- a/src/tree/identifier.rs
+++ b/src/tree/identifier.rs
@@ -7,14 +7,14 @@ use crate::lexer::byte_string::ByteString;
 use crate::tree::definition::template::TypeTemplateGroupDefinition;
 use crate::tree::Node;
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub struct Identifier {
     pub position: usize,
     pub value: ByteString, // `Bar`
 }
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub struct TemplatedIdentifier {
     pub name: Identifier,                               // `Bar`
diff --git a/src/tree/statement/block.rs b/src/tree/statement/block.rs
index e4779e9..f9d868d 100644
--- a/src/tree/statement/block.rs
+++ b/src/tree/statement/block.rs
@@ -6,7 +6,7 @@ use crate::tree::comment::CommentGroup;
 use crate::tree::statement::Statement;
 use crate::tree::Node;
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub struct BlockStatement {
     pub comments: CommentGroup,
diff --git a/src/tree/statement/control_flow.rs b/src/tree/statement/control_flow.rs
index 28fcc61..b7e53da 100644
--- a/src/tree/statement/control_flow.rs
+++ b/src/tree/statement/control_flow.rs
@@ -10,7 +10,7 @@ use crate::tree::utils::CommaSeparated;
 use crate::tree::variable::Variable;
 use crate::tree::Node;
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub struct IfStatement {
     pub comments: CommentGroup,
@@ -21,7 +21,7 @@ pub struct IfStatement {
     pub r#else: Option<IfElseStatement>,
 }
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub struct IfElseIfStatement {
     pub comments: CommentGroup,
@@ -30,7 +30,7 @@ pub struct IfElseIfStatement {
     pub block: BlockStatement,
 }
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub struct IfElseStatement {
     pub comments: CommentGroup,
@@ -38,14 +38,14 @@ pub struct IfElseStatement {
     pub block: IfElseBlockStatement,
 }
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub enum IfElseBlockStatement {
     If(Box<IfStatement>),
     Block(BlockStatement),
 }
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub struct UsingStatement {
     pub comments: CommentGroup,
@@ -55,7 +55,7 @@ pub struct UsingStatement {
     pub block: BlockStatement,
 }
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub struct UsingAssignmentStatement {
     pub comments: CommentGroup,
@@ -64,7 +64,7 @@ pub struct UsingAssignmentStatement {
     pub expression: Expression,
 }
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub struct UsingIfClauseStatement {
     pub comments: CommentGroup,
diff --git a/src/tree/statement/expression.rs b/src/tree/statement/expression.rs
index 05eb167..494eca4 100644
--- a/src/tree/statement/expression.rs
+++ b/src/tree/statement/expression.rs
@@ -6,7 +6,7 @@ use crate::tree::comment::CommentGroup;
 use crate::tree::expression::Expression;
 use crate::tree::Node;
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub struct ExpressionStatement {
     pub comments: CommentGroup,
diff --git a/src/tree/statement/loop.rs b/src/tree/statement/loop.rs
index acebd46..9462583 100644
--- a/src/tree/statement/loop.rs
+++ b/src/tree/statement/loop.rs
@@ -11,7 +11,7 @@ use crate::tree::utils::CommaSeparated;
 use crate::tree::variable::Variable;
 use crate::tree::Node;
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub struct ForeachStatement {
     pub comments: CommentGroup,
@@ -20,7 +20,7 @@ pub struct ForeachStatement {
     pub block: BlockStatement,
 }
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub enum ForeachIteratorStatement {
     Value {
@@ -53,7 +53,7 @@ pub enum ForeachIteratorStatement {
     },
 }
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub struct ForStatement {
     pub comments: CommentGroup,
@@ -62,7 +62,7 @@ pub struct ForStatement {
     pub block: BlockStatement,
 }
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub enum ForIteratorStatement {
     Standalone {
@@ -83,7 +83,7 @@ pub enum ForIteratorStatement {
     },
 }
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub struct DoWhileStatement {
     pub comments: CommentGroup,
@@ -94,7 +94,7 @@ pub struct DoWhileStatement {
     pub semicolon: usize,
 }
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub struct WhileStatement {
     pub comments: CommentGroup,
@@ -103,7 +103,7 @@ pub struct WhileStatement {
     pub block: BlockStatement,
 }
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub struct BreakStatement {
     pub comments: CommentGroup,
@@ -112,7 +112,7 @@ pub struct BreakStatement {
     pub semicolon: usize,
 }
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub struct ContinueStatement {
     pub comments: CommentGroup,
diff --git a/src/tree/statement/mod.rs b/src/tree/statement/mod.rs
index 629b431..863e902 100644
--- a/src/tree/statement/mod.rs
+++ b/src/tree/statement/mod.rs
@@ -24,7 +24,7 @@ pub mod r#loop;
 pub mod r#return;
 pub mod r#try;
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case", tag = "type", content = "value")]
 pub enum Statement {
     DoWhile(Box<DoWhileStatement>),
diff --git a/src/tree/statement/return.rs b/src/tree/statement/return.rs
index d837771..4afe2fe 100644
--- a/src/tree/statement/return.rs
+++ b/src/tree/statement/return.rs
@@ -7,7 +7,7 @@ use crate::tree::expression::Expression;
 use crate::tree::token::Keyword;
 use crate::tree::Node;
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case", tag = "type", content = "value")]
 pub enum ReturnStatement {
     Explicit {
diff --git a/src/tree/statement/try.rs b/src/tree/statement/try.rs
index 3fd7696..fab4b38 100644
--- a/src/tree/statement/try.rs
+++ b/src/tree/statement/try.rs
@@ -9,7 +9,7 @@ use crate::tree::token::Keyword;
 use crate::tree::variable::Variable;
 use crate::tree::Node;
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub struct TryStatement {
     pub comments: CommentGroup,
@@ -19,7 +19,7 @@ pub struct TryStatement {
     pub finally: Option<TryFinallyBlockStatement>,
 }
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub struct TryCatchBlockStatement {
     pub comments: CommentGroup,
@@ -31,14 +31,14 @@ pub struct TryCatchBlockStatement {
     pub block: BlockStatement,
 }
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case", tag = "type", content = "value")]
 pub enum TryCatchTypeStatement {
     Identifier(Identifier),
     Union(Vec<Identifier>),
 }
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub struct TryFinallyBlockStatement {
     pub comments: CommentGroup,
diff --git a/src/tree/token.rs b/src/tree/token.rs
index 146b7e7..355872b 100644
--- a/src/tree/token.rs
+++ b/src/tree/token.rs
@@ -8,7 +8,7 @@ use crate::lexer::byte_string::ByteString;
 use crate::tree::comment::CommentGroup;
 use crate::tree::Node;
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub struct Keyword {
     pub value: ByteString,
diff --git a/src/tree/utils.rs b/src/tree/utils.rs
index 75d7fad..a316a90 100644
--- a/src/tree/utils.rs
+++ b/src/tree/utils.rs
@@ -4,7 +4,7 @@ use serde::Serialize;
 
 use crate::tree::Node;
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub struct CommaSeparated<T: Node> {
     pub inner: Vec<T>,
diff --git a/src/tree/variable.rs b/src/tree/variable.rs
index 948fca9..64149a1 100644
--- a/src/tree/variable.rs
+++ b/src/tree/variable.rs
@@ -7,7 +7,7 @@ use std::fmt::Display;
 use crate::lexer::byte_string::ByteString;
 use crate::tree::Node;
 
-#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, PartialEq, Eq, Clone, Hash, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "snake_case")]
 pub struct Variable {
     pub position: usize,