From f958bbcb7989d32b347aaa04864d82031d1a8441 Mon Sep 17 00:00:00 2001
From: John <j@soft.fish>
Date: Sun, 14 Apr 2024 23:11:48 -0500
Subject: [PATCH] cl-ast: Hash everything

---
 cl-ast/src/lib.rs | 118 +++++++++++++++++++++++-----------------------
 1 file changed, 59 insertions(+), 59 deletions(-)

diff --git a/cl-ast/src/lib.rs b/cl-ast/src/lib.rs
index 10e1d5c..66afb75 100644
--- a/cl-ast/src/lib.rs
+++ b/cl-ast/src/lib.rs
@@ -18,7 +18,7 @@ pub mod ast_impl;
 pub mod format;
 
 /// Whether a binding ([Static] or [Let]) or reference is mutable or not
-#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
 pub enum Mutability {
     #[default]
     Not,
@@ -26,7 +26,7 @@ pub enum Mutability {
 }
 
 /// Whether an [Item] is visible outside of the current [Module]
-#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
 pub enum Visibility {
     #[default]
     Private,
@@ -34,26 +34,26 @@ pub enum Visibility {
 }
 
 /// A list of [Item]s
-#[derive(Clone, Debug, Default, PartialEq, Eq)]
+#[derive(Clone, Debug, Default, PartialEq, Eq, Hash)]
 pub struct File {
     pub items: Vec<Item>,
 }
 
 // Metadata decorators
-#[derive(Clone, Debug, Default, PartialEq, Eq)]
+#[derive(Clone, Debug, Default, PartialEq, Eq, Hash)]
 pub struct Attrs {
     pub meta: Vec<Meta>,
 }
 
 /// A metadata decorator
-#[derive(Clone, Debug, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub struct Meta {
     pub name: Identifier,
     pub kind: MetaKind,
 }
 
 /// Information attached to [Meta]data
-#[derive(Clone, Debug, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub enum MetaKind {
     Plain,
     Equals(Literal),
@@ -62,7 +62,7 @@ pub enum MetaKind {
 
 // Items
 /// Anything that can appear at the top level of a [File]
-#[derive(Clone, Debug, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub struct Item {
     pub extents: Span,
     pub attrs: Attrs,
@@ -71,7 +71,7 @@ pub struct Item {
 }
 
 /// What kind of [Item] is this?
-#[derive(Clone, Debug, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub enum ItemKind {
     // TODO: Import declaration ("use") item
     // TODO: Trait declaration ("trait") item?
@@ -94,14 +94,14 @@ pub enum ItemKind {
 }
 
 /// An alias to another [Ty]
-#[derive(Clone, Debug, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub struct Alias {
     pub to: Identifier,
     pub from: Option<Box<Ty>>,
 }
 
 /// A compile-time constant
-#[derive(Clone, Debug, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub struct Const {
     pub name: Identifier,
     pub ty: Box<Ty>,
@@ -109,7 +109,7 @@ pub struct Const {
 }
 
 /// A `static` variable
-#[derive(Clone, Debug, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub struct Static {
     pub mutable: Mutability,
     pub name: Identifier,
@@ -118,21 +118,21 @@ pub struct Static {
 }
 
 /// An ordered collection of [Items](Item)
-#[derive(Clone, Debug, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub struct Module {
     pub name: Identifier,
     pub kind: ModuleKind,
 }
 
 /// The contents of a [Module], if they're in the same file
-#[derive(Clone, Debug, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub enum ModuleKind {
     Inline(File),
     Outline,
 }
 
 /// Code, and the interface to that code
-#[derive(Clone, Debug, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub struct Function {
     pub name: Identifier,
     pub args: Vec<Param>,
@@ -141,7 +141,7 @@ pub struct Function {
 }
 
 /// A single parameter for a [Function]
-#[derive(Clone, Debug, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub struct Param {
     pub mutability: Mutability,
     pub name: Identifier,
@@ -149,14 +149,14 @@ pub struct Param {
 }
 
 /// A user-defined product type
-#[derive(Clone, Debug, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub struct Struct {
     pub name: Identifier,
     pub kind: StructKind,
 }
 
 /// Either a [Struct]'s [StructMember]s or tuple [Ty]pes, if present.
-#[derive(Clone, Debug, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub enum StructKind {
     Empty,
     Tuple(Vec<Ty>),
@@ -164,7 +164,7 @@ pub enum StructKind {
 }
 
 /// The [Visibility], [Identifier], and [Ty]pe of a single [Struct] member
-#[derive(Clone, Debug, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub struct StructMember {
     pub vis: Visibility,
     pub name: Identifier,
@@ -172,14 +172,14 @@ pub struct StructMember {
 }
 
 /// A user-defined sum type
-#[derive(Clone, Debug, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub struct Enum {
     pub name: Identifier,
     pub kind: EnumKind,
 }
 
 /// An [Enum]'s [Variant]s, if it has a variant block
-#[derive(Clone, Debug, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub enum EnumKind {
     /// Represents an enum with no variants
     NoVariants,
@@ -187,14 +187,14 @@ pub enum EnumKind {
 }
 
 /// A single [Enum] variant
-#[derive(Clone, Debug, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub struct Variant {
     pub name: Identifier,
     pub kind: VariantKind,
 }
 
 /// Whether the [Variant] has a C-like constant value, a tuple, or [StructMember]s
-#[derive(Clone, Debug, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub enum VariantKind {
     Plain,
     CLike(u128),
@@ -203,28 +203,28 @@ pub enum VariantKind {
 }
 
 /// Sub-[items](Item) (associated functions, etc.) for a [Ty]
-#[derive(Clone, Debug, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub struct Impl {
     pub target: ImplKind,
     pub body: File,
 }
 
 // TODO: `impl` Trait for <Target> { }
-#[derive(Clone, Debug, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub enum ImplKind {
     Type(Ty),
     Trait { impl_trait: Path, for_type: Box<Ty> },
 }
 
 /// A type expression
-#[derive(Clone, Debug, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub struct Ty {
     pub extents: Span,
     pub kind: TyKind,
 }
 
 /// Information about a [Ty]pe expression
-#[derive(Clone, Debug, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub enum TyKind {
     Never,
     Empty,
@@ -236,34 +236,34 @@ pub enum TyKind {
 }
 
 /// A tuple of [Ty]pes
-#[derive(Clone, Debug, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub struct TyTuple {
     pub types: Vec<Ty>,
 }
 
 /// A [Ty]pe-reference expression as (number of `&`, [Path])
-#[derive(Clone, Debug, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub struct TyRef {
     pub count: u16,
     pub to: Path,
 }
 
 /// The args and return value for a function pointer [Ty]pe
-#[derive(Clone, Debug, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub struct TyFn {
     pub args: TyTuple,
     pub rety: Option<Box<Ty>>,
 }
 
 /// A path to an [Item] in the [Module] tree
-#[derive(Clone, Debug, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub struct Path {
     pub absolute: bool,
     pub parts: Vec<PathPart>,
 }
 
 /// A single component of a [Path]
-#[derive(Clone, Debug, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub enum PathPart {
     SuperKw,
     SelfKw,
@@ -272,11 +272,11 @@ pub enum PathPart {
 
 // TODO: Capture token?
 /// A name
-#[derive(Clone, Debug, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub struct Identifier(pub String);
 
 /// An abstract statement, and associated metadata
-#[derive(Clone, Debug, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub struct Stmt {
     pub extents: Span,
     pub kind: StmtKind,
@@ -284,14 +284,14 @@ pub struct Stmt {
 }
 
 /// Whether or not a [Stmt] is followed by a semicolon
-#[derive(Clone, Debug, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub enum Semi {
     Terminated,
     Unterminated,
 }
 
 /// Whether the [Stmt] is a [Let], [Item], or [Expr] statement
-#[derive(Clone, Debug, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub enum StmtKind {
     Empty,
     Local(Let),
@@ -300,7 +300,7 @@ pub enum StmtKind {
 }
 
 /// A local variable declaration [Stmt]
-#[derive(Clone, Debug, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub struct Let {
     pub mutable: Mutability,
     pub name: Identifier,
@@ -309,14 +309,14 @@ pub struct Let {
 }
 
 /// An expression, the beating heart of the language
-#[derive(Clone, Debug, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub struct Expr {
     pub extents: Span,
     pub kind: ExprKind,
 }
 
 /// Any of the different [Expr]essions
-#[derive(Clone, Debug, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub enum ExprKind {
     /// An [Assign]ment expression: [`Expr`] ([`AssignKind`] [`Expr`])\+
     Assign(Assign),
@@ -360,13 +360,13 @@ pub enum ExprKind {
 }
 
 /// An [Assign]ment expression: [`Expr`] ([`AssignKind`] [`Expr`])\+
-#[derive(Clone, Debug, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub struct Assign {
     pub kind: AssignKind,
     pub parts: Box<(ExprKind, ExprKind)>,
 }
 
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
 pub enum AssignKind {
     /// Standard Assignment with no read-back
     Plain,
@@ -383,14 +383,14 @@ pub enum AssignKind {
 }
 
 /// A [Binary] expression: [`Expr`] ([`BinaryKind`] [`Expr`])\+
-#[derive(Clone, Debug, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub struct Binary {
     pub kind: BinaryKind,
     pub parts: Box<(ExprKind, ExprKind)>,
 }
 
 /// A [Binary] operator
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
 pub enum BinaryKind {
     Lt,
     LtEq,
@@ -418,14 +418,14 @@ pub enum BinaryKind {
 }
 
 /// A [Unary] expression: [`UnaryKind`]\* [`Expr`]
-#[derive(Clone, Debug, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub struct Unary {
     pub kind: UnaryKind,
     pub tail: Box<ExprKind>,
 }
 
 /// A [Unary] operator
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
 pub enum UnaryKind {
     Deref,
     Neg,
@@ -436,14 +436,14 @@ pub enum UnaryKind {
     Tilde,
 }
 /// A repeated [Index] expression: a[10, 20, 30][40, 50, 60]
-#[derive(Clone, Debug, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub struct Index {
     pub head: Box<ExprKind>,
     pub indices: Vec<Expr>,
 }
 
 /// A [Literal]: 0x42, 1e123, 2.4, "Hello"
-#[derive(Clone, Debug, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub enum Literal {
     Bool(bool),
     Char(char),
@@ -452,21 +452,21 @@ pub enum Literal {
 }
 
 /// An [Array] literal: `[` [`Expr`] (`,` [`Expr`])\* `]`
-#[derive(Clone, Debug, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub struct Array {
     pub values: Vec<Expr>,
 }
 
 /// An Array literal constructed with [repeat syntax](ArrayRep)
 /// `[` [Expr] `;` [Literal] `]`
-#[derive(Clone, Debug, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub struct ArrayRep {
     pub value: Box<ExprKind>,
     pub repeat: Box<ExprKind>,
 }
 
 /// An address-of expression: `&` `mut`? [`Expr`]
-#[derive(Clone, Debug, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub struct AddrOf {
     pub count: usize,
     pub mutable: Mutability,
@@ -474,25 +474,25 @@ pub struct AddrOf {
 }
 
 /// A [Block] expression: `{` [`Stmt`]\* [`Expr`]? `}`
-#[derive(Clone, Debug, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub struct Block {
     pub stmts: Vec<Stmt>,
 }
 
 /// A [Grouping](Group) expression `(` [`Expr`] `)`
-#[derive(Clone, Debug, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub struct Group {
     pub expr: Box<ExprKind>,
 }
 
 /// A [Tuple] expression: `(` [`Expr`] (`,` [`Expr`])+ `)`
-#[derive(Clone, Debug, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub struct Tuple {
     pub exprs: Vec<Expr>,
 }
 
 /// A [While] expression: `while` [`Expr`] [`Block`] [`Else`]?
-#[derive(Clone, Debug, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub struct While {
     pub cond: Box<Expr>,
     pub pass: Box<Block>,
@@ -500,7 +500,7 @@ pub struct While {
 }
 
 /// An [If] expression: `if` [`Expr`] [`Block`] [`Else`]?
-#[derive(Clone, Debug, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub struct If {
     pub cond: Box<Expr>,
     pub pass: Box<Block>,
@@ -508,7 +508,7 @@ pub struct If {
 }
 
 /// A [For] expression: `for` Pattern `in` [`Expr`] [`Block`] [`Else`]?
-#[derive(Clone, Debug, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub struct For {
     pub bind: Identifier, // TODO: Patterns?
     pub cond: Box<Expr>,
@@ -517,23 +517,23 @@ pub struct For {
 }
 
 /// The (optional) `else` clause of a [While], [If], or [For] expression
-#[derive(Clone, Debug, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub struct Else {
     pub body: Option<Box<Expr>>,
 }
 
 /// A [Break] expression: `break` [`Expr`]?
-#[derive(Clone, Debug, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub struct Break {
     pub body: Option<Box<Expr>>,
 }
 
 /// A [Return] expression `return` [`Expr`]?
-#[derive(Clone, Debug, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub struct Return {
     pub body: Option<Box<Expr>>,
 }
 
 /// A continue expression: `continue`
-#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
 pub struct Continue;