SPWN RWRT lexer-parser rewrite

.gitignore

@@ -1,2 +1,3 @@
 /target
-.DS_Store
+.DS_Store
+.vscode

Cargo.toml

@@ -17,7 +17,10 @@ ansi_term = "0.12.1"
 regex = "1.5.6"
 thiserror = "1.0.31"
 ahash = "0.7.6"
-serde = { version = "1.0.138", features = ["derive"] }
+serde = { version = "1.0.138", features = ["derive", "rc"] }
 bincode = "1.3.3"
 lz4-compression = "0.7.0"
-yazi = "0.1.4"
+yazi = "0.1.4"
+lasso = "0.6.0"
+base64 = "0.13.0"
+erased-serde = "0.3"

src/compiler/mod.rs

@@ -1,2 +1,2 @@
-pub mod compiler;
-mod error;
+// pub mod compiler;
+// pub mod error;

src/error.rs

@@ -1,3 +1,8 @@
+use std::fmt::Display;
+
+// use crate::compiler::error::CompilerError;
+use crate::interpreter::error::RuntimeError;
+use crate::parser::error::SyntaxError;
 use ariadne::Color;
 
 pub const ERROR_S: f64 = 0.4;
@@ -11,6 +16,23 @@ pub struct RainbowColorGenerator {
     shift: f64,
 }
 
+#[derive(Debug)]
+pub enum Error {
+    Syntax(SyntaxError),
+    Runtime(RuntimeError),
+    // Compiler(CompilerError),
+}
+
+impl Display for self::Error {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        todo!()
+    }
+}
+
+impl std::error::Error for self::Error {}
+
+pub type Result<T> = std::result::Result<T, self::Error>;
+
 impl RainbowColorGenerator {
     pub fn new(h: f64, s: f64, v: f64, shift: f64) -> Self {
         Self { h, s, v, shift }
@@ -76,12 +98,14 @@ macro_rules! error_maker {
         )*
 
     ) => {
+        use std::path::PathBuf;
         use $crate::error::*;
         use ariadne::{Report, ReportKind, Label, Source, Fmt};
-        #[allow(unused_imports)]
-        use $crate::Globals;
+        // #[allow(unused_imports)]
+        // use $crate::Globals;
 
         $(
+            #[derive(Debug)]
             pub enum $err_type {
                 $(
                     $variant {
@@ -93,7 +117,7 @@ macro_rules! error_maker {
             }
 
             impl $err_type {
-                pub fn raise(self, source: $crate::sources::SpwnSource $(, $globals: &Globals)?) {
+                pub fn raise(self, code: String, source: Option<PathBuf> /*$(, $globals: &Globals)?*/) -> String {
                     let mut label_colors = RainbowColorGenerator::new(120.0, ERROR_S, ERROR_V, 45.0);
                     let mut item_colors = RainbowColorGenerator::new(0.0, ERROR_S, ERROR_V, 15.0);
 
@@ -113,6 +137,7 @@ macro_rules! error_maker {
                         )*
                     };
 
+                    // epic
                     let mut report = Report::build(ReportKind::Error, area.name(), area.span.0)
                         .with_message(message.to_string() + "\n");
 
@@ -128,10 +153,14 @@ macro_rules! error_maker {
                         report = report.with_note(m)
                     }
 
+                    let ret = vec![];
+
                     report
                         .finish()
-                        .eprint((source.name(), Source::from(source.contents())))
+                        .write((source.name(), Source::from(code)), &mut ret)
                         .unwrap();
+
+                    std::str::from_utf8(&ret).unwrap().to_string()
                 }
             }
         )*

src/interpreter/error.rs

@@ -95,19 +95,19 @@ error_maker! {
             area: CodeArea,
         },
 
-        #[
-            Message = "Pattern mismatch", Area = area, Note = None,
-            Labels = [
-                area => "This {} is not {}": @(v.value.get_type().to_str()), @(pat.value.to_str(globals));
-                v.def_area => "This is of type {}": @(v.value.get_type().to_str());
-                pat.def_area => "Pattern defined as {} here": @(pat.value.to_str(globals));
-            ]
-        ]
-        PatternMismatch {
-            v: StoredValue,
-            pat: StoredValue,
-            area: CodeArea,
-        },
+        // #[
+        //     Message = "Pattern mismatch", Area = area, Note = None,
+        //     Labels = [
+        //         area => "This {} is not {}": @(v.value.get_type().to_str()), @(pat.value.to_str(globals));
+        //         v.def_area => "This is of type {}": @(v.value.get_type().to_str());
+        //         pat.def_area => "Pattern defined as {} here": @(pat.value.to_str(globals));
+        //     ]
+        // ]
+        // PatternMismatch {
+        //     v: StoredValue,
+        //     pat: StoredValue,
+        //     area: CodeArea,
+        // },
 
         #[
             Message = "Argument not satisfied", Area = call_area, Note = None,
@@ -116,12 +116,16 @@ error_maker! {
                 call_area => "Argument not provided here";
             ]
         ]
+
         ArgumentNotSatisfied {
             arg_name: String,
             call_area: CodeArea,
             arg_area: CodeArea,
         },
 
+        // what if the errors just carry the file too
+        // and rest is spans
+
         #[
             Message = "Too many arguments!", Area = call_area, Note = None,
             Labels = [

src/interpreter/from_value.rs

@@ -3,7 +3,7 @@ use super::value::Value;
 // can't return a `RuntimeError` cause can't get an `area` here
 // instead return a tuple of arguments to be formatted into error at a different place that
 // has an `area`
-type Error = (String, &'static str);
+pub type Error = (String, &'static str);
 
 pub trait FromValue: Clone {
     fn from_value(val: Value) -> Result<Self, Error>;