wat_service 0.10.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
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
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188

use crate::{
    LanguageService,
    binder::{SymbolKind, SymbolTable},
    deprecation,
    helpers::LineIndexExt,
    types_analyzer,
};
use lspt::{
    CallHierarchyIncomingCall, CallHierarchyIncomingCallsParams, CallHierarchyItem, CallHierarchyOutgoingCall,
    CallHierarchyOutgoingCallsParams, CallHierarchyPrepareParams, SymbolKind as LspSymbolKind, SymbolTag,
};

impl LanguageService {
    /// Handler for `textDocument/prepareCallHierarchy` request.
    pub fn prepare_call_hierarchy(&self, params: CallHierarchyPrepareParams) -> Option<Vec<CallHierarchyItem>> {
        let document = self.get_document(&params.text_document.uri)?;
        let line_index = document.line_index(self);
        let root = document.root_tree(self);
        let symbol_table = SymbolTable::of(self, document);
        let deprecation = deprecation::get_deprecation(self, document);

        let token = super::find_meaningful_token(self, document, &root, params.position)?;
        let parent_range = token.parent().text_range();

        symbol_table.symbols.values().find_map(|symbol| match symbol.kind {
            SymbolKind::Func if symbol.key.text_range() == parent_range => Some(vec![CallHierarchyItem {
                name: symbol.idx.render(self).to_string(),
                kind: LspSymbolKind::Function,
                tags: if deprecation.contains_key(&symbol.key) {
                    Some(vec![SymbolTag::Deprecated])
                } else {
                    None
                },
                detail: Some(types_analyzer::render_func_header(
                    self,
                    symbol.idx.name,
                    types_analyzer::get_func_sig(self, document, symbol.key, &symbol.green),
                )),
                uri: params.text_document.uri.clone(),
                range: line_index.convert(symbol.key.text_range()),
                selection_range: line_index.convert(
                    symbol_table
                        .def_poi
                        .get(&symbol.key)
                        .copied()
                        .unwrap_or_else(|| symbol.key.text_range()),
                ),
                data: None,
            }]),
            SymbolKind::Call if symbol.key.text_range() == parent_range => {
                symbol_table.find_def(symbol.key).map(|symbol| {
                    vec![CallHierarchyItem {
                        name: symbol.idx.render(self).to_string(),
                        kind: LspSymbolKind::Function,
                        tags: if deprecation.contains_key(&symbol.key) {
                            Some(vec![SymbolTag::Deprecated])
                        } else {
                            None
                        },
                        detail: Some(types_analyzer::render_func_header(
                            self,
                            symbol.idx.name,
                            types_analyzer::get_func_sig(self, document, symbol.key, &symbol.green),
                        )),
                        uri: params.text_document.uri.clone(),
                        range: line_index.convert(symbol.key.text_range()),
                        selection_range: line_index.convert(
                            symbol_table
                                .def_poi
                                .get(&symbol.key)
                                .copied()
                                .unwrap_or_else(|| symbol.key.text_range()),
                        ),
                        data: None,
                    }]
                })
            }
            _ => None,
        })
    }

    /// Handler for `callHierarchy/incomingCalls` request.
    pub fn call_hierarchy_incoming_calls(
        &self,
        params: CallHierarchyIncomingCallsParams,
    ) -> Option<Vec<CallHierarchyIncomingCall>> {
        let document = self.get_document(&params.item.uri)?;
        let line_index = document.line_index(self);
        let symbol_table = SymbolTable::of(self, document);
        let deprecation = deprecation::get_deprecation(self, document);
        let callee_def_range = line_index.convert(params.item.range)?;
        let mut items = symbol_table
            .resolved
            .iter()
            .filter_map(|(ref_key, def_key)| {
                if def_key.text_range() == callee_def_range {
                    Some(ref_key)
                } else {
                    None
                }
            })
            .filter_map(|call_key| {
                symbol_table
                    .symbols
                    .values()
                    .find(|symbol| {
                        symbol.kind == SymbolKind::Func && symbol.key.text_range().contains_range(call_key.text_range())
                    })
                    .map(|symbol| CallHierarchyIncomingCall {
                        from: CallHierarchyItem {
                            name: symbol.idx.render(self).to_string(),
                            kind: LspSymbolKind::Function,
                            tags: if deprecation.contains_key(&symbol.key) {
                                Some(vec![SymbolTag::Deprecated])
                            } else {
                                None
                            },
                            detail: Some(types_analyzer::render_func_header(
                                self,
                                symbol.idx.name,
                                types_analyzer::get_func_sig(self, document, symbol.key, &symbol.green),
                            )),
                            uri: params.item.uri.clone(),
                            range: line_index.convert(symbol.key.text_range()),
                            selection_range: line_index.convert(
                                symbol_table
                                    .def_poi
                                    .get(&symbol.key)
                                    .copied()
                                    .unwrap_or_else(|| symbol.key.text_range()),
                            ),
                            data: None,
                        },
                        from_ranges: vec![line_index.convert(call_key.text_range())],
                    })
            })
            .collect::<Vec<_>>();
        items.sort_unstable_by_key(|item| item.from.range.start);
        Some(items)
    }

    /// Handler for `callHierarchy/outgoingCalls` request.
    pub fn call_hierarchy_outgoing_calls(
        &self,
        params: CallHierarchyOutgoingCallsParams,
    ) -> Option<Vec<CallHierarchyOutgoingCall>> {
        let document = self.get_document(&params.item.uri)?;
        let line_index = document.line_index(self);
        let symbol_table = SymbolTable::of(self, document);
        let deprecation = deprecation::get_deprecation(self, document);
        let call_def_range = line_index.convert(params.item.range)?;
        let mut items = symbol_table
            .symbols
            .values()
            .filter(|symbol| symbol.kind == SymbolKind::Call && call_def_range.contains_range(symbol.key.text_range()))
            .filter_map(|symbol| symbol_table.find_def(symbol.key).map(|def_symbol| (def_symbol, symbol)))
            .map(|(def_symbol, ref_symbol)| CallHierarchyOutgoingCall {
                to: CallHierarchyItem {
                    name: def_symbol.idx.render(self).to_string(),
                    kind: LspSymbolKind::Function,
                    tags: if deprecation.contains_key(&def_symbol.key) {
                        Some(vec![SymbolTag::Deprecated])
                    } else {
                        None
                    },
                    detail: Some(types_analyzer::render_func_header(
                        self,
                        def_symbol.idx.name,
                        types_analyzer::get_func_sig(self, document, def_symbol.key, &def_symbol.green),
                    )),
                    uri: params.item.uri.clone(),
                    range: line_index.convert(def_symbol.key.text_range()),
                    selection_range: line_index.convert(
                        symbol_table
                            .def_poi
                            .get(&def_symbol.key)
                            .copied()
                            .unwrap_or_else(|| def_symbol.key.text_range()),
                    ),
                    data: None,
                },
                from_ranges: vec![line_index.convert(ref_symbol.key.text_range())],
            })
            .collect::<Vec<_>>();
        items.sort_unstable_by_key(|item| item.to.range.start);
        Some(items)
    }
}