laburnum 1.17.0

An LSP framework for building language servers and compilers, powered by an incremental query tree with content-addressed storage, task-based dataflow, and parallel queries.
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

// Copyright Two Neutron Stars Incorporated and contributors
// SPDX-License-Identifier: BlueOak-1.0.0

//! `goto_definition`, `goto_declaration`, `goto_type_definition`,
//! `goto_implementation`.

use crate::{
  connect::lsp::{
    LspClient,
    request::{
      GotoDeclaration,
      GotoDefinition,
      GotoImplementation,
      GotoTypeDefinition,
    },
  },
  connect::mcp::{
    schema,
    tool::{
      Tool,
      ToolError,
      ToolRegistry,
    },
  },
  protocol::lsp::{
    GotoDefinitionParams,
    GotoDefinitionResponse,
  },
};

pub fn register(registry: &mut ToolRegistry) {
  registry.register::<GotoDefinitionTool>();
  registry.register::<GotoDeclarationTool>();
  registry.register::<GotoTypeDefinitionTool>();
  registry.register::<GotoImplementationTool>();
}

pub enum GotoDefinitionTool {}

impl Tool for GotoDefinitionTool {
  type Input = GotoDefinitionParams;
  type Output = Option<GotoDefinitionResponse>;

  const NAME: &'static str = "goto_definition";
  const DESCRIPTION: &'static str =
    "Find the source location where the symbol at the given position is \
     defined. Wraps LSP `textDocument/definition`.";

  fn input_schema() -> serde_json::Value {
    schema::text_document_position()
  }

  async fn call(
    client: &LspClient,
    input: Self::Input,
  ) -> Result<Self::Output, ToolError> {
    Ok(client.send_request::<GotoDefinition>(input).await?)
  }
}

pub enum GotoDeclarationTool {}

impl Tool for GotoDeclarationTool {
  type Input = GotoDefinitionParams;
  type Output = Option<GotoDefinitionResponse>;

  const NAME: &'static str = "goto_declaration";
  const DESCRIPTION: &'static str =
    "Find the source location of the declaration (which may differ from the \
     definition in languages with split declarations) of the symbol at the \
     given position. Wraps LSP `textDocument/declaration`.";

  fn input_schema() -> serde_json::Value {
    schema::text_document_position()
  }

  async fn call(
    client: &LspClient,
    input: Self::Input,
  ) -> Result<Self::Output, ToolError> {
    Ok(client.send_request::<GotoDeclaration>(input).await?)
  }
}

pub enum GotoTypeDefinitionTool {}

impl Tool for GotoTypeDefinitionTool {
  type Input = GotoDefinitionParams;
  type Output = Option<GotoDefinitionResponse>;

  const NAME: &'static str = "goto_type_definition";
  const DESCRIPTION: &'static str =
    "Find the source location where the type of the symbol at the given \
     position is defined. Wraps LSP `textDocument/typeDefinition`.";

  fn input_schema() -> serde_json::Value {
    schema::text_document_position()
  }

  async fn call(
    client: &LspClient,
    input: Self::Input,
  ) -> Result<Self::Output, ToolError> {
    Ok(client.send_request::<GotoTypeDefinition>(input).await?)
  }
}

pub enum GotoImplementationTool {}

impl Tool for GotoImplementationTool {
  type Input = GotoDefinitionParams;
  type Output = Option<GotoDefinitionResponse>;

  const NAME: &'static str = "goto_implementation";
  const DESCRIPTION: &'static str =
    "Find source locations that implement the symbol at the given position \
     (e.g. concrete impls of a trait/interface). Wraps LSP \
     `textDocument/implementation`.";

  fn input_schema() -> serde_json::Value {
    schema::text_document_position()
  }

  async fn call(
    client: &LspClient,
    input: Self::Input,
  ) -> Result<Self::Output, ToolError> {
    Ok(client.send_request::<GotoImplementation>(input).await?)
  }
}