shape-ast 0.1.8

AST types and Pest grammar for the Shape programming language
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

//! Structured parse error types for Shape
//!
//! These types represent parse errors as structured data rather than strings,
//! enabling different rendering for CLI vs LSP contexts.

use super::{ErrorCode, SourceLocation};

// Module declarations
mod formatting;
mod kinds;
mod source_context;
mod suggestions;
mod tokens;

#[cfg(test)]
mod tests;

// Re-export all public types
pub use formatting::{format_error_message, matching_close, rule_to_friendly_name};
pub use kinds::{
    ErrorSeverity, IdentifierContext, MissingComponentKind, NumberError, ParseErrorKind,
    StringDelimiter,
};
pub use source_context::{Highlight, HighlightStyle, SourceContext, SourceLine};
pub use suggestions::{RelatedInfo, Suggestion, SuggestionConfidence, TextEdit};
pub use tokens::{ExpectedToken, TokenCategory, TokenInfo, TokenKind};

/// A complete structured parse error with all context needed for rendering
#[derive(Debug, Clone)]
pub struct StructuredParseError {
    /// The specific error kind
    pub kind: ParseErrorKind,

    /// Primary location of the error
    pub location: SourceLocation,

    /// Optional span end for range errors
    pub span_end: Option<(usize, usize)>,

    /// The source code snippet around the error
    pub source_context: SourceContext,

    /// Computed suggestions based on error kind
    pub suggestions: Vec<Suggestion>,

    /// Related locations (e.g., where a brace was opened)
    pub related: Vec<RelatedInfo>,

    /// Error severity
    pub severity: ErrorSeverity,

    /// Error code for documentation lookup
    pub code: ErrorCode,
}

impl StructuredParseError {
    pub fn new(kind: ParseErrorKind, location: SourceLocation) -> Self {
        Self {
            kind,
            location,
            span_end: None,
            source_context: SourceContext::default(),
            suggestions: Vec::new(),
            related: Vec::new(),
            severity: ErrorSeverity::Error,
            code: ErrorCode::E0001,
        }
    }

    pub fn with_span_end(mut self, line: usize, col: usize) -> Self {
        self.span_end = Some((line, col));
        self
    }

    pub fn with_source_context(mut self, ctx: SourceContext) -> Self {
        self.source_context = ctx;
        self
    }

    pub fn with_suggestion(mut self, suggestion: Suggestion) -> Self {
        self.suggestions.push(suggestion);
        self
    }

    pub fn with_suggestions(mut self, suggestions: impl IntoIterator<Item = Suggestion>) -> Self {
        self.suggestions.extend(suggestions);
        self
    }

    pub fn with_related(mut self, info: RelatedInfo) -> Self {
        self.related.push(info);
        self
    }

    pub fn with_severity(mut self, severity: ErrorSeverity) -> Self {
        self.severity = severity;
        self
    }

    pub fn with_code(mut self, code: ErrorCode) -> Self {
        self.code = code;
        self
    }
}

impl std::fmt::Display for StructuredParseError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        // Simple display - detailed rendering is done by ErrorRenderer
        write!(f, "{}", format_error_message(&self.kind))
    }
}

impl std::error::Error for StructuredParseError {}