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

use lsp_types::{FoldingRange, StaticTextDocumentColorProviderOptions};

use crate::{
    lsp::{error::LspResult, server::Server},
    project::syntax::Syntax,
    syntax::{cst::kind::TreeKind, location::Span},
};

pub fn folding_range_capabilities() -> lsp_types::FoldingRangeProviderCapability {
    // lsp_types::FoldingRangeProviderCapability::Simple(true)
    lsp_types::FoldingRangeProviderCapability::Options(StaticTextDocumentColorProviderOptions {
        document_selector: Some(vec![lsp_types::DocumentFilter {
            language: Some("bsv".into()),
            scheme: None,
            pattern: None,
        }]),
        id: Some("blues-lsp".into()),
    })
}

pub fn folding_range(
    server: &mut Server,
    params: lsp_types::FoldingRangeParams,
) -> LspResult<Option<Vec<lsp_types::FoldingRange>>> {
    let pkg = server.uri_to_pkg(&params.text_document.uri)?;
    let proj = &server.proj;

    let syntax = proj.syntax.get(proj, pkg);

    let ranges = folding_spans(&syntax)
        .map(|s| {
            let range = s.to_lsp(&syntax.ctx.origins);

            FoldingRange {
                start_line: range.start.line,
                start_character: None,
                // start_character: Some(range.start.character),
                end_line: range.end.line,
                end_character: None,
                // end_character: Some(range.end.character),
                kind: None,
                collapsed_text: None,
            }
        })
        .collect();

    Ok(Some(ranges))
}

fn folding_spans(syntax: &Syntax) -> impl Iterator<Item = Span> {
    syntax.cst.iter().filter_map(|n| {
        use TreeKind::*;
        match n.open_kind()? {
            StmtModule
            | StmtMethod
            | StmtFunction
            | StmtInterface
            | StmtTypedef
            | StmtInstance
            | StmtTypeclass
            | StmtImport
            | StmtExport
            | StmtRule
            | StmtAction
            | StmtActionvalue
            | StmtBlock
            | StmtSeq
            | StmtPar
            | StmtBvi
            | StmtBdpi
            | BviInterface
            | Case
            | StmtSubinterface
            | InterfaceItemMethod
            | InterfaceItemSubinterface
            | InstanceModule
            | InstanceFunction
            | TypeclassModule
            | TypeclassFunction
            | ExprAction
            | ExprActionvalue
            | ExprRules
            | ExprBlock
            | ExprInterface
            | ExprModule
            | ExprStructInit
            | ExprSeq
            | ExprPar => n.span(&syntax.ctx.origins),
            _ => None,
        }
    })
}