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 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204
use serde::{Deserialize, Serialize}; use serde_repr::{Deserialize_repr, Serialize_repr}; use crate::{ Documentation, MarkupKind, TextDocumentPositionParams, TextDocumentRegistrationOptions, WorkDoneProgressOptions, WorkDoneProgressParams, }; #[derive(Debug, Eq, PartialEq, Clone, Default, Deserialize, Serialize)] #[serde(rename_all = "camelCase")] pub struct SignatureInformationSettings { /// Client supports the follow content formats for the documentation /// property. The order describes the preferred format of the client. #[serde(skip_serializing_if = "Option::is_none")] pub documentation_format: Option<Vec<MarkupKind>>, #[serde(skip_serializing_if = "Option::is_none")] pub parameter_information: Option<ParameterInformationSettings>, /// The client support the `activeParameter` property on `SignatureInformation` /// literal. /// /// @since 3.16.0 - proposed state #[serde(skip_serializing_if = "Option::is_none")] #[cfg(feature = "proposed")] pub active_parameter_support: Option<bool>, } #[derive(Debug, Eq, PartialEq, Clone, Default, Deserialize, Serialize)] #[serde(rename_all = "camelCase")] pub struct ParameterInformationSettings { /// The client supports processing label offsets instead of a /// simple label string. /// /// @since 3.14.0 #[serde(skip_serializing_if = "Option::is_none")] pub label_offset_support: Option<bool>, } #[derive(Debug, Eq, PartialEq, Clone, Default, Deserialize, Serialize)] #[serde(rename_all = "camelCase")] pub struct SignatureHelpCapability { /// Whether completion supports dynamic registration. #[serde(skip_serializing_if = "Option::is_none")] pub dynamic_registration: Option<bool>, /// The client supports the following `SignatureInformation` /// specific properties. #[serde(skip_serializing_if = "Option::is_none")] pub signature_information: Option<SignatureInformationSettings>, /// The client supports to send additional context information for a /// `textDocument/signatureHelp` request. A client that opts into /// contextSupport will also support the `retriggerCharacters` on /// `SignatureHelpOptions`. /// /// @since 3.15.0 #[serde(skip_serializing_if = "Option::is_none")] pub context_support: Option<bool>, } /// Signature help options. #[derive(Debug, Eq, PartialEq, Clone, Default, Deserialize, Serialize)] #[serde(rename_all = "camelCase")] pub struct SignatureHelpOptions { /// The characters that trigger signature help automatically. #[serde(skip_serializing_if = "Option::is_none")] pub trigger_characters: Option<Vec<String>>, /// List of characters that re-trigger signature help. /// These trigger characters are only active when signature help is already showing. All trigger characters /// are also counted as re-trigger characters. #[serde(skip_serializing_if = "Option::is_none")] pub retrigger_characters: Option<Vec<String>>, #[serde(flatten)] pub work_done_progress_options: WorkDoneProgressOptions, } /// Signature help options. #[derive(Debug, Eq, PartialEq, Clone, Deserialize, Serialize)] pub struct SignatureHelpRegistrationOptions { #[serde(flatten)] pub text_document_registration_options: TextDocumentRegistrationOptions, } /// Signature help options. #[derive(Debug, Eq, PartialEq, Clone, Deserialize_repr, Serialize_repr)] #[repr(u8)] pub enum SignatureHelpTriggerKind { /// Signature help was invoked manually by the user or by a command. Invoked = 1, /// Signature help was triggered by a trigger character. TriggerCharacter = 2, /// Signature help was triggered by the cursor moving or by the document content changing. ContentChange = 3, } #[derive(Debug, Eq, PartialEq, Clone, Deserialize, Serialize)] #[serde(rename_all = "camelCase")] pub struct SignatureHelpParams { /// The signature help context. This is only available if the client specifies /// to send this using the client capability `textDocument.signatureHelp.contextSupport === true` #[serde(skip_serializing_if = "Option::is_none")] pub context: Option<SignatureHelpContext>, #[serde(flatten)] pub text_document_position_params: TextDocumentPositionParams, #[serde(flatten)] pub work_done_progress_params: WorkDoneProgressParams, } #[derive(Debug, Eq, PartialEq, Clone, Deserialize, Serialize)] #[serde(rename_all = "camelCase")] pub struct SignatureHelpContext { /// Action that caused signature help to be triggered. pub trigger_kind: SignatureHelpTriggerKind, /// Character that caused signature help to be triggered. /// This is undefined when `triggerKind !== SignatureHelpTriggerKind.TriggerCharacter` #[serde(skip_serializing_if = "Option::is_none")] pub trigger_character: Option<String>, /// `true` if signature help was already showing when it was triggered. /// Retriggers occur when the signature help is already active and can be caused by actions such as /// typing a trigger character, a cursor move, or document content changes. pub is_retrigger: bool, /// The currently active `SignatureHelp`. /// The `activeSignatureHelp` has its `SignatureHelp.activeSignature` field updated based on /// the user navigating through available signatures. #[serde(skip_serializing_if = "Option::is_none")] pub active_signature_help: Option<SignatureHelp>, } /// Signature help represents the signature of something /// callable. There can be multiple signature but only one /// active and only one active parameter. #[derive(Debug, Eq, PartialEq, Clone, Deserialize, Serialize)] #[serde(rename_all = "camelCase")] pub struct SignatureHelp { /// One or more signatures. pub signatures: Vec<SignatureInformation>, /// The active signature. #[serde(skip_serializing_if = "Option::is_none")] pub active_signature: Option<u32>, /// The active parameter of the active signature. #[serde(skip_serializing_if = "Option::is_none")] pub active_parameter: Option<u32>, } /// Represents the signature of something callable. A signature /// can have a label, like a function-name, a doc-comment, and /// a set of parameters. #[derive(Debug, Eq, PartialEq, Clone, Deserialize, Serialize)] pub struct SignatureInformation { /// The label of this signature. Will be shown in /// the UI. pub label: String, /// The human-readable doc-comment of this signature. Will be shown /// in the UI but can be omitted. #[serde(skip_serializing_if = "Option::is_none")] pub documentation: Option<Documentation>, /// The parameters of this signature. #[serde(skip_serializing_if = "Option::is_none")] pub parameters: Option<Vec<ParameterInformation>>, /// The index of the active parameter. /// /// If provided, this is used in place of `SignatureHelp.activeParameter`. /// /// @since 3.16.0 - proposed state #[serde(skip_serializing_if = "Option::is_none")] #[cfg(feature = "proposed")] pub active_parameter: Option<u32>, } /// Represents a parameter of a callable-signature. A parameter can /// have a label and a doc-comment. #[derive(Debug, Eq, PartialEq, Clone, Deserialize, Serialize)] pub struct ParameterInformation { /// The label of this parameter information. /// /// Either a string or an inclusive start and exclusive end offsets within its containing /// signature label. (see SignatureInformation.label). *Note*: A label of type string must be /// a substring of its containing signature label. pub label: ParameterLabel, /// The human-readable doc-comment of this parameter. Will be shown /// in the UI but can be omitted. #[serde(skip_serializing_if = "Option::is_none")] pub documentation: Option<Documentation>, } #[derive(Debug, Eq, PartialEq, Clone, Deserialize, Serialize)] #[serde(untagged)] pub enum ParameterLabel { Simple(String), LabelOffsets([u32; 2]), }