gluon_language-server 0.9.2

Language server providing completion for gluon
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

use gluon::RootedThread;

use jsonrpc_core::IoHandler;

use languageserver_types::{
    ParameterInformation, SignatureHelp, SignatureInformation, TextDocumentPositionParams,
};

use super::*;

use completion;

pub fn register(io: &mut IoHandler, thread: &RootedThread) {
    let thread = thread.clone();

    io.add_async_method(
        request!("textDocument/signatureHelp"),
        move |params: TextDocumentPositionParams| -> Result<_, _> {
            retrieve_expr(&thread, &params.text_document.uri, |module| {
                let expr = &module.expr;

                let source = &module.source;
                let byte_pos = position_to_byte_index(&source, &params.position)?;

                let env = thread.get_env();

                Ok(
                    completion::signature_help(&*env, module.source.span(), expr, byte_pos).map(
                        |help| {
                            let (_, metadata_map) = gluon::check::metadata::metadata(&*env, expr);
                            let comment = if help.name.is_empty() {
                                None
                            } else {
                                completion::suggest_metadata(
                                    &metadata_map,
                                    &*env,
                                    module.source.span(),
                                    expr,
                                    byte_pos,
                                    &help.name,
                                )
                                .and_then(|metadata| metadata.comment.clone())
                            };

                            SignatureHelp {
                                signatures: vec![SignatureInformation {
                                    label: help.name,
                                    documentation: Some(make_documentation(
                                        Some(&help.typ),
                                        &comment.as_ref().map_or("", |c| &c.content),
                                    )),
                                    parameters: Some(
                                        ::gluon::base::types::arg_iter(&help.typ)
                                            .map(|typ| ParameterInformation {
                                                label: "".to_string(),
                                                documentation: Some(make_documentation(
                                                    Some(typ),
                                                    "",
                                                )),
                                            })
                                            .collect(),
                                    ),
                                }],
                                active_signature: None,
                                active_parameter: help.index.map(u64::from),
                            }
                        },
                    ),
                )
            })
        },
    );
}