riscv_analysis_lsp 0.1.0-alpha

RISC-V static analysis tool -- LSP helpers
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

use lsp_types::CompletionItem;

use riscv_analysis::parser::{Inst, LabelString, Register};

pub enum RVCompletionItem {
    Inst(Inst),
    Register(Register),
    Label(LabelString),
    FunctionLabel(LabelString),
}

impl From<Register> for RVCompletionItem {
    fn from(value: Register) -> Self {
        RVCompletionItem::Register(value)
    }
}

impl From<Inst> for RVCompletionItem {
    fn from(value: Inst) -> Self {
        RVCompletionItem::Inst(value)
    }
}

impl From<LabelString> for RVCompletionItem {
    fn from(value: LabelString) -> Self {
        RVCompletionItem::Label(value)
    }
}

impl From<RVCompletionItem> for CompletionItem {
    fn from(value: RVCompletionItem) -> Self {
        match value {
            RVCompletionItem::Register(r) => {
                let mut item = CompletionItem::new_simple(
                    r.to_string(),
                    format!(
                        "Register {}",
                        r.all_representations()
                            .into_iter()
                            .collect::<Vec<String>>()
                            .join(", ")
                    ),
                );
                item.kind = Some(lsp_types::CompletionItemKind::VARIABLE);
                item.filter_text = Some(
                    r.all_representations()
                        .into_iter()
                        .collect::<Vec<String>>()
                        .join(" "),
                );
                item
            }
            RVCompletionItem::Inst(i) => {
                let mut item =
                    CompletionItem::new_simple(i.to_string(), format!("Instruction {i}"));
                item.kind = Some(lsp_types::CompletionItemKind::FUNCTION);
                item
            }
            RVCompletionItem::Label(l) => {
                CompletionItem::new_simple(l.to_string(), format!("Label {l}"))
            }
            RVCompletionItem::FunctionLabel(l) => {
                CompletionItem::new_simple(l.to_string(), format!("Function {l}"))
            }
        }
    }
}

impl RVCompletionItem {
    fn get_registers() -> Vec<CompletionItem> {
        Register::all()
            .into_iter()
            .map(|r| RVCompletionItem::from(r).into())
            .collect()
    }

    fn get_instructions() -> Vec<CompletionItem> {
        Inst::all()
            .into_iter()
            .map(|i| RVCompletionItem::from(i).into())
            .collect()
    }

    pub fn get_all() -> Vec<CompletionItem> {
        let mut items = RVCompletionItem::get_registers();
        items.extend(RVCompletionItem::get_instructions());
        items
    }
}