gluon_language-server 0.2.0

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


extern crate gluon_language_server;
extern crate languageserver_types;

extern crate jsonrpc_core;
extern crate serde_json;
extern crate serde;

mod support;

use std::io::Write;

use languageserver_types::{Hover, MarkedString, Position, TextDocumentPositionParams,
                           TextDocumentIdentifier};

fn hover<W: ?Sized>(stdin: &mut W, id: u64, uri: &str, position: Position)
    where W: Write,
{
    let hover = support::method_call("textDocument/hover",
                                     id,
                                     TextDocumentPositionParams {
                                         text_document: TextDocumentIdentifier { uri: uri.into() },
                                         position: position,
                                     });

    support::write_message(stdin, hover).unwrap();
}

const STREAM_SOURCE: &'static str = r#"
let prelude = import "std/prelude.glu"
and { Option, Num } = prelude
and { (+) } = prelude.num_Int

type Stream_ a =
    | Value a (Stream a)
    | Empty
and Stream a = Lazy (Stream_ a)

let from f : (Int -> Option a) -> Stream a =
        let from_ i =
                lazy (\_ ->
                    match f i with
                        | Some x -> Value x (from_ (i + 1))
                        | None -> Empty
                )
        in from_ 0

{ from }
"#;

#[test]
fn simple_hover() {
    let hover: Hover = support::send_rpc(|mut stdin| {

        support::did_open(stdin, "test", "123");

        hover(stdin,
              2,
              "test",
              Position {
                  line: 0,
                  character: 2,
              });
    });

    assert_eq!(hover,
               Hover {
                   contents: vec![MarkedString::String("Int".into())],
                   range: None,
               });
}

#[test]
fn identifier() {
    let hover: Hover = support::send_rpc(|mut stdin| {
        let src = r#"
let test = 1
test 
"#;
        support::did_open(stdin, "test", src);

        hover(stdin,
              2,
              "test",
              Position {
                  line: 2,
                  character: 2,
              });
    });

    assert_eq!(hover,
               Hover {
                   contents: vec![MarkedString::String("Int".into())],
                   range: None,
               });
}

#[test]
fn stream() {
    let hover: Hover = support::send_rpc(|mut stdin| {

        support::did_open(stdin, "stream", STREAM_SOURCE);

        hover(stdin,
              2,
              "stream",
              Position {
                  line: 13,
                  character: 29,
              });
    });

    assert_eq!(hover,
               Hover {
                   contents: vec![MarkedString::String("Int".into())],
                   range: None,
               });
}