devalang_core/core/error/
mod.rs

1use crate::core::parser::{
2    driver::Parser,
3    statement::{Statement, StatementKind},
4};
5use serde::{Deserialize, Serialize};
6
7pub struct ErrorHandler {
8    errors: Vec<Error>,
9}
10
11#[derive(Serialize, Deserialize, Clone, Debug)]
12pub enum Severity {
13    Warning,
14    Critical,
15}
16
17#[derive(Serialize, Deserialize, Clone, Debug, Default)]
18pub struct StackFrame {
19    pub module: Option<String>,
20    pub context: Option<String>,
21    pub line: usize,
22    pub column: usize,
23}
24
25#[derive(Serialize, Deserialize, Clone, Debug)]
26pub struct ErrorResult {
27    pub message: String,
28    pub line: usize,
29    pub column: usize,
30    pub severity: Severity,
31    pub stack: Vec<StackFrame>,
32}
33
34#[derive(Clone)]
35pub struct Error {
36    pub message: String,
37    pub line: usize,
38    pub column: usize,
39}
40
41impl ErrorHandler {
42    pub fn new() -> Self {
43        Self { errors: Vec::new() }
44    }
45
46    pub fn add_error(&mut self, message: String, line: usize, column: usize) {
47        let error_statement = Error {
48            message,
49            line,
50            column,
51        };
52        self.errors.push(error_statement);
53    }
54
55    pub fn has_errors(&self) -> bool {
56        !self.errors.is_empty()
57    }
58
59    pub fn get_errors(&self) -> &Vec<Error> {
60        &self.errors
61    }
62
63    pub fn clear_errors(&mut self) {
64        self.errors.clear();
65    }
66
67    pub fn detect_from_statements(&mut self, _parser: &mut Parser, statements: &[Statement]) {
68        for stmt in statements {
69            match &stmt.kind {
70                StatementKind::Unknown => {
71                    self.add_error("Unknown statement".to_string(), stmt.line, stmt.column);
72                }
73                StatementKind::Error { message } => {
74                    self.add_error(message.clone(), stmt.line, stmt.column);
75                }
76                _ => {}
77            }
78        }
79    }
80}