blues-lsp 0.1.0

LSP language server for the Bluespec SystemVerilog language
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

use std::{
    any,
    collections::{HashMap, HashSet},
    fmt::Debug,
    hash::Hash,
    sync::Arc,
};

use parking_lot::Mutex;
use tracing::warn;

use super::Project;

pub trait Queryable: Sized {
    type Input: Debug + Hash + Eq + Clone;
    type Backref: Debug + Hash + Eq + Clone;
    type Ctx: Default;

    fn compute(input: Self::Input, ctx: &Self::Ctx, proj: &Project) -> Arc<Self>;

    fn invalidate_backref(&self, backref: Self::Backref, proj: &Project);
    fn invalidate(&self, input: &Self::Input, ctx: &Self::Ctx, proj: &Project);
}

struct QuerryEntry<Q: Queryable> {
    data: Arc<Q>,
    backrefs: HashSet<Q::Backref>,
}
pub struct Querry<Q: Queryable> {
    cache: Mutex<HashMap<Q::Input, QuerryEntry<Q>>>,
    ctx: Q::Ctx,
}

impl<Q: Queryable> Querry<Q> {
    pub fn new() -> Self {
        Self {
            cache: Mutex::new(HashMap::new()),
            ctx: Default::default(),
        }
    }

    fn get_inner(&self, proj: &Project, i: Q::Input, backref: Option<Q::Backref>) -> Arc<Q> {
        if let Some(entry) = self.cache.lock().get_mut(&i) {
            backref.map(|b| entry.backrefs.insert(b));
            return entry.data.clone();
        }

        let computed = Q::compute(i.clone(), &self.ctx, proj);

        // Multiple threads may race to compute the same querry,
        // this is necessary to prevent deadlocks in situations where, eg.:
        // - Computing A requires querrying B
        // - Computing B requires querrying A
        // Here we let the first result win as otherwise we might
        // keep Arc's with duplicate data alive.
        let mut cache = self.cache.lock();
        let entry = cache.entry(i).or_insert_with(|| QuerryEntry {
            data: computed,
            backrefs: HashSet::new(),
        });

        backref.map(|b| entry.backrefs.insert(b));

        entry.data.clone()
    }

    pub fn get(&self, proj: &Project, i: Q::Input) -> Arc<Q> {
        self.get_inner(proj, i, None)
    }

    pub fn get_as(&self, proj: &Project, i: Q::Input, backref: Q::Backref) -> Arc<Q> {
        self.get_inner(proj, i, Some(backref))
    }

    pub fn invalidate(&self, proj: &Project, input: &Q::Input) {
        let cached = self.cache.lock().remove(input);
        if let Some(mut entry) = cached {
            entry
                .backrefs
                .into_iter()
                .for_each(|b| entry.data.invalidate_backref(b, proj));
            entry.data.invalidate(input, &self.ctx, proj);
            if Arc::get_mut(&mut entry.data).is_none() {
                warn!(
                    "Querry '{}' with input '{:?}' still has references after invalidation: {:?}",
                    any::type_name::<Q>(),
                    input,
                    (
                        Arc::strong_count(&entry.data) - 1,
                        Arc::weak_count(&entry.data)
                    )
                )
            }
        }
    }

    pub fn clear(&self, proj: &Project) {
        for i in self.cache.lock().keys() {
            self.invalidate(proj, i);
        }
    }
}

impl<Q: Queryable> Default for Querry<Q> {
    fn default() -> Self {
        Self::new()
    }
}