sync-lsp 0.1.0

A synchronous LSP library for servers
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

use log::Level;

use crate::window::MessageType;
use crate::{Connection, TypeProvider, Server};
use super::jsonrpc::{RpcConnection, Callback, RpcError, MessageID, RpcResolver};

pub(crate) struct Endpoint<T: TypeProvider, O: Clone + Default> {
    callback: Callback<Server<T>>,
    options: O,
    static_registration: bool
}

impl<T: TypeProvider> RpcResolver for Server<T> {
    type Connection = Connection<T>;

    fn connection(&mut self) -> &mut Self::Connection {
        &mut self.connection
    }

    fn resolve(&self, method: &str) -> Option<Callback<Self>> {
        self.lifecycle.resolve(method)
            .or(self.window.resolve(method))
            .or(self.text_document.resolve(method))
            .or(self.workspace.resolve(method))
    }
}

impl<T: TypeProvider> RpcConnection for Connection<T> {
    fn transport(&mut self) -> &mut crate::Transport {
        &mut self.transport
    }

    fn take_error(&mut self) -> Option<RpcError> {
        self.error.take()
    }

    fn log(&mut self, level: Level, message: String) {
        let r#type = match level {
            Level::Error => MessageType::Error,
            Level::Warn => MessageType::Warning,
            Level::Info => MessageType::Info,
            Level::Debug => MessageType::Log,
            Level::Trace => MessageType::Log
        };

        self.log_message(r#type, message)
    }

    fn set_current_request(&mut self, id: Option<MessageID>) {
        self.current_request = id;
    }
}

impl<T: TypeProvider, O: Clone + Default> Endpoint<T, O> {
    pub(crate) fn new(callback: Callback<Server<T>>,) -> Self {
        Endpoint {
            callback,
            options: O::default(),
            #[cfg(feature = "dynamic-callbacks")]
            static_registration: true,
            #[cfg(not(feature = "dynamic-callbacks"))]
            static_registration: false
        }
    }

    pub(super) fn static_registration(&self) -> bool {
        self.static_registration
    }

    pub(crate) fn options_mut(&mut self) -> &mut O {
        &mut self.options
    }

    pub(crate) fn set_callback(&mut self, callback: Callback<Server<T>>) {
        self.static_registration = true;
        self.callback = callback;
    }

    pub(crate) fn callback(&self) -> Callback<Server<T>> {
        self.callback.clone()
    }

    pub(crate) fn options(&self) -> O {
        self.options.clone()
    }
}