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
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145

use std::fmt::Display;

use crate::{
    syntax::lexer::token::{Kw, NumLit, Sym, TokenKind},
    util::data::bitset::BitSet,
};

/// "Token type"
/// Aka.: a TokenKind, but with with data unnecessary for parsing stripped.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Tt {
    /// Keywords
    Kw(Kw),
    /// Identifiers
    Ident,
    /// System identifiers ('$foo')
    SysIdent,
    /// Symbols
    Sym(Sym),
    /// Numeric literals
    Num(NumLit),
    /// String literals
    Str,
    /// End-of-File sentinel, parser internal
    Eof,
}

impl Tt {
    pub fn from_kind(kind: &TokenKind) -> Option<Tt> {
        match kind {
            TokenKind::Kw(kw) => Some(Tt::Kw(*kw)),
            TokenKind::Ident(_) => Some(Tt::Ident),
            TokenKind::SysIdent(_) => Some(Tt::SysIdent),
            TokenKind::Sym(sym) => Some(Tt::Sym(*sym)),
            TokenKind::Num(num_lit) => Some(Tt::Num(*num_lit)),
            TokenKind::Str(_) => Some(Tt::Str),
            TokenKind::Comment => None,
            TokenKind::Error => None,
        }
    }
}

impl Display for Tt {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Tt::Kw(kw) => write!(f, "keyword '{kw}'"),
            Tt::Ident => write!(f, "identifier"),
            Tt::SysIdent => write!(f, "system identifier"),
            Tt::Sym(sym) => write!(f, "symbol '{sym}'"),
            Tt::Num(_) => write!(f, "number"),
            Tt::Str => write!(f, "string"),
            Tt::Eof => write!(f, "end-of-file"),
        }
    }
}

impl From<Kw> for Tt {
    fn from(value: Kw) -> Self {
        Tt::Kw(value)
    }
}

impl From<Sym> for Tt {
    fn from(value: Sym) -> Self {
        Tt::Sym(value)
    }
}

impl From<NumLit> for Tt {
    fn from(value: NumLit) -> Self {
        Tt::Num(value)
    }
}

#[derive(Debug, Clone, Copy)]
pub struct TtSet {
    set: BitSet<3>,
}

impl Default for TtSet {
    fn default() -> Self {
        Self::new()
    }
}

impl TtSet {
    pub const fn new() -> Self {
        Self { set: BitSet::new() }
    }

    pub const fn inherit(mut self, other: TtSet) -> Self {
        self.set.union(other.set);
        self
    }

    pub const fn ty_idx(ty: Tt) -> usize {
        match ty {
            Tt::Ident => 0,
            Tt::SysIdent => 1,
            Tt::Str => 2,
            Tt::Eof => 3,
            Tt::Num(NumLit::Int) => 4,
            Tt::Num(NumLit::Real) => 5,
            Tt::Num(NumLit::Repeated) => 6,
            Tt::Num(NumLit::Mixed) => 7,
            Tt::Kw(kw) => 8 + kw as usize,
            Tt::Sym(sym) => 8 + Kw::__Last as usize + sym as usize,
        }
    }

    pub const fn add(&mut self, ty: Tt) {
        self.set.add(Self::ty_idx(ty));
    }

    pub const fn contains(&self, ty: Tt) -> bool {
        self.set.contains(Self::ty_idx(ty))
    }

    pub const fn tys(mut self, tys: &[Tt]) -> Self {
        let mut i = 0;
        while i < tys.len() {
            self.add(tys[i]);
            i += 1;
        }
        self
    }

    pub const fn kws(mut self, kws: &[Kw]) -> Self {
        let mut i = 0;
        while i < kws.len() {
            self.add(Tt::Kw(kws[i]));
            i += 1;
        }
        self
    }

    pub const fn syms(mut self, syms: &[Sym]) -> Self {
        let mut i = 0;
        while i < syms.len() {
            self.add(Tt::Sym(syms[i]));
            i += 1;
        }
        self
    }
}