Remove quickerror in favor of thiserror

rust_compiler/src/ffi/mod.rs

@@ -4,7 +4,7 @@ use parser::{sys_call::SysCall, Parser};
 use safer_ffi::prelude::*;
 use std::io::BufWriter;
 use tokenizer::{
-    token::{LexError, Token, TokenType},
+    token::{Token, TokenType},
     Tokenizer,
 };
 
@@ -140,14 +140,12 @@ pub fn tokenize_line(input: safer_ffi::slice::Ref<'_, u16>) -> safer_ffi::Vec<Ff
                 Err(ref e) => {
                     use tokenizer::token::LexError;
                     use tokenizer::Error::*;
-                    let (err_str, line, span) = match e {
-                        LexError(e) => match e {
-                            LexError::NumberParseError(line, span, err)
-                            | LexError::InvalidInput(line, span, err) => {
-                                (err.to_string(), line, span)
-                            }
-                            _ => continue,
-                        },
+                    let (err_str, _, span) = match e {
+                        LexError(LexError::NumberParse(line, span, err))
+                        | LexError(LexError::InvalidInput(line, span, err)) => {
+                            (err.to_string(), line, span)
+                        }
+
                         _ => continue,
                     };
 
@@ -160,10 +158,7 @@ pub fn tokenize_line(input: safer_ffi::slice::Ref<'_, u16>) -> safer_ffi::Vec<Ff
                     })
                 }
                 Ok(Token {
-                    line,
-                    span,
-                    token_type,
-                    ..
+                    span, token_type, ..
                 }) => tokens.push(FfiToken {
                     column: span.start as i32,
                     error: "".into(),

rust_compiler/src/main.rs

@@ -1,8 +1,5 @@
 #![allow(clippy::result_large_err)]
 
-#[macro_use]
-extern crate quick_error;
-
 use clap::Parser;
 use compiler::Compiler;
 use parser::Parser as ASTParser;
@@ -11,28 +8,22 @@ use std::{
     io::{stderr, BufWriter, Read, Write},
     path::PathBuf,
 };
+use thiserror::Error;
 use tokenizer::{self, Tokenizer};
 
-quick_error! {
-    #[derive(Debug)]
-    enum StationlangError {
-        TokenizerError(err: tokenizer::Error) {
-            from()
-            display("Tokenizer error: {}", err)
-        }
-        ParserError(err: parser::Error) {
-            from()
-            display("Parser error: {}", err)
-        }
-        CompileError(err: compiler::Error) {
-            from()
-            display("Compile error: {}", err)
-        }
-        IoError(err: std::io::Error) {
-            from()
-            display("IO error: {}", err)
-        }
-    }
+#[derive(Error, Debug)]
+enum StationlangError {
+    #[error(transparent)]
+    Tokenizer(#[from] tokenizer::Error),
+
+    #[error(transparent)]
+    Parser(#[from] parser::Error),
+
+    #[error(transparent)]
+    Compile(#[from] compiler::Error),
+
+    #[error(transparent)]
+    IO(#[from] std::io::Error),
 }
 
 #[derive(Parser, Debug)]