cairo-language-server 2.19.0-rc.2

The Cairo Language 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
106
107
108
109
110
111
112
113
114
115
116

use std::collections::HashMap;

use cairo_lang_diagnostics::{
    DiagnosticEntry, Diagnostics, PluginFileDiagnosticNotes, Severity, UserLocationWithPluginNotes,
};
use cairo_lang_filesystem::ids::{FileId, SpanInFile};
use lsp_types::{
    Diagnostic, DiagnosticRelatedInformation, DiagnosticSeverity, Location, NumberOrString, Range,
    Url,
};
use salsa::Database;
use tracing::{error, trace};

use crate::lang::lsp::{LsProtoGroup, ToLsp};

/// Converts internal diagnostics to LSP format.
pub fn map_cairo_diagnostics_to_lsp<'db, T>(
    db: &'db dyn Database,
    diags: &mut HashMap<(Url, FileId<'db>), Vec<Diagnostic>>,
    diagnostics: &Diagnostics<'db, T>,
    trace_macro_diagnostics: bool,
    plugin_file_notes: &PluginFileDiagnosticNotes<'db>,
) where
    T: DiagnosticEntry<'db> + salsa::Update,
{
    for diagnostic in if trace_macro_diagnostics {
        diagnostics.get_all()
    } else {
        diagnostics.get_diagnostics_without_duplicates(db)
    } {
        let mut message = diagnostic.format(db);
        let span_in_file = diagnostic.location(db);
        let (_, parent_file_notes) =
            span_in_file.user_location_with_plugin_notes(db.as_dyn_database(), plugin_file_notes);
        let mut related_information = vec![];
        for note in diagnostic.notes(db).iter().chain(&parent_file_notes) {
            if let Some(location) = &note.location {
                let Some((range, file_id)) = get_mapped_range_and_add_mapping_note(
                    db.as_dyn_database(),
                    location,
                    trace_macro_diagnostics.then_some(&mut related_information),
                    "Next note mapped from here.",
                ) else {
                    continue;
                };
                let Some(uri) = db.url_for_file(file_id) else {
                    trace!("url for file not found: {:?}", file_id.long(db));
                    continue;
                };
                related_information.push(DiagnosticRelatedInformation {
                    location: Location { uri, range },
                    message: note.text.clone(),
                });
            } else {
                message += &format!("\nnote: {}", note.text);
            }
        }

        let Some((range, mapped_file_id)) = get_mapped_range_and_add_mapping_note(
            db.as_dyn_database(),
            &diagnostic.location(db),
            trace_macro_diagnostics.then_some(&mut related_information),
            "Diagnostic mapped from here.",
        ) else {
            continue;
        };

        let diagnostic = Diagnostic {
            range,
            message,
            related_information: (!related_information.is_empty()).then_some(related_information),
            severity: Some(match diagnostic.severity() {
                Severity::Error => DiagnosticSeverity::ERROR,
                Severity::Warning => DiagnosticSeverity::WARNING,
            }),
            code: diagnostic.error_code().map(|code| NumberOrString::String(code.to_string())),
            ..Diagnostic::default()
        };
        let Some(mapped_file_url) = db.url_for_file(mapped_file_id) else {
            continue;
        };

        diags.entry((mapped_file_url, mapped_file_id)).or_default().push(diagnostic);
    }
}

/// Returns the mapped range of a location, optionally adds a note about the mapping of the
/// location.
fn get_mapped_range_and_add_mapping_note<'db>(
    db: &'db dyn Database,
    orig: &SpanInFile<'db>,
    related_info: Option<&mut Vec<DiagnosticRelatedInformation>>,
    message: &str,
) -> Option<(Range, FileId<'db>)> {
    let mapped = orig.user_location(db);
    let mapped_range = get_lsp_range(db, &mapped)?;
    if let Some(related_info) = related_info
        && *orig != mapped
        && let Some(range) = get_lsp_range(db, orig)
    {
        related_info.push(DiagnosticRelatedInformation {
            location: Location { uri: db.url_for_file(orig.file_id)?, range },
            message: message.to_string(),
        });
    }
    Some((mapped_range, mapped.file_id))
}

/// Converts an internal diagnostic location to an LSP range.
fn get_lsp_range<'db>(db: &'db dyn Database, location: &SpanInFile<'db>) -> Option<Range> {
    let Some(span) = location.span.position_in_file(db, location.file_id) else {
        error!("failed to get range for diagnostic");
        return None;
    };
    Some(span.to_lsp())
}