wat_service 0.8.0

WebAssembly Text Format language service.
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

use crate::{LanguageService, helpers, uri::InternUri};
use line_index::LineIndex;
use lspt::{
    CodeAction, CodeActionContext, CodeActionKind, Diagnostic, TextEdit, Union2, WorkspaceEdit,
};
use rowan::{Direction, TextRange};
use rustc_hash::FxBuildHasher;
use std::collections::HashMap;
use wat_syntax::{SyntaxElement, SyntaxKind, SyntaxNode};

pub fn act(
    service: &LanguageService,
    uri: InternUri,
    line_index: &LineIndex,
    node: &SyntaxNode,
    context: &CodeActionContext,
) -> Option<Vec<CodeAction>> {
    let node_lsp_range = helpers::rowan_range_to_lsp_range(line_index, node.text_range());
    let diagnostic = context
        .diagnostics
        .iter()
        .find(|diagnostic| match &diagnostic.code {
            Some(Union2::B(code)) => code == "packing" && diagnostic.range == node_lsp_range,
            _ => false,
        })?;
    let instr_name =
        node.siblings_with_tokens(Direction::Prev)
            .find_map(|element| match element {
                SyntaxElement::Token(token) if token.kind() == SyntaxKind::INSTR_NAME => {
                    Some(token)
                }
                _ => None,
            })?;

    let range = instr_name.text_range();
    match instr_name.text() {
        "struct.get" => Some(
            ["struct.get_s", "struct.get_u"]
                .iter()
                .map(|new_text| build_action(new_text, range, diagnostic, service, uri, line_index))
                .collect(),
        ),
        "struct.get_s" | "struct.get_u" => Some(vec![build_action(
            "struct.get",
            range,
            diagnostic,
            service,
            uri,
            line_index,
        )]),
        "array.get" => Some(
            ["array.get_s", "array.get_u"]
                .iter()
                .map(|new_text| build_action(new_text, range, diagnostic, service, uri, line_index))
                .collect(),
        ),
        "array.get_s" | "array.get_u" => Some(vec![build_action(
            "array.get",
            range,
            diagnostic,
            service,
            uri,
            line_index,
        )]),
        _ => None,
    }
}

fn build_action(
    new_text: &str,
    range: TextRange,
    diagnostic: &Diagnostic,
    service: &LanguageService,
    uri: InternUri,
    line_index: &LineIndex,
) -> CodeAction {
    let text_edits = vec![TextEdit {
        range: helpers::rowan_range_to_lsp_range(line_index, range),
        new_text: new_text.into(),
    }];
    let mut changes = HashMap::with_capacity_and_hasher(1, FxBuildHasher);
    changes.insert(uri.raw(service), text_edits);
    CodeAction {
        title: format!("Replace instruction with `{new_text}`"),
        kind: Some(CodeActionKind::QuickFix),
        edit: Some(WorkspaceEdit {
            changes: Some(changes),
            ..Default::default()
        }),
        is_preferred: Some(true),
        diagnostics: Some(vec![diagnostic.clone()]),
        ..Default::default()
    }
}