merman-analysis 0.8.0-alpha.3

Diagnostics-first analysis contracts and source mapping for Merman.
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
117
118
119
120
121
122
123
124
125
126
127
128

use crate::rules::{
    RESOURCE_LIMIT_RULE_ID, internal_rule_registry_gap_diagnostic, rule_descriptor,
};
use crate::{AnalysisDiagnostic, AnalysisResult, AnalysisStatus, SourceDescriptor, SourceMap};

pub(crate) fn source_limit_result(
    source: &str,
    descriptor: SourceDescriptor,
    max_source_bytes: Option<usize>,
) -> Option<AnalysisResult> {
    let diagnostics = source_limit_diagnostics(source, max_source_bytes)?;
    Some(AnalysisResult::new(
        descriptor,
        SourceMap::new(""),
        diagnostics,
        Vec::new(),
    ))
}

pub(crate) fn source_limit_diagnostics(
    source: &str,
    max_source_bytes: Option<usize>,
) -> Option<Vec<AnalysisDiagnostic>> {
    let limit = max_source_bytes?;
    if source.len() <= limit {
        return None;
    }

    Some(vec![source_limit_diagnostic(source, limit)])
}

fn source_limit_diagnostic(source: &str, limit: usize) -> AnalysisDiagnostic {
    let span = crate::source_map::whole_text_span_without_source_copy(source);
    source_limit_diagnostic_for_len_and_span(source.len(), limit, span)
}

pub fn source_limit_diagnostic_for_len(source_len: usize, limit: usize) -> AnalysisDiagnostic {
    let span = crate::DiagnosticSpan::new(
        0,
        0,
        1,
        1,
        1,
        1,
        crate::Utf16Position {
            line: 0,
            character: 0,
        },
        crate::Utf16Position {
            line: 0,
            character: 0,
        },
    );
    source_limit_diagnostic_for_len_and_span(source_len, limit, span)
}

pub fn source_discarded_after_limit_change_diagnostic(
    source_len: usize,
    previous_limit: usize,
) -> AnalysisDiagnostic {
    let span = crate::DiagnosticSpan::new(
        0,
        0,
        1,
        1,
        1,
        1,
        crate::Utf16Position {
            line: 0,
            character: 0,
        },
        crate::Utf16Position {
            line: 0,
            character: 0,
        },
    );
    let message = format!(
        "source is {source_len} bytes and was discarded after exceeding previous max_source_bytes {previous_limit}; reopen the document or send a full document replacement to analyze it with the current limit"
    );
    let Some(descriptor) = rule_descriptor(RESOURCE_LIMIT_RULE_ID) else {
        return internal_rule_registry_gap_diagnostic(
            format!(
                "unknown analysis rule id `{RESOURCE_LIMIT_RULE_ID}` while emitting diagnostic: {message}"
            ),
            Some(span),
        );
    };

    AnalysisDiagnostic::new(
        descriptor.id,
        descriptor.default_severity,
        descriptor.category,
        message,
    )
    .with_code(
        AnalysisStatus::ResourceLimitExceeded.code(),
        AnalysisStatus::ResourceLimitExceeded.code_name(),
    )
    .with_span(span)
}

fn source_limit_diagnostic_for_len_and_span(
    source_len: usize,
    limit: usize,
    span: crate::DiagnosticSpan,
) -> AnalysisDiagnostic {
    let message = format!("source is {source_len} bytes, exceeding max_source_bytes {limit}");
    let Some(descriptor) = rule_descriptor(RESOURCE_LIMIT_RULE_ID) else {
        return internal_rule_registry_gap_diagnostic(
            format!(
                "unknown analysis rule id `{RESOURCE_LIMIT_RULE_ID}` while emitting diagnostic: {message}"
            ),
            Some(span),
        );
    };

    AnalysisDiagnostic::new(
        descriptor.id,
        descriptor.default_severity,
        descriptor.category,
        message,
    )
    .with_code(
        AnalysisStatus::ResourceLimitExceeded.code(),
        AnalysisStatus::ResourceLimitExceeded.code_name(),
    )
    .with_span(span)
}