mortar_lsp 0.4.0

Mortar language LSP server
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

use mortar_compiler::{
    Diagnostic as CompilerDiagnostic, DiagnosticCollector, Language, ParseHandler, Severity,
};
use tower_lsp_server::lsp_types::{Diagnostic, DiagnosticSeverity, Position, Range};

/// Convert compiler diagnostics to LSP diagnostics
pub fn convert_diagnostics_to_lsp(
    content: &str,
    diagnostics: &[CompilerDiagnostic],
) -> Vec<Diagnostic> {
    diagnostics
        .iter()
        .map(|diag| convert_single_diagnostic(content, diag))
        .collect()
}

/// Convert a single compiler diagnostic to LSP diagnostic
fn convert_single_diagnostic(content: &str, diag: &CompilerDiagnostic) -> Diagnostic {
    let severity = match diag.severity {
        Severity::Error => Some(DiagnosticSeverity::ERROR),
        Severity::Warning => Some(DiagnosticSeverity::WARNING),
    };

    let range = if let Some((start, end)) = diag.span {
        byte_span_to_lsp_range(content, start, end)
    } else {
        Range::new(Position::new(0, 0), Position::new(0, 0))
    };

    Diagnostic {
        range,
        severity,
        code: None,
        code_description: None,
        source: Some("mortar".to_string()),
        message: diag.message.clone(),
        related_information: None,
        tags: None,
        data: None,
    }
}

/// Convert byte positions to LSP Range
fn byte_span_to_lsp_range(content: &str, start: usize, end: usize) -> Range {
    let start_pos = byte_offset_to_position(content, start);
    let end_pos = byte_offset_to_position(content, end);
    Range::new(start_pos, end_pos)
}

/// Convert byte offset to LSP Position
fn byte_offset_to_position(content: &str, offset: usize) -> Position {
    let mut line = 0u32;
    let mut character = 0u32;
    let mut current_offset = 0;

    for ch in content.chars() {
        if current_offset >= offset {
            break;
        }

        if ch == '\n' {
            line += 1;
            character = 0;
        } else {
            character += 1;
        }

        current_offset += ch.len_utf8();
    }

    Position::new(line, character)
}

/// Parse content and get diagnostics with language support
pub fn parse_with_diagnostics(
    content: &str,
    file_name: String,
    language: Language,
) -> (Vec<Diagnostic>, Option<mortar_compiler::Program>) {
    let (parse_result, diagnostics) = ParseHandler::parse_source_code_with_diagnostics_and_language(
        content, file_name, false, // verbose_lexer
        language,
    );

    let mut lsp_diagnostics = convert_diagnostics_to_lsp(content, diagnostics.get_diagnostics());

    // Analyze the program if parsing succeeded
    let program = if let Ok(ref program) = parse_result {
        // Create a new diagnostics collector for analysis
        let mut analysis_diagnostics =
            DiagnosticCollector::new_with_language("analysis".to_string(), language);
        analysis_diagnostics.analyze_program(program);

        // Add analysis diagnostics to the result
        let analysis_lsp_diagnostics =
            convert_diagnostics_to_lsp(content, analysis_diagnostics.get_diagnostics());
        lsp_diagnostics.extend(analysis_lsp_diagnostics);

        Some(program.clone())
    } else {
        None
    };

    (lsp_diagnostics, program)
}