dts-lsp 0.1.2

Language Server for Device Tree Source files
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

use crate::utils::convert_range;
use crate::utils::Symbol;
use crate::FileDepot;
use std::collections::HashMap;
use std::collections::HashSet;
use tokio::sync::Mutex;
use tower_lsp::lsp_types::Range;
use tower_lsp::lsp_types::*;
use tower_lsp::Client;

#[derive(Eq, Hash, PartialEq)]
struct Label {
    uri: Url,
    name: String,
}

struct Data {
    label_to_symbol: HashMap<Label, Range>,
    fd: FileDepot,
    client: Client,
}

impl Data {
    fn new(client: &Client, fd: &FileDepot) -> Data {
        Data {
            label_to_symbol: HashMap::new(),
            client: client.clone(),
            fd: fd.clone(),
        }
    }
    async fn add_label(&mut self, label: &str, uri: &Url, range: tree_sitter::Range) {
        self.label_to_symbol.insert(
            Label {
                uri: uri.clone(),
                name: label.to_string(),
            },
            convert_range(&range),
        );
    }

    async fn find_label(&self, uri: &Url, label: &str) -> Option<Symbol> {
        let mut visited = HashSet::new();
        let mut to_visit = Vec::new();

        to_visit.push(uri.clone());

        while let Some(uri) = to_visit.pop() {
            self.client
                .log_message(MessageType::INFO, &format!("processing {}", uri))
                .await;

            if let Some(range) = self.label_to_symbol.get(&Label {
                name: label.to_string(),
                uri: uri.clone(),
            }) {
                let s = Symbol::new(uri, *range);
                return Some(s);
            }

            if let Some(x) = self.fd.get_neighbours(&uri).await {
                for f in x.lock().await.iter() {
                    if !visited.contains(f) {
                        to_visit.push(f.clone())
                    }
                }
            }

            visited.insert(uri);
        }

        None
    }
}

pub struct LabelsDepot {
    data: Mutex<Data>,
    client: Client,
}

impl LabelsDepot {
    pub fn new(client: Client, fd: FileDepot) -> LabelsDepot {
        LabelsDepot {
            data: Mutex::new(Data::new(&client, &fd)),
            client,
        }
    }

    pub async fn add_label(&self, label: &str, uri: &Url, range: tree_sitter::Range) {
        let mut data = self.data.lock().await;
        data.add_label(label, uri, range).await;
    }

    pub async fn find_label(&self, uri: &Url, label: &str) -> Option<Symbol> {
        let data = self.data.lock().await;
        data.find_label(uri, label).await
    }

    pub async fn dump(&self) {
        let data = self.data.lock().await;
        self.client
            .log_message(MessageType::INFO, "====== (labels) ======")
            .await;
        for k in data.label_to_symbol.keys() {
            self.client
                .log_message(MessageType::INFO, &format!("url: {}: {}", k.uri, k.name))
                .await;
        }
        self.client
            .log_message(MessageType::INFO, "======================")
            .await;
    }
}