pascal 0.1.4

A modern Pascal compiler with build/intepreter/package manager built with Rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162

//! Diagnostic and error reporting trait definitions

use std::fmt;

/// Diagnostic severity level
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
pub enum Severity {
    Hint,
    Info,
    Warning,
    Error,
    Fatal,
}

/// Source location for diagnostics
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct DiagnosticLocation {
    pub file: String,
    pub line: usize,
    pub column: usize,
    pub span: std::ops::Range<usize>,
}

/// Diagnostic message
#[derive(Debug, Clone)]
pub struct Diagnostic {
    pub severity: Severity,
    pub message: String,
    pub location: DiagnosticLocation,
    pub hints: Vec<String>,
    pub code: Option<String>,
}

impl fmt::Display for Diagnostic {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        let severity_str = match self.severity {
            Severity::Hint => "hint",
            Severity::Info => "info",
            Severity::Warning => "warning",
            Severity::Error => "error",
            Severity::Fatal => "fatal error",
        };

        write!(
            f,
            "{}:{}:{}: {}: {}",
            self.location.file,
            self.location.line,
            self.location.column,
            severity_str,
            self.message
        )?;

        if let Some(code) = &self.code {
            write!(f, " [{}]", code)?;
        }

        Ok(())
    }
}

/// Diagnostic emitter trait
pub trait DiagnosticEmitter {
    /// Emit a diagnostic message
    fn emit(&mut self, diagnostic: Diagnostic);

    /// Emit an error
    fn emit_error(&mut self, location: DiagnosticLocation, message: &str) {
        self.emit(Diagnostic {
            severity: Severity::Error,
            message: message.to_string(),
            location,
            hints: vec![],
            code: None,
        });
    }

    /// Emit a warning
    fn emit_warning(&mut self, location: DiagnosticLocation, message: &str) {
        self.emit(Diagnostic {
            severity: Severity::Warning,
            message: message.to_string(),
            location,
            hints: vec![],
            code: None,
        });
    }

    /// Emit a hint
    fn emit_hint(&mut self, location: DiagnosticLocation, message: &str) {
        self.emit(Diagnostic {
            severity: Severity::Hint,
            message: message.to_string(),
            location,
            hints: vec![],
            code: None,
        });
    }

    /// Check if any errors were emitted
    fn has_errors(&self) -> bool;

    /// Get error count
    fn error_count(&self) -> usize;

    /// Get warning count
    fn warning_count(&self) -> usize;

    /// Clear all diagnostics
    fn clear(&mut self);

    /// Get all diagnostics
    fn diagnostics(&self) -> &[Diagnostic];
}

/// Diagnostic rendering trait
pub trait DiagnosticRenderer {
    /// Render diagnostics to string
    fn render(&self, diagnostic: &Diagnostic) -> String;

    /// Render with source code context
    fn render_with_context(&self, diagnostic: &Diagnostic, source: &str) -> String;

    /// Render multiple diagnostics
    fn render_all(&self, diagnostics: &[Diagnostic]) -> String;

    /// Color output (if supported)
    fn enable_colors(&mut self, enabled: bool);
}

/// Error reporting trait
pub trait DiagnosticErrorReporter {
    /// Report error with message
    fn report_error(&mut self, message: &str);

    /// Report error with location
    fn report_error_with_location(&mut self, location: DiagnosticLocation, message: &str);

    /// Report warning
    fn report_warning(&mut self, message: &str);

    /// Report fatal error (usually exits)
    fn report_fatal(&mut self, message: &str) -> !;

    /// Check if errors occurred
    fn has_errors(&self) -> bool;
}

/// Source code caching for diagnostics
pub trait SourceCache {
    /// Add source file to cache
    fn add_source(&mut self, file: String, source: String);

    /// Get source file from cache
    fn get_source(&self, file: &str) -> Option<&str>;

    /// Get line from source
    fn get_line(&self, file: &str, line: usize) -> Option<&str>;

    /// Remove source from cache
    fn remove_source(&mut self, file: &str);
}