rust/crates/ra_lsp_server/src/req.rs

209 lines
5.4 KiB
Rust
Raw Normal View History

2019-12-21 14:27:38 -06:00
//! Defines `rust-analyzer` specific custom messages.
2019-01-14 04:55:56 -06:00
use lsp_types::{Location, Position, Range, TextDocumentIdentifier, Url};
use rustc_hash::FxHashMap;
use serde::{Deserialize, Serialize};
2018-08-10 13:13:39 -05:00
2019-01-14 04:55:56 -06:00
pub use lsp_types::{
notification::*, request::*, ApplyWorkspaceEditParams, CodeActionParams, CodeLens,
CodeLensParams, CompletionParams, CompletionResponse, DiagnosticTag,
DidChangeConfigurationParams, DidChangeWatchedFilesParams,
DidChangeWatchedFilesRegistrationOptions, DocumentOnTypeFormattingParams, DocumentSymbolParams,
DocumentSymbolResponse, FileSystemWatcher, Hover, InitializeResult, MessageType,
PartialResultParams, ProgressParams, ProgressParamsValue, ProgressToken,
PublishDiagnosticsParams, ReferenceParams, Registration, RegistrationParams, SelectionRange,
SelectionRangeParams, ServerCapabilities, ShowMessageParams, SignatureHelp, SymbolKind,
TextDocumentEdit, TextDocumentPositionParams, TextEdit, WorkDoneProgressParams, WorkspaceEdit,
WorkspaceSymbolParams,
2018-08-10 13:13:39 -05:00
};
2018-08-10 07:07:43 -05:00
2019-01-22 15:15:03 -06:00
pub enum AnalyzerStatus {}
impl Request for AnalyzerStatus {
type Params = ();
type Result = String;
2019-01-28 05:43:07 -06:00
const METHOD: &'static str = "rust-analyzer/analyzerStatus";
2019-01-22 15:15:03 -06:00
}
2019-01-25 10:11:58 -06:00
pub enum CollectGarbage {}
impl Request for CollectGarbage {
type Params = ();
type Result = ();
2019-01-28 05:43:07 -06:00
const METHOD: &'static str = "rust-analyzer/collectGarbage";
2019-01-25 10:11:58 -06:00
}
2018-08-10 07:07:43 -05:00
pub enum SyntaxTree {}
impl Request for SyntaxTree {
type Params = SyntaxTreeParams;
type Result = String;
2019-01-28 05:43:07 -06:00
const METHOD: &'static str = "rust-analyzer/syntaxTree";
2018-08-10 07:07:43 -05:00
}
#[derive(Deserialize, Debug)]
2018-08-10 13:13:39 -05:00
#[serde(rename_all = "camelCase")]
2018-08-10 07:07:43 -05:00
pub struct SyntaxTreeParams {
pub text_document: TextDocumentIdentifier,
pub range: Option<Range>,
2018-08-10 07:07:43 -05:00
}
2018-08-10 13:13:39 -05:00
2019-11-19 08:56:48 -06:00
#[derive(Serialize, Debug)]
#[serde(rename_all = "camelCase")]
pub struct ExpandedMacro {
pub name: String,
pub expansion: String,
}
2019-11-17 12:47:50 -06:00
pub enum ExpandMacro {}
impl Request for ExpandMacro {
type Params = ExpandMacroParams;
2019-11-19 08:56:48 -06:00
type Result = Option<ExpandedMacro>;
2019-11-17 12:47:50 -06:00
const METHOD: &'static str = "rust-analyzer/expandMacro";
}
#[derive(Deserialize, Debug)]
#[serde(rename_all = "camelCase")]
pub struct ExpandMacroParams {
pub text_document: TextDocumentIdentifier,
pub position: Option<Position>,
}
2018-08-15 16:23:22 -05:00
pub enum FindMatchingBrace {}
impl Request for FindMatchingBrace {
type Params = FindMatchingBraceParams;
type Result = Vec<Position>;
2019-01-28 05:43:07 -06:00
const METHOD: &'static str = "rust-analyzer/findMatchingBrace";
2018-08-15 16:23:22 -05:00
}
#[derive(Deserialize, Debug)]
#[serde(rename_all = "camelCase")]
pub struct FindMatchingBraceParams {
pub text_document: TextDocumentIdentifier,
pub offsets: Vec<Position>,
}
2018-08-27 16:20:59 -05:00
pub enum DecorationsRequest {}
impl Request for DecorationsRequest {
type Params = TextDocumentIdentifier;
type Result = Vec<Decoration>;
2019-01-28 05:43:07 -06:00
const METHOD: &'static str = "rust-analyzer/decorationsRequest";
2018-08-27 16:20:59 -05:00
}
2018-08-10 16:55:32 -05:00
pub enum PublishDecorations {}
impl Notification for PublishDecorations {
type Params = PublishDecorationsParams;
2019-01-28 05:43:07 -06:00
const METHOD: &'static str = "rust-analyzer/publishDecorations";
2018-08-10 16:55:32 -05:00
}
#[derive(Serialize, Debug)]
#[serde(rename_all = "camelCase")]
pub struct PublishDecorationsParams {
pub uri: Url,
pub decorations: Vec<Decoration>,
}
#[derive(Serialize, Debug)]
#[serde(rename_all = "camelCase")]
pub struct Decoration {
pub range: Range,
pub tag: &'static str,
2019-05-26 08:39:57 -05:00
pub binding_hash: Option<String>,
2018-08-10 16:55:32 -05:00
}
2018-08-16 05:46:31 -05:00
2018-08-22 02:18:58 -05:00
pub enum ParentModule {}
impl Request for ParentModule {
type Params = TextDocumentPositionParams;
2018-08-22 02:18:58 -05:00
type Result = Vec<Location>;
2019-01-28 05:43:07 -06:00
const METHOD: &'static str = "rust-analyzer/parentModule";
2018-08-22 02:18:58 -05:00
}
2018-08-23 14:14:51 -05:00
pub enum JoinLines {}
impl Request for JoinLines {
type Params = JoinLinesParams;
2018-08-29 10:03:14 -05:00
type Result = SourceChange;
2019-01-28 05:43:07 -06:00
const METHOD: &'static str = "rust-analyzer/joinLines";
2018-08-23 14:14:51 -05:00
}
#[derive(Deserialize, Debug)]
#[serde(rename_all = "camelCase")]
pub struct JoinLinesParams {
pub text_document: TextDocumentIdentifier,
pub range: Range,
}
2018-08-27 14:03:19 -05:00
pub enum OnEnter {}
impl Request for OnEnter {
type Params = TextDocumentPositionParams;
type Result = Option<SourceChange>;
2019-01-28 05:43:07 -06:00
const METHOD: &'static str = "rust-analyzer/onEnter";
}
2018-08-27 14:03:19 -05:00
pub enum Runnables {}
impl Request for Runnables {
type Params = RunnablesParams;
type Result = Vec<Runnable>;
2019-01-28 05:43:07 -06:00
const METHOD: &'static str = "rust-analyzer/runnables";
2018-08-27 14:03:19 -05:00
}
2018-09-01 12:21:11 -05:00
#[derive(Serialize, Deserialize, Debug)]
2018-08-27 14:03:19 -05:00
#[serde(rename_all = "camelCase")]
pub struct RunnablesParams {
pub text_document: TextDocumentIdentifier,
pub position: Option<Position>,
}
#[derive(Serialize, Debug)]
#[serde(rename_all = "camelCase")]
pub struct Runnable {
pub range: Range,
pub label: String,
pub bin: String,
pub args: Vec<String>,
pub env: FxHashMap<String, String>,
pub cwd: Option<String>,
2018-08-27 14:03:19 -05:00
}
2018-08-29 10:03:14 -05:00
#[derive(Serialize, Debug)]
#[serde(rename_all = "camelCase")]
pub struct SourceChange {
pub label: String,
pub workspace_edit: WorkspaceEdit,
2018-08-29 10:03:14 -05:00
pub cursor_position: Option<TextDocumentPositionParams>,
}
2019-07-22 13:52:47 -05:00
pub enum InlayHints {}
impl Request for InlayHints {
type Params = InlayHintsParams;
type Result = Vec<InlayHint>;
const METHOD: &'static str = "rust-analyzer/inlayHints";
}
#[derive(Serialize, Deserialize, Debug)]
#[serde(rename_all = "camelCase")]
pub struct InlayHintsParams {
pub text_document: TextDocumentIdentifier,
}
#[derive(Debug, PartialEq, Eq, Deserialize, Serialize)]
pub enum InlayKind {
2019-08-04 16:28:36 -05:00
TypeHint,
ParameterHint,
2019-07-22 13:52:47 -05:00
}
#[derive(Debug, Deserialize, Serialize)]
pub struct InlayHint {
pub range: Range,
pub kind: InlayKind,
pub label: String,
}