lmntal-language-server 0.2.0

A language server for LMNtal.
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

use lmntalc_ide::{
    Diagnostic as IdeDiagnostic, DiagnosticSeverity as IdeSeverity, DiagnosticStage as IdeStage,
    Pos, Source, Span,
};
use tower_lsp_server::ls_types::{
    Diagnostic, DiagnosticRelatedInformation, DiagnosticSeverity, Location, Position, Range, Uri,
};

pub fn to_lsp_diagnostics(
    source: &Source,
    uri: &Uri,
    diagnostics: &[IdeDiagnostic],
) -> Vec<Diagnostic> {
    diagnostics
        .iter()
        .map(|diagnostic| Diagnostic {
            range: diagnostic
                .primary_span
                .map(range_from_span)
                .unwrap_or_else(|| range_from_span(Span::default())),
            severity: Some(severity(diagnostic.severity)),
            source: Some(format!("lmntalc::{}", stage_name(diagnostic.stage))),
            message: format!("{}: {}", source.name(), diagnostic.message),
            related_information: if diagnostic.related_spans.is_empty() {
                None
            } else {
                Some(
                    diagnostic
                        .related_spans
                        .iter()
                        .map(|related| DiagnosticRelatedInformation {
                            location: Location {
                                uri: uri.clone(),
                                range: range_from_span(related.span),
                            },
                            message: related.message.clone(),
                        })
                        .collect(),
                )
            },
            ..Default::default()
        })
        .collect()
}

pub(crate) fn range_from_span(span: Span) -> Range {
    Range {
        start: position(span.low()),
        end: position(span.high()),
    }
}

fn position(pos: Pos) -> Position {
    Position {
        line: pos.line,
        character: pos.column,
    }
}

fn severity(severity: IdeSeverity) -> DiagnosticSeverity {
    match severity {
        IdeSeverity::Advice => DiagnosticSeverity::HINT,
        IdeSeverity::Warning => DiagnosticSeverity::WARNING,
        IdeSeverity::Error => DiagnosticSeverity::ERROR,
    }
}

fn stage_name(stage: IdeStage) -> &'static str {
    match stage {
        IdeStage::Lexing => "lexing",
        IdeStage::Parsing => "parsing",
        IdeStage::Semantics => "semantics",
        IdeStage::Lowering => "lowering",
        IdeStage::Backend => "backend",
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use lmntalc_ide::{DiagnosticStage, RelatedSpan};

    #[test]
    fn converts_diagnostics_with_stage_and_related_information() {
        let source = Source::from_string("a :-".to_string());
        let diagnostics = vec![IdeDiagnostic {
            stage: DiagnosticStage::Parsing,
            severity: IdeSeverity::Error,
            message: "Unexpected end of file".to_string(),
            primary_span: Some(Span::new(Pos::new(2, 0, 2), Pos::new(4, 0, 4))),
            related_spans: vec![RelatedSpan {
                span: Span::new(Pos::new(0, 0, 0), Pos::new(1, 0, 1)),
                message: "Rule starts here".to_string(),
            }],
        }];

        let converted = to_lsp_diagnostics(
            &source,
            &"file:///test.lmn".parse().expect("uri should parse"),
            &diagnostics,
        );
        assert_eq!(converted.len(), 1);
        assert_eq!(converted[0].severity, Some(DiagnosticSeverity::ERROR));
        assert_eq!(converted[0].source.as_deref(), Some("lmntalc::parsing"));
        assert!(converted[0].related_information.is_some());
    }
}