wat_service 0.1.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

use crate::{files::FilesCtx, helpers, InternUri, LanguageService};
use line_index::LineIndex;
use lsp_types::{CodeAction, CodeActionKind, TextEdit, WorkspaceEdit};
use rowan::TextRange;
use std::collections::HashMap;
use wat_syntax::{SyntaxKind, SyntaxNode};

pub fn act(
    service: &LanguageService,
    uri: InternUri,
    line_index: &LineIndex,
    node: &SyntaxNode,
    range: TextRange,
) -> Option<CodeAction> {
    let params = node
        .children()
        .skip_while(|child| !is_joinable_param(child, range))
        .take_while(|child| is_joinable_param(child, range))
        .collect::<Vec<_>>();
    let [first_node, ..] = &params[..] else {
        return None;
    };
    let types = params
        .iter()
        .flat_map(|param| {
            param
                .children()
                .filter(|child| child.kind() == SyntaxKind::VAL_TYPE)
        })
        .collect::<Vec<_>>();
    let [first, rest @ ..] = &types[..] else {
        return None;
    };
    if rest.is_empty() {
        return None;
    }

    let mut new_text = rest
        .iter()
        .fold(format!("(param {first}"), |mut new_text, ty| {
            new_text.push(' ');
            new_text.push_str(&ty.to_string());
            new_text
        });
    new_text.push(')');

    #[expect(clippy::mutable_key_type)]
    let mut changes = HashMap::with_capacity(1);
    changes.insert(
        service.lookup_uri(uri),
        vec![TextEdit {
            range: helpers::rowan_range_to_lsp_range(
                line_index,
                TextRange::new(
                    first_node.text_range().start(),
                    params.last().unwrap_or(first_node).text_range().end(),
                ),
            ),
            new_text,
        }],
    );
    Some(CodeAction {
        title: "Join parameters".into(),
        kind: Some(CodeActionKind::REFACTOR_REWRITE),
        edit: Some(WorkspaceEdit {
            changes: Some(changes),
            ..Default::default()
        }),
        ..Default::default()
    })
}

fn is_joinable_param(node: &SyntaxNode, range: TextRange) -> bool {
    node.kind() == SyntaxKind::PARAM
        && range.contains_range(node.text_range())
        && !node
            .children_with_tokens()
            .any(|it| it.kind() == SyntaxKind::IDENT)
}