ra_ap_rust-analyzer 0.0.340

//! rust-analyzer extensions to the LSP.

// Note when adding new resolve payloads, add a #[serde(default)] on boolean fields as some clients
// might strip `false` values from the JSON payload due to their reserialization logic turning false
// into null which will then cause them to be omitted in the resolve request. See https://github.com/rust-lang/rust-analyzer/issues/18767

#![allow(clippy::disallowed_types)]

use std::ops;

use lsp_types::{
    CodeActionKind, DocumentOnTypeFormattingParams, LspNotificationMethod, LspRequestMethod,
    MessageDirection, Notification, PartialResultParams, Position, Range, Request,
    TextDocumentIdentifier, Uri, WorkDoneProgressParams,
};
use paths::Utf8PathBuf;
use rustc_hash::FxHashMap;
use serde::{Deserialize, Serialize};

pub enum InternalTestingFetchConfigRequest {}

#[derive(Deserialize, Serialize, Debug)]
pub enum InternalTestingFetchConfigOption {
    AssistEmitMustUse,
    CheckWorkspace,
}

#[derive(Deserialize, Serialize, Debug, PartialEq, Eq)]
pub enum InternalTestingFetchConfigResponse {
    AssistEmitMustUse(bool),
    CheckWorkspace(bool),
}

impl Request for InternalTestingFetchConfigRequest {
    type Params = InternalTestingFetchConfigParams;
    // Option is solely to circumvent Default bound.
    type Result = Option<InternalTestingFetchConfigResponse>;
    const METHOD: LspRequestMethod =
        LspRequestMethod::new("rust-analyzer-internal/internalTestingFetchConfig");
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ClientToServer;
}

#[derive(Deserialize, Serialize, Debug)]
#[serde(rename_all = "camelCase")]
pub struct InternalTestingFetchConfigParams {
    pub text_document: Option<TextDocumentIdentifier>,
    pub config: InternalTestingFetchConfigOption,
}
pub enum AnalyzerStatusRequest {}

impl Request for AnalyzerStatusRequest {
    type Params = AnalyzerStatusParams;
    type Result = String;
    const METHOD: LspRequestMethod = LspRequestMethod::new("rust-analyzer/analyzerStatus");
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ClientToServer;
}

#[derive(Deserialize, Serialize, Debug)]
#[serde(rename_all = "camelCase")]
pub struct AnalyzerStatusParams {
    pub text_document: Option<TextDocumentIdentifier>,
}

#[derive(Deserialize, Serialize, Debug)]
#[serde(rename_all = "camelCase")]
pub struct CrateInfoResult {
    pub name: Option<String>,
    pub version: Option<String>,
    pub path: Uri,
}
pub enum FetchDependencyListRequest {}

impl Request for FetchDependencyListRequest {
    type Params = FetchDependencyListParams;
    type Result = FetchDependencyListResult;
    const METHOD: LspRequestMethod = LspRequestMethod::new("rust-analyzer/fetchDependencyList");
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ClientToServer;
}

#[derive(Deserialize, Serialize, Debug)]
#[serde(rename_all = "camelCase")]
pub struct FetchDependencyListParams {}

#[derive(Deserialize, Serialize, Debug, Default)]
#[serde(rename_all = "camelCase")]
pub struct FetchDependencyListResult {
    pub crates: Vec<CrateInfoResult>,
}

pub enum MemoryUsageRequest {}

impl Request for MemoryUsageRequest {
    type Params = ();
    type Result = String;
    const METHOD: LspRequestMethod = LspRequestMethod::new("rust-analyzer/memoryUsage");
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ClientToServer;
}

pub enum ReloadWorkspaceRequest {}

impl Request for ReloadWorkspaceRequest {
    type Params = ();
    type Result = ();
    const METHOD: LspRequestMethod = LspRequestMethod::new("rust-analyzer/reloadWorkspace");
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ClientToServer;
}

pub enum RebuildProcMacrosRequest {}

impl Request for RebuildProcMacrosRequest {
    type Params = ();
    type Result = ();
    const METHOD: LspRequestMethod = LspRequestMethod::new("rust-analyzer/rebuildProcMacros");
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ClientToServer;
}

pub enum ViewSyntaxTreeRequest {}

impl Request for ViewSyntaxTreeRequest {
    type Params = ViewSyntaxTreeParams;
    type Result = String;
    const METHOD: LspRequestMethod = LspRequestMethod::new("rust-analyzer/viewSyntaxTree");
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ClientToServer;
}

#[derive(Deserialize, Serialize, Debug)]
#[serde(rename_all = "camelCase")]
pub struct ViewSyntaxTreeParams {
    pub text_document: TextDocumentIdentifier,
}

pub enum ViewHirRequest {}

impl Request for ViewHirRequest {
    type Params = lsp_types::TextDocumentPositionParams;
    type Result = String;
    const METHOD: LspRequestMethod = LspRequestMethod::new("rust-analyzer/viewHir");
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ClientToServer;
}

pub enum ViewMirRequest {}

impl Request for ViewMirRequest {
    type Params = lsp_types::TextDocumentPositionParams;
    type Result = String;
    const METHOD: LspRequestMethod = LspRequestMethod::new("rust-analyzer/viewMir");
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ClientToServer;
}

pub enum InterpretFunctionRequest {}

impl Request for InterpretFunctionRequest {
    type Params = lsp_types::TextDocumentPositionParams;
    type Result = String;
    const METHOD: LspRequestMethod = LspRequestMethod::new("rust-analyzer/interpretFunction");
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ClientToServer;
}

pub enum ViewFileTextRequest {}

impl Request for ViewFileTextRequest {
    type Params = lsp_types::TextDocumentIdentifier;
    type Result = String;
    const METHOD: LspRequestMethod = LspRequestMethod::new("rust-analyzer/viewFileText");
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ClientToServer;
}

#[derive(Deserialize, Serialize, Debug)]
#[serde(rename_all = "camelCase")]
pub struct ViewCrateGraphParams {
    /// Include *all* crates, not just crates in the workspace.
    pub full: bool,
}

pub enum ViewCrateGraphRequest {}

impl Request for ViewCrateGraphRequest {
    type Params = ViewCrateGraphParams;
    type Result = String;
    const METHOD: LspRequestMethod = LspRequestMethod::new("rust-analyzer/viewCrateGraph");
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ClientToServer;
}

#[derive(Deserialize, Serialize, Debug)]
#[serde(rename_all = "camelCase")]
pub struct ViewItemTreeParams {
    pub text_document: TextDocumentIdentifier,
}

pub enum ViewItemTreeRequest {}

impl Request for ViewItemTreeRequest {
    type Params = ViewItemTreeParams;
    type Result = String;
    const METHOD: LspRequestMethod = LspRequestMethod::new("rust-analyzer/viewItemTree");
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ClientToServer;
}

#[derive(Deserialize, Serialize, Debug)]
#[serde(rename_all = "camelCase")]
pub struct DiscoverTestParams {
    pub test_id: Option<String>,
}

#[derive(Deserialize, Serialize, Debug)]
#[serde(rename_all = "camelCase")]
pub enum TestItemKind {
    Package,
    Module,
    Test,
}

#[derive(Deserialize, Serialize, Debug)]
#[serde(rename_all = "camelCase")]
pub struct TestItem {
    pub id: String,
    pub label: String,
    pub kind: TestItemKind,
    pub can_resolve_children: bool,
    pub parent: Option<String>,
    pub text_document: Option<TextDocumentIdentifier>,
    pub range: Option<Range>,
    pub runnable: Option<Runnable>,
}

#[derive(Deserialize, Serialize, Debug, Default)]
#[serde(rename_all = "camelCase")]
pub struct DiscoverTestResults {
    pub tests: Vec<TestItem>,
    pub scope: Option<Vec<String>>,
    pub scope_file: Option<Vec<TextDocumentIdentifier>>,
}

pub enum DiscoverTestRequest {}

impl Request for DiscoverTestRequest {
    type Params = DiscoverTestParams;
    type Result = DiscoverTestResults;
    const METHOD: LspRequestMethod = LspRequestMethod::new("experimental/discoverTest");
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ClientToServer;
}

pub enum DiscoveredTestsNotification {}

impl Notification for DiscoveredTestsNotification {
    type Params = DiscoverTestResults;
    const METHOD: LspNotificationMethod =
        LspNotificationMethod::new("experimental/discoveredTests");
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ClientToServer;
}

#[derive(Deserialize, Serialize, Debug)]
#[serde(rename_all = "camelCase")]
pub struct RunTestParams {
    pub include: Option<Vec<String>>,
    pub exclude: Option<Vec<String>>,
}

pub enum RunTestRequest {}

impl Request for RunTestRequest {
    type Params = RunTestParams;
    type Result = ();
    const METHOD: LspRequestMethod = LspRequestMethod::new("experimental/runTest");
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ClientToServer;
}

pub enum EndRunTestNotification {}

impl Notification for EndRunTestNotification {
    type Params = ();
    const METHOD: LspNotificationMethod = LspNotificationMethod::new("experimental/endRunTest");
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ClientToServer;
}

pub enum AppendOutputToRunTestNotification {}

impl Notification for AppendOutputToRunTestNotification {
    type Params = String;
    const METHOD: LspNotificationMethod =
        LspNotificationMethod::new("experimental/appendOutputToRunTest");
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ClientToServer;
}

pub enum AbortRunTestNotification {}

impl Notification for AbortRunTestNotification {
    type Params = ();
    const METHOD: LspNotificationMethod = LspNotificationMethod::new("experimental/abortRunTest");
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ClientToServer;
}

#[derive(Deserialize, Serialize, Debug)]
#[serde(rename_all = "camelCase", tag = "tag")]
pub enum TestState {
    Passed,
    Failed { message: String },
    Skipped,
    Started,
    Enqueued,
}

#[derive(Deserialize, Serialize, Debug)]
#[serde(rename_all = "camelCase")]
pub struct ChangeTestStateParams {
    pub test_id: String,
    pub state: TestState,
}

pub enum ChangeTestStateNotification {}

impl Notification for ChangeTestStateNotification {
    type Params = ChangeTestStateParams;
    const METHOD: LspNotificationMethod =
        LspNotificationMethod::new("experimental/changeTestState");
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ClientToServer;
}

pub enum ExpandMacroRequest {}

impl Request for ExpandMacroRequest {
    type Params = ExpandMacroParams;
    type Result = Option<ExpandedMacro>;
    const METHOD: LspRequestMethod = LspRequestMethod::new("rust-analyzer/expandMacro");
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ClientToServer;
}

#[derive(Deserialize, Serialize, Debug)]
#[serde(rename_all = "camelCase")]
pub struct ExpandMacroParams {
    pub text_document: TextDocumentIdentifier,
    pub position: Position,
}

#[derive(Deserialize, Serialize, Debug)]
#[serde(rename_all = "camelCase")]
pub struct ExpandedMacro {
    pub name: String,
    pub expansion: String,
}

pub enum ViewRecursiveMemoryLayoutRequest {}

impl Request for ViewRecursiveMemoryLayoutRequest {
    type Params = lsp_types::TextDocumentPositionParams;
    type Result = Option<RecursiveMemoryLayout>;
    const METHOD: LspRequestMethod =
        LspRequestMethod::new("rust-analyzer/viewRecursiveMemoryLayout");
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ClientToServer;
}

#[derive(Deserialize, Serialize, Debug)]
#[serde(rename_all = "camelCase")]
pub struct RecursiveMemoryLayout {
    pub nodes: Vec<MemoryLayoutNode>,
}

#[derive(Deserialize, Serialize, Debug)]
#[serde(rename_all = "camelCase")]
pub struct MemoryLayoutNode {
    pub item_name: String,
    pub typename: String,
    pub size: u64,
    pub offset: u64,
    pub alignment: u64,
    pub parent_idx: i64,
    pub children_start: i64,
    pub children_len: u64,
}

pub enum CancelFlycheckNotification {}

impl Notification for CancelFlycheckNotification {
    type Params = ();
    const METHOD: LspNotificationMethod =
        LspNotificationMethod::new("rust-analyzer/cancelFlycheck");
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ClientToServer;
}

pub enum RunFlycheckNotification {}

impl Notification for RunFlycheckNotification {
    type Params = RunFlycheckParams;
    const METHOD: LspNotificationMethod = LspNotificationMethod::new("rust-analyzer/runFlycheck");
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ClientToServer;
}

pub enum ClearFlycheckNotification {}

impl Notification for ClearFlycheckNotification {
    type Params = ();
    const METHOD: LspNotificationMethod = LspNotificationMethod::new("rust-analyzer/clearFlycheck");
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ClientToServer;
}

pub enum OpenServerLogsNotification {}

impl Notification for OpenServerLogsNotification {
    type Params = ();
    const METHOD: LspNotificationMethod =
        LspNotificationMethod::new("rust-analyzer/openServerLogs");
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ClientToServer;
}

#[derive(Deserialize, Serialize, Debug)]
#[serde(rename_all = "camelCase")]
pub struct RunFlycheckParams {
    pub text_document: Option<TextDocumentIdentifier>,
}

pub enum MatchingBraceRequest {}

impl Request for MatchingBraceRequest {
    type Params = MatchingBraceParams;
    type Result = Vec<Position>;
    const METHOD: LspRequestMethod = LspRequestMethod::new("experimental/matchingBrace");
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ClientToServer;
}

#[derive(Deserialize, Serialize, Debug)]
#[serde(rename_all = "camelCase")]
pub struct MatchingBraceParams {
    pub text_document: TextDocumentIdentifier,
    pub positions: Vec<Position>,
}

pub enum ParentModuleRequest {}

impl Request for ParentModuleRequest {
    type Params = lsp_types::TextDocumentPositionParams;
    type Result = Option<lsp_types::DefinitionResponse>;
    const METHOD: LspRequestMethod = LspRequestMethod::new("experimental/parentModule");
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ClientToServer;
}

pub enum ChildModulesRequest {}

impl Request for ChildModulesRequest {
    type Params = lsp_types::TextDocumentPositionParams;
    type Result = Option<lsp_types::DefinitionResponse>;
    const METHOD: LspRequestMethod = LspRequestMethod::new("experimental/childModules");
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ClientToServer;
}

pub enum JoinLinesRequest {}

impl Request for JoinLinesRequest {
    type Params = JoinLinesParams;
    type Result = Vec<lsp_types::TextEdit>;
    const METHOD: LspRequestMethod = LspRequestMethod::new("experimental/joinLines");
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ClientToServer;
}

#[derive(Deserialize, Serialize, Debug)]
#[serde(rename_all = "camelCase")]
pub struct JoinLinesParams {
    pub text_document: TextDocumentIdentifier,
    pub ranges: Vec<Range>,
}

pub enum OnEnterRequest {}

impl Request for OnEnterRequest {
    type Params = lsp_types::TextDocumentPositionParams;
    type Result = Option<Vec<SnippetTextEdit>>;
    const METHOD: LspRequestMethod = LspRequestMethod::new("experimental/onEnter");
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ClientToServer;
}

pub enum RunnablesRequest {}

impl Request for RunnablesRequest {
    type Params = RunnablesParams;
    type Result = Vec<Runnable>;
    const METHOD: LspRequestMethod = LspRequestMethod::new("experimental/runnables");
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ClientToServer;
}

#[derive(Serialize, Deserialize, Debug, Clone)]
#[serde(rename_all = "camelCase")]
pub struct RunnablesParams {
    pub text_document: TextDocumentIdentifier,
    pub position: Option<Position>,
}

#[derive(Deserialize, Serialize, Debug, Clone)]
#[serde(rename_all = "camelCase")]
pub struct Runnable {
    pub label: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub location: Option<lsp_types::LocationLink>,
    #[serde(flatten)]
    pub args: RunnableArgs,
}

#[derive(Deserialize, Serialize, Debug, Clone)]
#[serde(tag = "kind", content = "args", rename_all = "lowercase")]
pub enum RunnableArgs {
    Cargo(CargoRunnableArgs),
    Shell(ShellRunnableArgs),
}

#[derive(Deserialize, Serialize, Debug, Clone)]
#[serde(rename_all = "camelCase")]
pub struct CargoRunnableArgs {
    #[serde(skip_serializing_if = "FxHashMap::is_empty")]
    pub environment: FxHashMap<String, String>,
    pub cwd: Utf8PathBuf,
    /// Command to be executed instead of cargo
    pub override_cargo: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub workspace_root: Option<Utf8PathBuf>,
    // command, --package and --lib stuff
    pub cargo_args: Vec<String>,
    // stuff after --
    pub executable_args: Vec<String>,
}

#[derive(Deserialize, Serialize, Debug, Clone)]
#[serde(rename_all = "camelCase")]
pub struct ShellRunnableArgs {
    #[serde(skip_serializing_if = "FxHashMap::is_empty")]
    pub environment: FxHashMap<String, String>,
    pub cwd: Utf8PathBuf,
    pub program: String,
    pub args: Vec<String>,
}

pub enum RelatedTestsRequest {}

impl Request for RelatedTestsRequest {
    type Params = lsp_types::TextDocumentPositionParams;
    type Result = Vec<TestInfo>;
    const METHOD: LspRequestMethod = LspRequestMethod::new("rust-analyzer/relatedTests");
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ClientToServer;
}

#[derive(Debug, Deserialize, Serialize)]
pub struct TestInfo {
    pub runnable: Runnable,
}

pub enum SsrRequest {}

impl Request for SsrRequest {
    type Params = SsrParams;
    type Result = lsp_types::WorkspaceEdit;
    const METHOD: LspRequestMethod = LspRequestMethod::new("experimental/ssr");
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ClientToServer;
}

#[derive(Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct SsrParams {
    pub query: String,
    pub parse_only: bool,

    /// File position where SSR was invoked. Paths in `query` will be resolved relative to this
    /// position.
    #[serde(flatten)]
    pub position: lsp_types::TextDocumentPositionParams,

    /// Current selections. Search/replace will be restricted to these if non-empty.
    pub selections: Vec<lsp_types::Range>,
}

pub enum ServerStatusNotification {}

impl Notification for ServerStatusNotification {
    type Params = ServerStatusParams;
    const METHOD: LspNotificationMethod = LspNotificationMethod::new("experimental/serverStatus");
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ClientToServer;
}

#[derive(Deserialize, Serialize, PartialEq, Eq, Clone)]
#[serde(rename_all = "camelCase")]
pub struct ServerStatusParams {
    pub health: Health,
    pub quiescent: bool,
    pub message: Option<String>,
}

#[derive(Serialize, Deserialize, Clone, Copy, PartialEq, Eq, Debug)]
#[serde(rename_all = "camelCase")]
pub enum Health {
    Ok,
    Warning,
    Error,
}

impl ops::BitOrAssign for Health {
    fn bitor_assign(&mut self, rhs: Self) {
        *self = match (*self, rhs) {
            (Health::Error, _) | (_, Health::Error) => Health::Error,
            (Health::Warning, _) | (_, Health::Warning) => Health::Warning,
            _ => Health::Ok,
        }
    }
}

pub enum CodeActionRequest {}

impl Request for CodeActionRequest {
    type Params = lsp_types::CodeActionParams;
    type Result = Option<Vec<CodeAction>>;
    const METHOD: LspRequestMethod = LspRequestMethod::new("textDocument/codeAction");
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ClientToServer;
}

pub enum CodeActionResolveRequest {}

impl Request for CodeActionResolveRequest {
    type Params = CodeAction;
    type Result = CodeAction;
    const METHOD: LspRequestMethod = LspRequestMethod::new("codeAction/resolve");
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ClientToServer;
}

#[derive(Debug, PartialEq, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct CodeAction {
    pub title: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub group: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub kind: Option<CodeActionKind>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub command: Option<lsp_types::Command>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub edit: Option<SnippetWorkspaceEdit>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub is_preferred: Option<bool>,

    #[serde(skip_serializing_if = "Option::is_none")]
    pub data: Option<CodeActionData>,
}

#[derive(Debug, Eq, PartialEq, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct CodeActionData {
    pub code_action_params: lsp_types::CodeActionParams,
    pub id: String,
    pub version: Option<i32>,
}

#[derive(Debug, Eq, PartialEq, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct SnippetWorkspaceEdit {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub changes: Option<FxHashMap<Uri, Vec<lsp_types::TextEdit>>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub document_changes: Option<Vec<SnippetDocumentChangeOperation>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub change_annotations: Option<
        std::collections::HashMap<
            lsp_types::ChangeAnnotationIdentifier,
            lsp_types::ChangeAnnotation,
        >,
    >,
}

#[derive(Debug, Eq, PartialEq, Clone, Deserialize, Serialize)]
#[serde(untagged, rename_all = "lowercase")]
pub enum SnippetDocumentChangeOperation {
    Change(lsp_types::DocumentChange),
    Edit(SnippetTextDocumentEdit),
}

#[derive(Debug, Eq, PartialEq, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct SnippetTextDocumentEdit {
    pub text_document: lsp_types::OptionalVersionedTextDocumentIdentifier,
    pub edits: Vec<SnippetTextEdit>,
}

#[derive(Debug, Eq, PartialEq, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct SnippetTextEdit {
    pub range: Range,
    pub new_text: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub insert_text_format: Option<lsp_types::InsertTextFormat>,
    /// The annotation id if this is an annotated
    #[serde(skip_serializing_if = "Option::is_none")]
    pub annotation_id: Option<lsp_types::ChangeAnnotationIdentifier>,
}

pub enum HoverRequest {}

impl Request for HoverRequest {
    type Params = HoverParams;
    type Result = Option<Hover>;
    const METHOD: LspRequestMethod = lsp_types::HoverRequest::METHOD;
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ClientToServer;
}

#[derive(Debug, Eq, PartialEq, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct HoverParams {
    pub text_document: TextDocumentIdentifier,
    pub position: PositionOrRange,

    #[serde(flatten)]
    pub work_done_progress_params: WorkDoneProgressParams,
}

#[derive(Debug, Eq, PartialEq, Clone, Deserialize, Serialize)]
#[serde(untagged)]
pub enum PositionOrRange {
    Position(lsp_types::Position),
    Range(lsp_types::Range),
}

#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
pub struct Hover {
    #[serde(flatten)]
    pub hover: lsp_types::Hover,
    #[serde(skip_serializing_if = "Vec::is_empty")]
    pub actions: Vec<CommandLinkGroup>,
}

#[derive(Debug, PartialEq, Clone, Default, Deserialize, Serialize)]
pub struct CommandLinkGroup {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub title: Option<String>,
    pub commands: Vec<CommandLink>,
}

// LSP v3.15 Command does not have a `tooltip` field, vscode supports one.
#[derive(Debug, PartialEq, Clone, Default, Deserialize, Serialize)]
pub struct CommandLink {
    #[serde(flatten)]
    pub command: lsp_types::Command,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tooltip: Option<String>,
}

pub enum ExternalDocsRequest {}

impl Request for ExternalDocsRequest {
    type Params = lsp_types::TextDocumentPositionParams;
    type Result = ExternalDocsResponse;
    const METHOD: LspRequestMethod = LspRequestMethod::new("experimental/externalDocs");
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ClientToServer;
}

#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
#[serde(untagged)]
pub enum ExternalDocsResponse {
    Simple(Option<lsp_types::Uri>),
    WithLocal(ExternalDocsPair),
}

impl Default for ExternalDocsResponse {
    fn default() -> Self {
        ExternalDocsResponse::Simple(None)
    }
}

#[derive(Debug, Default, PartialEq, Serialize, Deserialize, Clone)]
#[serde(rename_all = "camelCase")]
pub struct ExternalDocsPair {
    pub web: Option<lsp_types::Uri>,
    pub local: Option<lsp_types::Uri>,
}

pub enum OpenCargoTomlRequest {}

impl Request for OpenCargoTomlRequest {
    type Params = OpenCargoTomlParams;
    type Result = Option<lsp_types::DefinitionResponse>;
    const METHOD: LspRequestMethod = LspRequestMethod::new("experimental/openCargoToml");
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ClientToServer;
}

#[derive(Serialize, Deserialize, Debug)]
#[serde(rename_all = "camelCase")]
pub struct OpenCargoTomlParams {
    pub text_document: TextDocumentIdentifier,
}

/// Information about CodeLens, that is to be resolved.
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct CodeLensResolveData {
    pub version: i32,
    pub kind: CodeLensResolveDataKind,
}

#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub enum CodeLensResolveDataKind {
    Impls(lsp_types::ImplementationParams),
    References(lsp_types::TextDocumentPositionParams),
}

pub enum MoveItemRequest {}

impl Request for MoveItemRequest {
    type Params = MoveItemParams;
    type Result = Vec<SnippetTextEdit>;
    const METHOD: LspRequestMethod = LspRequestMethod::new("experimental/moveItem");
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ClientToServer;
}

#[derive(Serialize, Deserialize, Debug)]
#[serde(rename_all = "camelCase")]
pub struct MoveItemParams {
    pub direction: MoveItemDirection,
    pub text_document: TextDocumentIdentifier,
    pub range: Range,
}

#[derive(Serialize, Deserialize, Debug)]
pub enum MoveItemDirection {
    Up,
    Down,
}

#[derive(Debug)]
pub enum WorkspaceSymbolRequest {}

impl Request for WorkspaceSymbolRequest {
    type Params = WorkspaceSymbolParams;
    type Result = Option<lsp_types::WorkspaceSymbolResponse>;
    const METHOD: LspRequestMethod = LspRequestMethod::new("workspace/symbol");
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ClientToServer;
}

#[derive(Debug, Eq, PartialEq, Clone, Default, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct WorkspaceSymbolParams {
    #[serde(flatten)]
    pub partial_result_params: PartialResultParams,

    #[serde(flatten)]
    pub work_done_progress_params: WorkDoneProgressParams,

    /// A non-empty query string
    pub query: String,

    pub search_scope: Option<WorkspaceSymbolSearchScope>,

    pub search_kind: Option<WorkspaceSymbolSearchKind>,
}

#[derive(Serialize, Deserialize, Debug, Clone, Eq, PartialEq)]
#[serde(rename_all = "camelCase")]
pub enum WorkspaceSymbolSearchScope {
    Workspace,
    WorkspaceAndDependencies,
}

#[derive(Serialize, Deserialize, Debug, Clone, Eq, PartialEq)]
#[serde(rename_all = "camelCase")]
pub enum WorkspaceSymbolSearchKind {
    OnlyTypes,
    AllSymbols,
}

/// The document on type formatting request is sent from the client to
/// the server to format parts of the document during typing.  This is
/// almost same as [`lsp_types::DocumentOnTypeFormattingRequest`], but the
/// result has SnippetTextEdit in it instead of TextEdit.
#[derive(Debug)]
pub enum DocumentOnTypeFormattingRequest {}

impl Request for DocumentOnTypeFormattingRequest {
    type Params = DocumentOnTypeFormattingParams;
    type Result = Option<Vec<SnippetTextEdit>>;
    const METHOD: LspRequestMethod = LspRequestMethod::new("textDocument/onTypeFormatting");
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ClientToServer;
}

#[derive(Debug, Serialize, Deserialize)]
pub struct CompletionResolveData {
    pub position: lsp_types::TextDocumentPositionParams,
    #[serde(skip_serializing_if = "Vec::is_empty", default)]
    pub imports: Vec<CompletionImport>,
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub version: Option<i32>,
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub trigger_character: Option<char>,
    #[serde(default)]
    pub for_ref: bool,
    pub hash: String,
}

#[derive(Debug, Serialize, Deserialize)]
pub struct InlayHintResolveData {
    pub file_id: u32,
    // This is a string instead of a u64 as javascript can't represent u64 fully
    pub hash: String,
    pub resolve_range: lsp_types::Range,
    #[serde(skip_serializing_if = "Option::is_none", default)]
    pub version: Option<i32>,
}

#[derive(Debug, Serialize, Deserialize)]
pub struct CompletionImport {
    pub full_import_path: String,
    #[serde(default)]
    pub as_underscore: bool,
}

#[derive(Debug, Deserialize, Default)]
pub struct ClientCommandOptions {
    pub commands: Vec<String>,
}

pub enum EvaluatePredicateRequest {}

#[derive(Deserialize, Serialize, Debug)]
#[serde(rename_all = "camelCase")]
pub struct EvaluatePredicateParams {
    pub text: String,
    pub text_document: TextDocumentIdentifier,
    pub position: Position,
}

#[derive(Deserialize, Serialize, Debug, Default)]
#[serde(rename_all = "camelCase")]
pub struct EvaluatePredicateResult {
    pub status: PredicateEvaluationStatus,
    pub message: String,
}

#[derive(Deserialize, Serialize, Debug, Default, PartialEq, Eq)]
#[serde(rename_all = "camelCase")]
pub enum PredicateEvaluationStatus {
    Holds,
    #[default]
    NotProven,
    Invalid,
    Unsupported,
}

impl Request for EvaluatePredicateRequest {
    type Params = EvaluatePredicateParams;
    type Result = EvaluatePredicateResult;
    const METHOD: LspRequestMethod = LspRequestMethod::new("rust-analyzer/evaluatePredicate");
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ClientToServer;
}

pub enum GetFailedObligationsRequest {}

#[derive(Deserialize, Serialize, Debug)]
#[serde(rename_all = "camelCase")]
pub struct GetFailedObligationsParams {
    pub text_document: TextDocumentIdentifier,
    pub position: Position,
}

impl Request for GetFailedObligationsRequest {
    type Params = GetFailedObligationsParams;
    type Result = String;
    const METHOD: LspRequestMethod = LspRequestMethod::new("rust-analyzer/getFailedObligations");
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ClientToServer;
}

#[cfg(test)]
mod tests {
    use super::*;
    use serde_json::json;

    #[test]
    fn cargo_runnable_round_trips() {
        let runnable = Runnable {
            label: "cargo test -p my-crate".to_owned(),
            location: None,
            args: RunnableArgs::Cargo(CargoRunnableArgs {
                environment: [("RUSTC_TOOLCHAIN".to_owned(), "/toolchain".to_owned())]
                    .into_iter()
                    .collect(),
                cwd: "/project".into(),
                override_cargo: None,
                workspace_root: Some("/project".into()),
                cargo_args: vec![
                    "test".into(),
                    "--package".into(),
                    "my-crate".into(),
                    "--lib".into(),
                ],
                executable_args: vec!["my_test".into(), "--exact".into()],
            }),
        };
        let expected = json!({
            "label": "cargo test -p my-crate",
            "kind": "cargo",
            "args": {
                "environment": {"RUSTC_TOOLCHAIN": "/toolchain"},
                "cwd": "/project",
                "overrideCargo": null,
                "workspaceRoot": "/project",
                "cargoArgs": ["test", "--package", "my-crate", "--lib"],
                "executableArgs": ["my_test", "--exact"],
            }
        });

        let serialized = serde_json::to_value(&runnable).expect("serialized runnable");
        assert_eq!(serialized, expected);

        let deserialized: Runnable =
            serde_json::from_value(expected).expect("cargo runnable should deserialize");
        let RunnableArgs::Cargo(cargo) = &deserialized.args else {
            panic!("expected Cargo variant, got {:?}", deserialized.args);
        };
        assert_eq!(cargo.cargo_args, vec!["test", "--package", "my-crate", "--lib"]);
        assert_eq!(cargo.executable_args, vec!["my_test", "--exact"]);
    }

    #[test]
    fn shell_runnable_round_trips() {
        let runnable = Runnable {
            label: "nextest test_one".to_owned(),
            location: None,
            args: RunnableArgs::Shell(ShellRunnableArgs {
                environment: [("RUSTC_TOOLCHAIN".to_owned(), "/toolchain".to_owned())]
                    .into_iter()
                    .collect(),
                cwd: "/project".into(),
                program: "cargo".into(),
                args: vec!["nextest".into(), "run".into(), "--package".into(), "my-crate".into()],
            }),
        };
        let expected = json!({
            "label": "nextest test_one",
            "kind": "shell",
            "args": {
                "environment": {"RUSTC_TOOLCHAIN": "/toolchain"},
                "cwd": "/project",
                "program": "cargo",
                "args": ["nextest", "run", "--package", "my-crate"],
            }
        });

        let serialized = serde_json::to_value(&runnable).expect("serialized runnable");
        assert_eq!(serialized, expected);

        // Every shell runnable is a structurally valid cargo runnable if the `kind` tag isn't
        // used. This test ensures that the `kind` tag is used.
        let deserialized: Runnable =
            serde_json::from_value(expected).expect("shell runnable should deserialize");
        let RunnableArgs::Shell(shell) = &deserialized.args else {
            panic!("expected Shell variant, got {:?}", deserialized.args);
        };
        assert_eq!(shell.program, "cargo");
        assert_eq!(shell.args, vec!["nextest", "run", "--package", "my-crate"]);
    }
}