From f55040ad0068e0bc979dda394ee586a1197766f6 Mon Sep 17 00:00:00 2001
From: sofia <sofia@teascade.net>
Date: Mon, 21 Jul 2025 11:06:42 +0300
Subject: [PATCH] Update how types are formatted

---
 reid/src/mir/fmt.rs       | 69 ++++++++++++++++++++++++++++++++++++---
 reid/src/mir/mod.rs       | 27 ++-------------
 reid_src/borrow_hard.reid |  4 +--
 3 files changed, 69 insertions(+), 31 deletions(-)

diff --git a/reid/src/mir/fmt.rs b/reid/src/mir/fmt.rs
index 7a9f2b3..b578b47 100644
--- a/reid/src/mir/fmt.rs
+++ b/reid/src/mir/fmt.rs
@@ -74,12 +74,12 @@ impl Display for FunctionDefinition {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         write!(
             f,
-            "{}fn {}({}) -> {} ",
+            "{}fn {}({}) -> {:#} ",
             if self.is_pub { "pub " } else { "" },
             self.name,
             self.parameters
                 .iter()
-                .map(|(n, t)| format!("{}: {}", n, t))
+                .map(|(n, t)| format!("{}: {:#}", n, t))
                 .collect::<Vec<_>>()
                 .join(", "),
             self.return_type
@@ -166,7 +166,7 @@ impl Display for ExprKind {
             ExprKind::Block(block) => Display::fmt(block, f),
             ExprKind::Indexed(expression, elem_ty, idx_expr) => {
                 Display::fmt(&expression, f)?;
-                write!(f, "<{}>", elem_ty)?;
+                write!(f, "<{:#}>", elem_ty)?;
                 write_index(f, idx_expr)
             }
             ExprKind::Array(expressions) => {
@@ -228,7 +228,7 @@ impl Display for IfExpression {
 
 impl Display for FunctionCall {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{}<{}>(", self.name, self.return_type)?;
+        write!(f, "{}<{:#}>(", self.name, self.return_type)?;
         for (i, param) in self.parameters.iter().enumerate() {
             Display::fmt(param, f)?;
             if i < (self.parameters.len() - 1) {
@@ -241,7 +241,7 @@ impl Display for FunctionCall {
 
 impl Display for NamedVariableRef {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "v(\"{}\", {})", &self.1, &self.0)
+        write!(f, "v(\"{}\", {:#})", &self.1, &self.0)
     }
 }
 
@@ -312,3 +312,62 @@ fn write_access(f: &mut std::fmt::Formatter<'_>, name: &String) -> std::fmt::Res
     f.write_char('.')?;
     Display::fmt(name, f)
 }
+
+impl Display for TypeKind {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            TypeKind::Bool => write!(f, "bool"),
+            TypeKind::I8 => write!(f, "i8"),
+            TypeKind::I16 => write!(f, "i16"),
+            TypeKind::I32 => write!(f, "i32"),
+            TypeKind::I64 => write!(f, "i64"),
+            TypeKind::I128 => write!(f, "i128"),
+            TypeKind::U8 => write!(f, "u8"),
+            TypeKind::U16 => write!(f, "u16"),
+            TypeKind::U32 => write!(f, "u32"),
+            TypeKind::U64 => write!(f, "u64"),
+            TypeKind::U128 => write!(f, "u128"),
+            TypeKind::Void => write!(f, "void"),
+            TypeKind::StringPtr => write!(f, "string"),
+            TypeKind::Array(type_kind, len) => {
+                f.write_char('[')?;
+                Display::fmt(type_kind, f)?;
+                write!(f, "; ")?;
+                Display::fmt(len, f)?;
+                f.write_char(']')
+            }
+            TypeKind::CustomType(name) => write!(f, "{}", name),
+            TypeKind::Borrow(type_kind, false) => {
+                write!(f, "&")?;
+                Display::fmt(type_kind, f)
+            }
+            TypeKind::Borrow(type_kind, true) => {
+                write!(f, "&mut ")?;
+                Display::fmt(type_kind, f)
+            }
+            TypeKind::Ptr(type_kind) => {
+                write!(f, "*")?;
+                Display::fmt(type_kind, f)
+            }
+            TypeKind::Vague(vague_type) => Display::fmt(vague_type, f),
+        }
+    }
+}
+
+impl Display for VagueType {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        if f.alternate() {
+            match self {
+                VagueType::Unknown => write!(f, "Unknown"),
+                VagueType::Number => write!(f, "Number"),
+                VagueType::TypeRef(id) => write!(f, "TypeRef({0})", id),
+            }
+        } else {
+            match self {
+                VagueType::Unknown => write!(f, "{{unknown}}"),
+                VagueType::Number => write!(f, "Number"),
+                VagueType::TypeRef(_) => write!(f, "{{unknown}}"),
+            }
+        }
+    }
+}
diff --git a/reid/src/mir/mod.rs b/reid/src/mir/mod.rs
index f432a8c..9024be5 100644
--- a/reid/src/mir/mod.rs
+++ b/reid/src/mir/mod.rs
@@ -77,53 +77,32 @@ impl TokenRange {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, thiserror::Error, PartialOrd, Ord, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub enum TypeKind {
-    #[error("bool")]
     Bool,
-    #[error("i8")]
     I8,
-    #[error("i16")]
     I16,
-    #[error("i32")]
     I32,
-    #[error("i64")]
     I64,
-    #[error("i128")]
     I128,
-    #[error("u8")]
     U8,
-    #[error("u16")]
     U16,
-    #[error("u32")]
     U32,
-    #[error("u64")]
     U64,
-    #[error("u128")]
     U128,
-    #[error("void")]
     Void,
-    #[error("string")]
     StringPtr,
-    #[error("[{0}; {1}]")]
     Array(Box<TypeKind>, u64),
-    #[error("{0}")]
     CustomType(String),
-    #[error("Borrow({0}, {1})")]
     Borrow(Box<TypeKind>, bool),
-    #[error("Ptr({0})")]
     Ptr(Box<TypeKind>),
-    #[error(transparent)]
-    Vague(#[from] VagueType),
+    Vague(VagueType),
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq, thiserror::Error, PartialOrd, Ord, Hash)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub enum VagueType {
-    #[error("Unknown")]
     Unknown,
-    #[error("Number")]
     Number,
-    #[error("TypeRef({0})")]
     TypeRef(usize),
 }
 
diff --git a/reid_src/borrow_hard.reid b/reid_src/borrow_hard.reid
index 8fc9e78..38fe32e 100644
--- a/reid_src/borrow_hard.reid
+++ b/reid_src/borrow_hard.reid
@@ -5,9 +5,9 @@ fn changer(param: &mut u32) {
 }
 
 fn main() -> u32 {
-  let value = 6;
+  let mut value = 6;
 
-  let mut a = &value;
+  changer(&mut value);
 
   return value;
 }