lspf 0.9.1

A Rust framework for building extensible LSP language servers
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

//! Rename server for a small `type`/`fn` language.

mod example_support;

use std::collections::HashMap;
use std::sync::Arc;

use lspf::types::{
    PrepareRenameResponse, RenameOptions, RenameParams, TextDocumentPositionParams, TextEdit,
    WorkspaceEdit,
};
use lspf::{CancellationToken, LspError, Server, ServerContext};

struct State;

fn renameable(text: &str, word: &str) -> bool {
    text.lines().any(|line| {
        ["type ", "fn "].into_iter().any(|prefix| {
            line.strip_prefix(prefix)
                .and_then(|rest| rest.split(['(', ' ', '=']).next())
                == Some(word)
        })
    })
}

async fn prepare(
    _: Arc<State>,
    ctx: ServerContext,
    params: TextDocumentPositionParams,
    _: CancellationToken,
) -> Result<Option<PrepareRenameResponse>, LspError> {
    let text = example_support::text(&ctx, &params.text_document.uri)?;
    let Some((word, range)) = example_support::word_at(&text, params.position) else {
        return Ok(None);
    };
    Ok(
        renameable(&text, &word).then_some(PrepareRenameResponse::RangeWithPlaceholder {
            range,
            placeholder: word,
        }),
    )
}

async fn rename(
    _: Arc<State>,
    ctx: ServerContext,
    params: RenameParams,
    _: CancellationToken,
) -> Result<Option<WorkspaceEdit>, LspError> {
    let uri = params.text_document_position.text_document.uri;
    let text = example_support::text(&ctx, &uri)?;
    let Some((word, _)) = example_support::word_at(&text, params.text_document_position.position)
    else {
        return Ok(None);
    };
    if !renameable(&text, &word) {
        return Ok(None);
    }
    let edits = example_support::word_ranges(&text, &word)
        .into_iter()
        .map(|range| TextEdit {
            range,
            new_text: params.new_name.clone(),
        })
        .collect();
    Ok(Some(WorkspaceEdit {
        changes: Some(HashMap::from([(uri, edits)])),
        ..WorkspaceEdit::default()
    }))
}

#[tokio::main]
async fn main() -> lspf::Result<()> {
    let server = Server::builder(State)
        .feature(
            lspf::features::rename(RenameOptions {
                prepare_provider: None,
                work_done_progress_options: Default::default(),
            }),
            rename,
        )
        .feature(lspf::features::prepare_rename(), prepare)
        .build()
        .expect("rename registrations are valid");
    example_support::serve(server).await
}