harper-ls 0.8.8

The language checker for developers.
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

use std::collections::HashMap;

use harper_core::{Lint, Suggestion};
use tower_lsp::lsp_types::{
    CodeAction,
    CodeActionKind,
    CodeActionOrCommand,
    Command,
    Diagnostic,
    TextEdit,
    Url,
    WorkspaceEdit
};

use crate::config::{CodeActionConfig, DiagnosticSeverity};
use crate::pos_conv::span_to_range;

pub fn lints_to_diagnostics(
    source: &[char],
    lints: &[Lint],
    severity: DiagnosticSeverity
) -> Vec<Diagnostic> {
    lints
        .iter()
        .map(|lint| lint_to_diagnostic(lint, source, severity))
        .collect()
}

pub fn lint_to_code_actions<'a>(
    lint: &'a Lint,
    url: &'a Url,
    source: &'a [char],
    config: &CodeActionConfig
) -> Vec<CodeActionOrCommand> {
    let mut results = Vec::new();

    results.extend(
        lint.suggestions
            .iter()
            .flat_map(|suggestion| {
                let range = span_to_range(source, lint.span);

                let replace_string = match suggestion {
                    Suggestion::ReplaceWith(with) => with.iter().collect(),
                    Suggestion::Remove => "".to_string()
                };

                Some(CodeAction {
                    title: suggestion.to_string(),
                    kind: Some(CodeActionKind::QUICKFIX),
                    diagnostics: None,
                    edit: Some(WorkspaceEdit {
                        changes: Some(HashMap::from([(
                            url.clone(),
                            vec![TextEdit {
                                range,
                                new_text: replace_string
                            }]
                        )])),
                        document_changes: None,
                        change_annotations: None
                    }),
                    command: None,
                    is_preferred: None,
                    disabled: None,
                    data: None
                })
            })
            .map(CodeActionOrCommand::CodeAction)
    );

    if lint.lint_kind.is_spelling() {
        let orig = lint.span.get_content_string(source);

        results.push(CodeActionOrCommand::Command(Command::new(
            format!("Add \"{}\" to the global dictionary.", orig),
            "HarperAddToUserDict".to_string(),
            Some(vec![orig.clone().into(), url.to_string().into()])
        )));

        results.push(CodeActionOrCommand::Command(Command::new(
            format!("Add \"{}\" to the file dictionary.", orig),
            "HarperAddToFileDict".to_string(),
            Some(vec![orig.into(), url.to_string().into()])
        )));

        if config.force_stable {
            results.reverse();
        }
    }

    results
}

fn lint_to_diagnostic(lint: &Lint, source: &[char], severity: DiagnosticSeverity) -> Diagnostic {
    let range = span_to_range(source, lint.span);

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