laburnum 1.17.1

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

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

mod ariadne_diagnostics;
mod db_stats;
mod query_records;
mod query_source_cache;
mod query_source_keys;

use {
  crate::{
    Partitions,
    TRACER,
    protocol::{
      lsp::LanguageServer,
      task::RpcTask,
    },
    scheduler::task::TaskContext,
  },
  otel::span,
  serde_json::Value,
};

#[cfg(feature = "testing-commands")]
use crate::protocol::jsonrpc;

async fn handle_custom_command<P: Partitions, T: LanguageServer<P>>(
  command: &str,
  arguments: &[Value],
  ctx: &mut TaskContext<P, T>,
) -> jsonrpc::Result<Option<Value>> {
  match command {
    | "laburnum/dbStats" => db_stats::handle_db_stats(arguments, ctx).await,
    | "laburnum/querySourceCache" => {
      query_source_cache::handle_query_source_cache(arguments, ctx).await
    },
    | "laburnum/queryRecords" => {
      query_records::handle_query_records(arguments, ctx).await
    },
    | "laburnum/querySourceKeys" => {
      query_source_keys::handle_query_source_keys(arguments, ctx).await
    },
    | "laburnum/ariadneDiagnostics" => {
      ariadne_diagnostics::handle_ariadne_diagnostics(arguments, ctx).await
    },
    | _ => Err(jsonrpc::Error::method_not_found()),
  }
}

impl<P: Partitions, T: LanguageServer<P>> RpcTask<P, T> {
  #[cfg(feature = "testing-commands")]
  pub(super) fn try_handle_laburnum_command(
    &mut self,
    method: &str,
    params: &serde_json::Value,
    request_id: jsonrpc::Id,
  ) -> bool {
    use crate::scheduler::lanes::SYNC_LANE;

    if method != "workspace/executeCommand" {
      return false;
    }

    let command = match params.get("command").and_then(|v| v.as_str()) {
      | Some(cmd) if cmd.starts_with("laburnum/") => cmd.to_string(),
      | _ => return false,
    };

    let arguments = params
      .get("arguments")
      .and_then(|v| v.as_array())
      .cloned()
      .unwrap_or_default();

    let cx = span!(
      ^ @TRACER,
      "laburnum.commands.try_handle",
      "command" = command.clone(),
      "method" = method.to_string(),
      "request_id" = request_id.to_string()
    );

    let tx = self.response_tx.clone();
    let request_id_clone = request_id.clone();

    self.ctx.spawn_task(
      move |mut ctx| -> _ {
        use opentelemetry::trace::FutureExt;

        async move {
          let result =
            handle_custom_command(&command, &arguments, &mut ctx).await;

          let response = match result {
            | Ok(value) => {
              jsonrpc::Response::from_ok(
                request_id_clone.clone(),
                value.unwrap_or(serde_json::Value::Null),
              )
            },
            | Err(error) => {
              jsonrpc::Response::from_error(request_id_clone.clone(), error)
            },
          };

          if let Err(_e) = tx.send(response).await {}

          None
        }
        .with_context(cx)
      },
      SYNC_LANE,
    );

    true
  }
}