Unnamed repository; edit this file 'description' to name the repository.
Diffstat (limited to 'helix-lsp-types/src/inline_value.rs')
| -rw-r--r-- | helix-lsp-types/src/inline_value.rs | 217 |
1 files changed, 217 insertions, 0 deletions
diff --git a/helix-lsp-types/src/inline_value.rs b/helix-lsp-types/src/inline_value.rs new file mode 100644 index 00000000..dd29fbbf --- /dev/null +++ b/helix-lsp-types/src/inline_value.rs @@ -0,0 +1,217 @@ +use crate::{ + DynamicRegistrationClientCapabilities, Range, StaticRegistrationOptions, + TextDocumentIdentifier, TextDocumentRegistrationOptions, WorkDoneProgressOptions, + WorkDoneProgressParams, +}; +use serde::{Deserialize, Serialize}; + +pub type InlineValueClientCapabilities = DynamicRegistrationClientCapabilities; + +#[derive(Debug, Eq, PartialEq, Clone, Deserialize, Serialize)] +#[serde(untagged)] +pub enum InlineValueServerCapabilities { + Options(InlineValueOptions), + RegistrationOptions(InlineValueRegistrationOptions), +} + +/// Inline value options used during static registration. +/// +/// @since 3.17.0 +#[derive(Debug, Eq, PartialEq, Clone, Default, Deserialize, Serialize)] +pub struct InlineValueOptions { + #[serde(flatten)] + pub work_done_progress_options: WorkDoneProgressOptions, +} + +/// Inline value options used during static or dynamic registration. +/// +/// @since 3.17.0 +#[derive(Debug, Eq, PartialEq, Clone, Default, Deserialize, Serialize)] +pub struct InlineValueRegistrationOptions { + #[serde(flatten)] + pub inline_value_options: InlineValueOptions, + + #[serde(flatten)] + pub text_document_registration_options: TextDocumentRegistrationOptions, + + #[serde(flatten)] + pub static_registration_options: StaticRegistrationOptions, +} + +/// A parameter literal used in inline value requests. +/// +/// @since 3.17.0 +#[derive(Debug, Eq, PartialEq, Clone, Deserialize, Serialize)] +#[serde(rename_all = "camelCase")] +pub struct InlineValueParams { + #[serde(flatten)] + pub work_done_progress_params: WorkDoneProgressParams, + + /// The text document. + pub text_document: TextDocumentIdentifier, + + /// The document range for which inline values should be computed. + pub range: Range, + + /// Additional information about the context in which inline values were + /// requested. + pub context: InlineValueContext, +} + +/// @since 3.17.0 +#[derive(Debug, Eq, PartialEq, Clone, Default, Deserialize, Serialize)] +#[serde(rename_all = "camelCase")] +pub struct InlineValueContext { + /// The stack frame (as a DAP Id) where the execution has stopped. + pub frame_id: i32, + + /// The document range where execution has stopped. + /// Typically the end position of the range denotes the line where the + /// inline values are shown. + pub stopped_location: Range, +} + +/// Provide inline value as text. +/// +/// @since 3.17.0 +#[derive(Debug, Eq, PartialEq, Clone, Default, Deserialize, Serialize)] +pub struct InlineValueText { + /// The document range for which the inline value applies. + pub range: Range, + + /// The text of the inline value. + pub text: String, +} + +/// Provide inline value through a variable lookup. +/// +/// If only a range is specified, the variable name will be extracted from +/// the underlying document. +/// +/// An optional variable name can be used to override the extracted name. +/// +/// @since 3.17.0 +#[derive(Debug, Eq, PartialEq, Clone, Default, Deserialize, Serialize)] +#[serde(rename_all = "camelCase")] +pub struct InlineValueVariableLookup { + /// The document range for which the inline value applies. + /// The range is used to extract the variable name from the underlying + /// document. + pub range: Range, + + /// If specified the name of the variable to look up. + #[serde(skip_serializing_if = "Option::is_none")] + pub variable_name: Option<String>, + + /// How to perform the lookup. + pub case_sensitive_lookup: bool, +} + +/// Provide an inline value through an expression evaluation. +/// +/// If only a range is specified, the expression will be extracted from the +/// underlying document. +/// +/// An optional expression can be used to override the extracted expression. +/// +/// @since 3.17.0 +#[derive(Debug, Eq, PartialEq, Clone, Default, Deserialize, Serialize)] +#[serde(rename_all = "camelCase")] +pub struct InlineValueEvaluatableExpression { + /// The document range for which the inline value applies. + /// The range is used to extract the evaluatable expression from the + /// underlying document. + pub range: Range, + + /// If specified the expression overrides the extracted expression. + #[serde(skip_serializing_if = "Option::is_none")] + pub expression: Option<String>, +} + +/// Inline value information can be provided by different means: +/// - directly as a text value (class InlineValueText). +/// - as a name to use for a variable lookup (class InlineValueVariableLookup) +/// - as an evaluatable expression (class InlineValueEvaluatableExpression) +/// The InlineValue types combines all inline value types into one type. +/// +/// @since 3.17.0 +#[derive(Debug, Eq, PartialEq, Clone, Deserialize, Serialize)] +#[serde(untagged)] +pub enum InlineValue { + Text(InlineValueText), + VariableLookup(InlineValueVariableLookup), + EvaluatableExpression(InlineValueEvaluatableExpression), +} + +impl From<InlineValueText> for InlineValue { + #[inline] + fn from(from: InlineValueText) -> Self { + Self::Text(from) + } +} + +impl From<InlineValueVariableLookup> for InlineValue { + #[inline] + fn from(from: InlineValueVariableLookup) -> Self { + Self::VariableLookup(from) + } +} + +impl From<InlineValueEvaluatableExpression> for InlineValue { + #[inline] + fn from(from: InlineValueEvaluatableExpression) -> Self { + Self::EvaluatableExpression(from) + } +} + +/// Client workspace capabilities specific to inline values. +#[derive(Debug, Eq, PartialEq, Clone, Default, Deserialize, Serialize)] +/// +/// @since 3.17.0 +#[serde(rename_all = "camelCase")] +pub struct InlineValueWorkspaceClientCapabilities { + /// Whether the client implementation supports a refresh request sent from + /// the server to the client. + /// + /// Note that this event is global and will force the client to refresh all + /// inline values currently shown. It should be used with absolute care and + /// is useful for situation where a server for example detect a project wide + /// change that requires such a calculation. + #[serde(skip_serializing_if = "Option::is_none")] + pub refresh_support: Option<bool>, +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::tests::test_serialization; + use crate::Position; + + #[test] + fn inline_values() { + test_serialization( + &InlineValueText { + range: Range::new(Position::new(0, 0), Position::new(0, 4)), + text: "one".to_owned(), + }, + r#"{"range":{"start":{"line":0,"character":0},"end":{"line":0,"character":4}},"text":"one"}"#, + ); + + test_serialization( + &InlineValue::VariableLookup(InlineValueVariableLookup { + range: Range::new(Position::new(1, 0), Position::new(1, 4)), + variable_name: None, + case_sensitive_lookup: false, + }), + r#"{"range":{"start":{"line":1,"character":0},"end":{"line":1,"character":4}},"caseSensitiveLookup":false}"#, + ); + + test_serialization( + &InlineValue::EvaluatableExpression(InlineValueEvaluatableExpression { + range: Range::new(Position::new(2, 0), Position::new(2, 4)), + expression: None, + }), + r#"{"range":{"start":{"line":2,"character":0},"end":{"line":2,"character":4}}}"#, + ); + } +} |