ast error analyzer

mist-test/src/app.mist

@@ -1,95 +0,0 @@
-use <super::task>;
-use <super::logger>;
-use <super::event>;
-
-pub class Application {
-    String name;
-
-    Vec<task::Task> tasks;
-    Vec<String> plugins;
-
-    logger::Logger logger;
-
-    bool running;
-    i32 ticks;
-
-    pub constructor(str* name) {
-        self.name = name.to_string();
-
-        self.tasks = new Vec();
-        self.plugins = new Vec();
-
-        self.logger = new logger::Logger("app");
-
-        self.running = false;
-        self.ticks = 0;
-    }
-
-    pub void boot(self mut*) {
-        self.logger.info("booting application");
-
-        self.running = true;
-
-        self.emit(event::Event::Startup);
-    }
-
-    pub void run(self mut*) {
-        while(self.running) {
-            self.tick();
-
-            if(self.ticks >= 5) {
-                self.shutdown();
-            }
-        }
-    }
-
-    void tick(self mut*) {
-        self.logger.info("tick");
-
-        self.ticks = self.ticks + 1;
-
-        var task = task::create_task("background-job");
-
-        self.tasks.push(task);
-
-        println!("tasks: {}", self.tasks.len());
-    }
-
-    pub void shutdown(self mut*) {
-        self.emit(event::Event::Shutdown);
-
-        self.logger.warning("shutdown");
-
-        self.running = false;
-    }
-
-    pub void register_plugin(self mut*, String name) {
-        self.plugins.push(name.clone());
-
-        self.emit(event::Event::PluginLoaded(name));
-    }
-
-    void emit(self*, event::Event event) {
-        match(event) {
-            event::Event::Startup => {
-                self.logger.info("startup event");
-            }
-
-            event::Event::Shutdown => {
-                self.logger.info("shutdown event");
-            }
-
-            event::Event::PluginLoaded(name) => {
-                println!("plugin loaded: {}", name);
-            }
-
-            event::Event::TaskExecuted(name) => {
-                println!("task executed: {}", name);
-            }
-
-            event::Event::Error(message) => {
-                self.logger.error(&message);
-            }
-        }
-    }
-}

mist-test/src/event.mist

@@ -1,7 +0,0 @@
-pub enum Event {
-    Startup,
-    Shutdown,
-    TaskExecuted(String),
-    PluginLoaded(String),
-    Error(String),
-}

mist-test/src/logger.mist

@@ -1,72 +0,0 @@
-use <std::fmt::Formatter>;
-use <std::fmt>;
-
-pub trait TestLogging<T: fmt::Display>: fmt::Display {
-    String get();
-}
-
-pub enum LogLevel {
-    Info,
-    Warning,
-    Error,
-}
-
-impl fmt::Display for LogLevel {
-    fmt::Result fmt(self*, Formatter<'_> mut* f) {
-        match (self) {
-            LogLevel::Info => {
-                return write!(f, "[INFO]");
-            }
-
-            LogLevel::Warning => {
-                return write!(f, "[WARN]");
-            }
-
-            LogLevel::Error => {
-                return write!(f, "[ERROR]");
-            }
-        }
-    }
-}
-
-pub class Logger {
-    String prefix;
-
-    pub constructor(str* prefix) {
-        self.prefix = prefix.to_string();
-    }
-
-    pub void info(self*, str* message) {
-        self.log(LogLevel::Info, message);
-    }
-
-    pub void warning(self*, str* message) {
-        self.log(LogLevel::Warning, message);
-    }
-
-    pub void error(self*, str* message) {
-        self.log(LogLevel::Error, message);
-    }
-
-    void log(self*, LogLevel level, str* message) {
-        match(level) {
-            LogLevel::Info => {
-                println!("{level} {} {}", self.prefix, message);
-            }
-
-            LogLevel::Warning => {
-                println!("{level} {} {}", self.prefix, message);
-            }
-
-            LogLevel::Error => {
-                println!("{level} {} {}", self.prefix, message);
-            }
-        }
-    }
-
-    impl fmt::Display {
-        fmt::Result fmt(self*, Formatter<'_> mut* f) {
-            return write!(f, "logger ({})", self.prefix);
-        }
-    }
-}

mist-test/src/main.mist

@@ -1,15 +1,4 @@
-pub mod app;
-pub mod task;
-pub mod plugin;
-pub mod logger;
-pub mod event;
-
 void main() {
-    var mut app_instance = new app::Application("mist-app");
-
-    // greeting::register(&mut app_instance);
-    // statistics::register(&mut app_instance);
-
     app_instance.boot();
     app_instance.run();
 

mist-test/src/plugin.mist

@@ -1,16 +0,0 @@
-pub struct PluginInfo {
-    pub String name,
-    pub String version,
-}
-
-pub class PluginRegistry<T> {
-    T plugins;
-
-    pub constructor(T plugins) {
-        self.plugins = plugins;
-    }
-
-    pub T plugins(self) {
-        return self.plugins;
-    }
-}

mist-test/src/task.mist

@@ -1,20 +0,0 @@
-pub enum TaskState {
-    Pending,
-    Running,
-    Finished,
-    Failed,
-}
-
-pub struct Task {
-    pub String name,
-    pub TaskState state,
-    pub i32 executions,
-}
-
-pub Task create_task(str* name) {
-    return Task {
-        name: name.to_string(),
-        state: TaskState::Pending,
-        executions: 0,
-    };
-}

parser/src/error.rs

@@ -1,3 +1,5 @@
+use std::fmt::Debug;
+
 use crate::Rule;
 
 pub type AstResult<'a, T, ET = T> = Result<T, AstError<'a, ET>>;
@@ -75,7 +77,7 @@ impl<'a, F> GetParseError<'a, Option<Vec<F>>> for Result<Option<Vec<F>>, AstErro
     }
 }
 
-pub fn collect_recovered<'a, T, ET>(
+pub fn collect_recovered<'a, T: Debug, ET>(
     pairs: impl Iterator<Item = pest::iterators::Pair<'a, Rule>>,
 ) -> AstResult<'a, Vec<T>, Vec<T>>
 where
@@ -84,7 +86,7 @@ where
     collect_recovered_map(pairs, T::try_from)
 }
 
-pub fn collect_recovered_map<'a, T, F, ET>(
+pub fn collect_recovered_map<'a, T: Debug, F, ET>(
     pairs: impl Iterator<Item = pest::iterators::Pair<'a, Rule>>,
     f: F,
 ) -> AstResult<'a, Vec<T>, Vec<T>>
@@ -113,3 +115,31 @@ where
         None => Ok(items),
     }
 }
+
+pub struct AstErrorAnalyzer<'a, T>(pub Option<AstError<'a, T>>);
+
+impl<'a, T> AstErrorAnalyzer<'a, T> {
+    pub fn get<V: Clone>(&mut self, r: AstResult<'a, V>) -> AstResult<'a, V> {
+        if let Err(e) = r {
+            self.0 = Some(e.clone().get());
+
+            if let Some(recovered) = e.recovered {
+                Ok(recovered)
+            } else {
+                Err(e)
+            }
+        } else {
+            r
+        }
+    }
+
+    pub fn build(self, v: T) -> AstResult<'a, T> {
+        if let Some(mut e) = self.0 {
+            e.recovered = Some(v);
+
+            Err(e)
+        } else {
+            Ok(v)
+        }
+    }
+}

parser/src/lib.rs

@@ -30,61 +30,19 @@ pub fn parse<'a>(source: &'a str) -> Result<Vec<TopLevel>, ParseError<'a, Vec<To
 #[macro_export]
 macro_rules! ast_expr {
     ($($item:ident)::+ { $($k:ident: $v:expr),* $(,)? }) => {{
-        let mut err = None;
+        let mut analyzer = $crate::error::AstErrorAnalyzer(None);
 
-        let v = $($item)::+ {
-            $(
-                $k: {
-                    let r = $v.get();
+        let v = $($item)::+ { $($k: analyzer.get($v).get()?),* };
 
-                    if let Err(e) = r {
-                        err = Some(e.clone().get());
-
-                        if let Some(recovered) = e.recovered {
-                            Ok(recovered)
-                        } else {
-                            Err(e)
-                        }
-                    } else {
-                        r
-                    }
-                }.get()?
-            ),*
-        };
-
-        if let Some(mut e) = err {
-            e.recovered = Some(v);
-            Err(e)
-        } else {
-            Ok(v)
-        }
+        analyzer.build(v)
     }};
 
     ($($item:ident)::+ ( $($v:expr),* $(,)? )) => {{
-        let mut err = None;
+        let mut analyzer = $crate::error::AstErrorAnalyzer(None);
 
-        let v = $($item)::+ ( $({
-            let r = $v.get();
+        let v = $($item)::+ ( $(analyzer.get($v).get()?),* );
 
-            if let Err(e) = r {
-                err = Some(e.clone().get());
-
-                if let Some(recovered) = e.recovered {
-                    Ok(recovered)
-                } else {
-                    Err(e)
-                }
-            } else {
-                r
-            }
-        }.get()?),* );
-
-        if let Some(mut e) = err {
-            e.recovered = Some(v);
-            Err(e)
-        } else {
-            Ok(v)
-        }
+        analyzer.build(v)
     }};
 
     ($($item:ident)::+) => {