sipha 3.0.0

PEG parser, syntax trees, and code generation
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

//! LSP (Language Server Protocol) conversion helpers.
//!
//! Enable the `lsp` feature to use this module. This feature depends on `utf16`
//! because LSP `Position.character` is defined in UTF-16 code units.

use super::parsed_doc::ParsedDoc;
use crate::diagnostics::error::{Diagnostic, SemanticDiagnostic, Severity};
use crate::parse::engine::ParseError;
use crate::types::{Pos, Span};

pub use lsp_types::{Diagnostic as LspDiagnostic, DiagnosticSeverity, Position, Range};

/// Convert a byte offset to an LSP `Position` (0-based line, UTF-16 character).
#[must_use]
pub fn byte_offset_to_position(doc: &ParsedDoc, offset: Pos) -> Position {
    let (line, character) = doc.offset_to_line_col_utf16(offset);
    Position { line, character }
}

/// Convert a byte span to an LSP `Range` using UTF-16 character offsets.
#[must_use]
pub fn span_to_range(doc: &ParsedDoc, span: Span) -> Range {
    let start = byte_offset_to_position(doc, span.start);
    let end = byte_offset_to_position(doc, span.end);
    Range { start, end }
}

/// Convert an LSP `Position` to a byte offset.
///
/// Returns `None` if the position is out of bounds for the document.
#[must_use]
pub fn position_to_byte_offset(doc: &ParsedDoc, pos: Position) -> Option<Pos> {
    doc.line_index()
        .line_col_utf16_to_byte(doc.source_str(), pos.line, pos.character)
}

const fn severity_to_lsp(sev: Severity) -> DiagnosticSeverity {
    match sev {
        Severity::Error => DiagnosticSeverity::ERROR,
        Severity::Warning => DiagnosticSeverity::WARNING,
        Severity::Deprecation => DiagnosticSeverity::HINT,
        Severity::Note => DiagnosticSeverity::INFORMATION,
    }
}

/// Convert a parse `Diagnostic` (furthest/expected) into an LSP diagnostic.
///
/// The range is derived from `diag.primary_span(source_len)`.
#[must_use]
pub fn parse_diagnostic_to_lsp(doc: &ParsedDoc, diag: &Diagnostic) -> LspDiagnostic {
    let primary = diag.primary_span(doc.source().len());
    LspDiagnostic {
        range: span_to_range(doc, primary),
        severity: Some(DiagnosticSeverity::ERROR),
        code: None,
        code_description: None,
        source: Some("sipha".to_string()),
        message: diag.message(None, None),
        related_information: None,
        tags: None,
        data: None,
    }
}

/// Convert a semantic diagnostic into an LSP diagnostic.
#[must_use]
pub fn semantic_diagnostic_to_lsp(doc: &ParsedDoc, diag: &SemanticDiagnostic) -> LspDiagnostic {
    LspDiagnostic {
        range: span_to_range(doc, diag.span),
        severity: Some(severity_to_lsp(diag.severity)),
        code: diag.code.clone().map(lsp_types::NumberOrString::String),
        code_description: None,
        source: Some("sipha".to_string()),
        message: diag.message.clone(),
        related_information: None,
        tags: None,
        data: None,
    }
}

/// Convert a `ParseError` into an LSP diagnostic when possible.
///
/// Returns `None` for non-parse failures (`BadGraph`, `UnknownRuleName`), since those
/// are typically configuration/infra errors rather than source diagnostics.
#[must_use]
pub fn parse_error_to_lsp(doc: &ParsedDoc, err: &ParseError) -> Option<LspDiagnostic> {
    match err {
        ParseError::NoMatch(d) => Some(parse_diagnostic_to_lsp(doc, d)),
        ParseError::BadGraph(_) | ParseError::UnknownRuleName(_) => None,
    }
}