-use std::borrow::Cow;
-
-use serde::ser::SerializeSeq;
-use serde::{Deserialize, Serialize};
-
-use crate::{
- PartialResultParams, Range, StaticRegistrationOptions, TextDocumentIdentifier,
- TextDocumentRegistrationOptions, WorkDoneProgressOptions, WorkDoneProgressParams,
-};
-/// A set of predefined token types. This set is not fixed
-/// and clients can specify additional token types via the
-/// corresponding client capabilities.
-/// since @3.16.0
-#[derive(Debug, Eq, PartialEq, Hash, PartialOrd, Clone, Deserialize, Serialize)]
-pub struct SemanticTokenType(Cow<'static, str>);
-
-impl SemanticTokenType {
- pub const NAMESPACE: SemanticTokenType = SemanticTokenType::new("namespace");
- pub const TYPE: SemanticTokenType = SemanticTokenType::new("type");
- pub const CLASS: SemanticTokenType = SemanticTokenType::new("class");
- pub const ENUM: SemanticTokenType = SemanticTokenType::new("enum");
- pub const INTERFACE: SemanticTokenType = SemanticTokenType::new("interface");
- pub const STRUCT: SemanticTokenType = SemanticTokenType::new("struct");
- pub const TYPE_PARAMETER: SemanticTokenType = SemanticTokenType::new("typeParameter");
- pub const PARAMETER: SemanticTokenType = SemanticTokenType::new("parameter");
- pub const VARIABLE: SemanticTokenType = SemanticTokenType::new("variable");
- pub const PROPERTY: SemanticTokenType = SemanticTokenType::new("property");
- pub const ENUM_MEMBER: SemanticTokenType = SemanticTokenType::new("enumMember");
- pub const EVENT: SemanticTokenType = SemanticTokenType::new("event");
- pub const FUNCTION: SemanticTokenType = SemanticTokenType::new("function");
- pub const METHOD: SemanticTokenType = SemanticTokenType::new("method");
- pub const MACRO: SemanticTokenType = SemanticTokenType::new("macro");
- pub const KEYWORD: SemanticTokenType = SemanticTokenType::new("keyword");
- pub const MODIFIER: SemanticTokenType = SemanticTokenType::new("modifier");
- pub const COMMENT: SemanticTokenType = SemanticTokenType::new("comment");
- pub const STRING: SemanticTokenType = SemanticTokenType::new("string");
- pub const NUMBER: SemanticTokenType = SemanticTokenType::new("number");
- pub const REGEXP: SemanticTokenType = SemanticTokenType::new("regexp");
- pub const OPERATOR: SemanticTokenType = SemanticTokenType::new("operator");
-
- /// since @3.17.0
- #[cfg(feature = "proposed")]
- pub const DECORATOR: SemanticTokenType = SemanticTokenType::new("decorator");
-
- pub const fn new(tag: &'static str) -> Self {
- SemanticTokenType(Cow::Borrowed(tag))
- }
-
- pub fn as_str(&self) -> &str {
- &self.0
- }
-}
-
-impl From<String> for SemanticTokenType {
- fn from(from: String) -> Self {
- SemanticTokenType(Cow::from(from))
- }
-}
-
-impl From<&'static str> for SemanticTokenType {
- fn from(from: &'static str) -> Self {
- SemanticTokenType::new(from)
- }
-}
-
-/// A set of predefined token modifiers. This set is not fixed
-/// and clients can specify additional token types via the
-/// corresponding client capabilities.
-///
-/// @since 3.16.0
-#[derive(Debug, Eq, PartialEq, Hash, PartialOrd, Clone, Deserialize, Serialize)]
-pub struct SemanticTokenModifier(Cow<'static, str>);
-
-impl SemanticTokenModifier {
- pub const DECLARATION: SemanticTokenModifier = SemanticTokenModifier::new("declaration");
- pub const DEFINITION: SemanticTokenModifier = SemanticTokenModifier::new("definition");
- pub const READONLY: SemanticTokenModifier = SemanticTokenModifier::new("readonly");
- pub const STATIC: SemanticTokenModifier = SemanticTokenModifier::new("static");
- pub const DEPRECATED: SemanticTokenModifier = SemanticTokenModifier::new("deprecated");
- pub const ABSTRACT: SemanticTokenModifier = SemanticTokenModifier::new("abstract");
- pub const ASYNC: SemanticTokenModifier = SemanticTokenModifier::new("async");
- pub const MODIFICATION: SemanticTokenModifier = SemanticTokenModifier::new("modification");
- pub const DOCUMENTATION: SemanticTokenModifier = SemanticTokenModifier::new("documentation");
- pub const DEFAULT_LIBRARY: SemanticTokenModifier = SemanticTokenModifier::new("defaultLibrary");
-
- pub const fn new(tag: &'static str) -> Self {
- SemanticTokenModifier(Cow::Borrowed(tag))
- }
-
- pub fn as_str(&self) -> &str {
- &self.0
- }
-}
-
-impl From<String> for SemanticTokenModifier {
- fn from(from: String) -> Self {
- SemanticTokenModifier(Cow::from(from))
- }
-}
-
-impl From<&'static str> for SemanticTokenModifier {
- fn from(from: &'static str) -> Self {
- SemanticTokenModifier::new(from)
- }
-}
-
-#[derive(Debug, Eq, PartialEq, Hash, PartialOrd, Clone, Deserialize, Serialize)]
-pub struct TokenFormat(Cow<'static, str>);
-
-impl TokenFormat {
- pub const RELATIVE: TokenFormat = TokenFormat::new("relative");
-
- pub const fn new(tag: &'static str) -> Self {
- TokenFormat(Cow::Borrowed(tag))
- }
-
- pub fn as_str(&self) -> &str {
- &self.0
- }
-}
-
-impl From<String> for TokenFormat {
- fn from(from: String) -> Self {
- TokenFormat(Cow::from(from))
- }
-}
-
-impl From<&'static str> for TokenFormat {
- fn from(from: &'static str) -> Self {
- TokenFormat::new(from)
- }
-}
-
-/// @since 3.16.0
-#[derive(Debug, Eq, PartialEq, Clone, Default, Deserialize, Serialize)]
-#[serde(rename_all = "camelCase")]
-pub struct SemanticTokensLegend {
- /// The token types a server uses.
- pub token_types: Vec<SemanticTokenType>,
-
- /// The token modifiers a server uses.
- pub token_modifiers: Vec<SemanticTokenModifier>,
-}
-
-/// The actual tokens. For a detailed description about how the data is
-/// structured please see
-/// <https://github.com/microsoft/vscode-extension-samples/blob/5ae1f7787122812dcc84e37427ca90af5ee09f14/semantic-tokens-sample/vscode.proposed.d.ts#L71>
-#[derive(Debug, Eq, PartialEq, Copy, Clone, Default)]
-pub struct SemanticToken {
- pub delta_line: u32,
- pub delta_start: u32,
- pub length: u32,
- pub token_type: u32,
- pub token_modifiers_bitset: u32,
-}
-
-impl SemanticToken {
- fn deserialize_tokens<'de, D>(deserializer: D) -> Result<Vec<SemanticToken>, D::Error>
- where
- D: serde::Deserializer<'de>,
- {
- let data = Vec::<u32>::deserialize(deserializer)?;
- let chunks = data.chunks_exact(5);
-
- if !chunks.remainder().is_empty() {
- return Result::Err(serde::de::Error::custom("Length is not divisible by 5"));
- }
-
- Result::Ok(
- chunks
- .map(|chunk| SemanticToken {
- delta_line: chunk[0],
- delta_start: chunk[1],
- length: chunk[2],
- token_type: chunk[3],
- token_modifiers_bitset: chunk[4],
- })
- .collect(),
- )
- }
-
- fn serialize_tokens<S>(tokens: &[SemanticToken], serializer: S) -> Result<S::Ok, S::Error>
- where
- S: serde::Serializer,
- {
- let mut seq = serializer.serialize_seq(Some(tokens.len() * 5))?;
- for token in tokens.iter() {
- seq.serialize_element(&token.delta_line)?;
- seq.serialize_element(&token.delta_start)?;
- seq.serialize_element(&token.length)?;
- seq.serialize_element(&token.token_type)?;
- seq.serialize_element(&token.token_modifiers_bitset)?;
- }
- seq.end()
- }
-
- fn deserialize_tokens_opt<'de, D>(
- deserializer: D,
- ) -> Result<Option<Vec<SemanticToken>>, D::Error>
- where
- D: serde::Deserializer<'de>,
- {
- #[derive(Deserialize)]
- #[serde(transparent)]
- struct Wrapper {
- #[serde(deserialize_with = "SemanticToken::deserialize_tokens")]
- tokens: Vec<SemanticToken>,
- }
-
- Ok(Option::<Wrapper>::deserialize(deserializer)?.map(|wrapper| wrapper.tokens))
- }
-
- fn serialize_tokens_opt<S>(
- data: &Option<Vec<SemanticToken>>,
- serializer: S,
- ) -> Result<S::Ok, S::Error>
- where
- S: serde::Serializer,
- {
- #[derive(Serialize)]
- #[serde(transparent)]
- struct Wrapper {
- #[serde(serialize_with = "SemanticToken::serialize_tokens")]
- tokens: Vec<SemanticToken>,
- }
-
- let opt = data.as_ref().map(|t| Wrapper { tokens: t.to_vec() });
-
- opt.serialize(serializer)
- }
-}
-
-/// @since 3.16.0
-#[derive(Debug, Eq, PartialEq, Clone, Default, Deserialize, Serialize)]
-#[serde(rename_all = "camelCase")]
-pub struct SemanticTokens {
- /// An optional result id. If provided and clients support delta updating
- /// the client will include the result id in the next semantic token request.
- /// A server can then instead of computing all semantic tokens again simply
- /// send a delta.
- #[serde(skip_serializing_if = "Option::is_none")]
- pub result_id: Option<String>,
-
- /// The actual tokens. For a detailed description about how the data is
- /// structured please see
- /// <https://github.com/microsoft/vscode-extension-samples/blob/5ae1f7787122812dcc84e37427ca90af5ee09f14/semantic-tokens-sample/vscode.proposed.d.ts#L71>
- #[serde(
- deserialize_with = "SemanticToken::deserialize_tokens",
- serialize_with = "SemanticToken::serialize_tokens"
- )]
- pub data: Vec<SemanticToken>,
-}
-
-/// @since 3.16.0
-#[derive(Debug, Eq, PartialEq, Clone, Default, Deserialize, Serialize)]
-#[serde(rename_all = "camelCase")]
-pub struct SemanticTokensPartialResult {
- #[serde(
- deserialize_with = "SemanticToken::deserialize_tokens",
- serialize_with = "SemanticToken::serialize_tokens"
- )]
- pub data: Vec<SemanticToken>,
-}
-
-#[derive(Debug, Eq, PartialEq, Clone, Deserialize, Serialize)]
-#[serde(rename_all = "camelCase")]
-#[serde(untagged)]
-pub enum SemanticTokensResult {
- Tokens(SemanticTokens),
- Partial(SemanticTokensPartialResult),
-}
-
-impl From<SemanticTokens> for SemanticTokensResult {
- fn from(from: SemanticTokens) -> Self {
- SemanticTokensResult::Tokens(from)
- }
-}
-
-impl From<SemanticTokensPartialResult> for SemanticTokensResult {
- fn from(from: SemanticTokensPartialResult) -> Self {
- SemanticTokensResult::Partial(from)
- }
-}
-
-/// @since 3.16.0
-#[derive(Debug, Eq, PartialEq, Clone, Default, Deserialize, Serialize)]
-#[serde(rename_all = "camelCase")]
-pub struct SemanticTokensEdit {
- pub start: u32,
- pub delete_count: u32,
-
- #[serde(
- default,
- skip_serializing_if = "Option::is_none",
- deserialize_with = "SemanticToken::deserialize_tokens_opt",
- serialize_with = "SemanticToken::serialize_tokens_opt"
- )]
- pub data: Option<Vec<SemanticToken>>,
-}
-
-#[derive(Debug, Eq, PartialEq, Clone, Deserialize, Serialize)]
-#[serde(rename_all = "camelCase")]
-#[serde(untagged)]
-pub enum SemanticTokensFullDeltaResult {
- Tokens(SemanticTokens),
- TokensDelta(SemanticTokensDelta),
- PartialTokensDelta { edits: Vec<SemanticTokensEdit> },
-}
-
-impl From<SemanticTokens> for SemanticTokensFullDeltaResult {
- fn from(from: SemanticTokens) -> Self {
- SemanticTokensFullDeltaResult::Tokens(from)
- }
-}
-
-impl From<SemanticTokensDelta> for SemanticTokensFullDeltaResult {
- fn from(from: SemanticTokensDelta) -> Self {
- SemanticTokensFullDeltaResult::TokensDelta(from)
- }
-}
-
-/// @since 3.16.0
-#[derive(Debug, Eq, PartialEq, Clone, Default, Deserialize, Serialize)]
-#[serde(rename_all = "camelCase")]
-pub struct SemanticTokensDelta {
- #[serde(skip_serializing_if = "Option::is_none")]
- pub result_id: Option<String>,
- /// For a detailed description how these edits are structured please see
- /// <https://github.com/microsoft/vscode-extension-samples/blob/5ae1f7787122812dcc84e37427ca90af5ee09f14/semantic-tokens-sample/vscode.proposed.d.ts#L131>
- pub edits: Vec<SemanticTokensEdit>,
-}
-
-/// Capabilities specific to the `textDocument/semanticTokens/*` requests.
-///
-/// @since 3.16.0
-#[derive(Debug, Eq, PartialEq, Clone, Default, Deserialize, Serialize)]
-#[serde(rename_all = "camelCase")]
-pub struct SemanticTokensClientCapabilities {
- /// Whether implementation supports dynamic registration. If this is set to `true`
- /// the client supports the new `(TextDocumentRegistrationOptions & StaticRegistrationOptions)`
- /// return value for the corresponding server capability as well.
- #[serde(skip_serializing_if = "Option::is_none")]
- pub dynamic_registration: Option<bool>,
-
- /// Which requests the client supports and might send to the server
- /// depending on the server's capability. Please note that clients might not
- /// show semantic tokens or degrade some of the user experience if a range
- /// or full request is advertised by the client but not provided by the
- /// server. If for example the client capability `requests.full` and
- /// `request.range` are both set to true but the server only provides a
- /// range provider the client might not render a minimap correctly or might
- /// even decide to not show any semantic tokens at all.
- pub requests: SemanticTokensClientCapabilitiesRequests,
-
- /// The token types that the client supports.
- pub token_types: Vec<SemanticTokenType>,
-
- /// The token modifiers that the client supports.
- pub token_modifiers: Vec<SemanticTokenModifier>,
-
- /// The token formats the clients supports.
- pub formats: Vec<TokenFormat>,
-
- /// Whether the client supports tokens that can overlap each other.
- #[serde(skip_serializing_if = "Option::is_none")]
- pub overlapping_token_support: Option<bool>,
-
- /// Whether the client supports tokens that can span multiple lines.
- #[serde(skip_serializing_if = "Option::is_none")]
- pub multiline_token_support: Option<bool>,
-
- /// Whether the client allows the server to actively cancel a
- /// semantic token request, e.g. supports returning
- /// ErrorCodes.ServerCancelled. If a server does the client
- /// needs to retrigger the request.
- ///
- /// since @3.17.0
- #[cfg(feature = "proposed")]
- #[serde(skip_serializing_if = "Option::is_none")]
- pub server_cancel_support: Option<bool>,
-
-
- /// Whether the client uses semantic tokens to augment existing
- /// syntax tokens. If set to `true` client side created syntax
- /// tokens and semantic tokens are both used for colorization. If
- /// set to `false` the client only uses the returned semantic tokens
- /// for colorization.
- ///
- /// If the value is `undefined` then the client behavior is not
- /// specified.
- ///
- /// @since 3.17.0
- #[cfg(feature = "proposed")]
- #[serde(skip_serializing_if = "Option::is_none")]
- pub augments_syntax_tokens: Option<bool>,
-}
-
-#[derive(Debug, Eq, PartialEq, Clone, Default, Deserialize, Serialize)]
-#[serde(rename_all = "camelCase")]
-pub struct SemanticTokensClientCapabilitiesRequests {
- /// The client will send the `textDocument/semanticTokens/range` request if the server provides a corresponding handler.
- #[serde(skip_serializing_if = "Option::is_none")]
- pub range: Option<bool>,
-
- /// The client will send the `textDocument/semanticTokens/full` request if the server provides a corresponding handler.
- #[serde(skip_serializing_if = "Option::is_none")]
- pub full: Option<SemanticTokensFullOptions>,
-}
-
-#[derive(Debug, Eq, PartialEq, Clone, Deserialize, Serialize)]
-#[serde(rename_all = "camelCase")]
-#[serde(untagged)]
-pub enum SemanticTokensFullOptions {
- Bool(bool),
- Delta {
- /// The client will send the `textDocument/semanticTokens/full/delta` request if the server provides a corresponding handler.
- /// The server supports deltas for full documents.
- #[serde(skip_serializing_if = "Option::is_none")]
- delta: Option<bool>,
- },
-}
-
-/// @since 3.16.0
-#[derive(Debug, Eq, PartialEq, Clone, Default, Deserialize, Serialize)]
-#[serde(rename_all = "camelCase")]
-pub struct SemanticTokensOptions {
- #[serde(flatten)]
- pub work_done_progress_options: WorkDoneProgressOptions,
-
- /// The legend used by the server
- pub legend: SemanticTokensLegend,
-
- /// Server supports providing semantic tokens for a sepcific range
- /// of a document.
- #[serde(skip_serializing_if = "Option::is_none")]
- pub range: Option<bool>,
-
- /// Server supports providing semantic tokens for a full document.
- #[serde(skip_serializing_if = "Option::is_none")]
- pub full: Option<SemanticTokensFullOptions>,
-}
-
-#[derive(Debug, Eq, PartialEq, Clone, Deserialize, Serialize)]
-#[serde(rename_all = "camelCase")]
-pub struct SemanticTokensRegistrationOptions {
- #[serde(flatten)]
- pub text_document_registration_options: TextDocumentRegistrationOptions,
-
- #[serde(flatten)]
- pub semantic_tokens_options: SemanticTokensOptions,
-
- #[serde(flatten)]
- pub static_registration_options: StaticRegistrationOptions,
-}
-
-#[derive(Debug, Eq, PartialEq, Clone, Deserialize, Serialize)]
-#[serde(rename_all = "camelCase")]
-#[serde(untagged)]
-pub enum SemanticTokensServerCapabilities {
- SemanticTokensOptions(SemanticTokensOptions),
- SemanticTokensRegistrationOptions(SemanticTokensRegistrationOptions),
-}
-
-impl From<SemanticTokensOptions> for SemanticTokensServerCapabilities {
- fn from(from: SemanticTokensOptions) -> Self {
- SemanticTokensServerCapabilities::SemanticTokensOptions(from)
- }
-}
-
-impl From<SemanticTokensRegistrationOptions> for SemanticTokensServerCapabilities {
- fn from(from: SemanticTokensRegistrationOptions) -> Self {
- SemanticTokensServerCapabilities::SemanticTokensRegistrationOptions(from)
- }
-}
-
-#[derive(Debug, Eq, PartialEq, Clone, Deserialize, Serialize)]
-#[serde(rename_all = "camelCase")]
-pub struct SemanticTokensWorkspaceClientCapabilities {
- /// 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
- /// semantic tokens 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.
- pub refresh_support: Option<bool>,
-}
-
-#[derive(Debug, Eq, PartialEq, Clone, Deserialize, Serialize)]
-#[serde(rename_all = "camelCase")]
-pub struct SemanticTokensParams {
- #[serde(flatten)]
- pub work_done_progress_params: WorkDoneProgressParams,
-
- #[serde(flatten)]
- pub partial_result_params: PartialResultParams,
-
- /// The text document.
- pub text_document: TextDocumentIdentifier,
-}
-
-#[derive(Debug, Eq, PartialEq, Clone, Deserialize, Serialize)]
-#[serde(rename_all = "camelCase")]
-pub struct SemanticTokensDeltaParams {
- #[serde(flatten)]
- pub work_done_progress_params: WorkDoneProgressParams,
-
- #[serde(flatten)]
- pub partial_result_params: PartialResultParams,
-
- /// The text document.
- pub text_document: TextDocumentIdentifier,
-
- /// The result id of a previous response. The result Id can either point to a full response
- /// or a delta response depending on what was recevied last.
- pub previous_result_id: String,
-}
-
-#[derive(Debug, Eq, PartialEq, Clone, Deserialize, Serialize)]
-#[serde(rename_all = "camelCase")]
-pub struct SemanticTokensRangeParams {
- #[serde(flatten)]
- pub work_done_progress_params: WorkDoneProgressParams,
-
- #[serde(flatten)]
- pub partial_result_params: PartialResultParams,
-
- /// The text document.
- pub text_document: TextDocumentIdentifier,
-
- /// The range the semantic tokens are requested for.
- pub range: Range,
-}
-
-#[derive(Debug, Eq, PartialEq, Clone, Deserialize, Serialize)]
-#[serde(rename_all = "camelCase")]
-#[serde(untagged)]
-pub enum SemanticTokensRangeResult {
- Tokens(SemanticTokens),
- Partial(SemanticTokensPartialResult),
-}
-
-impl From<SemanticTokens> for SemanticTokensRangeResult {
- fn from(tokens: SemanticTokens) -> Self {
- SemanticTokensRangeResult::Tokens(tokens)
- }
-}
-
-impl From<SemanticTokensPartialResult> for SemanticTokensRangeResult {
- fn from(partial: SemanticTokensPartialResult) -> Self {
- SemanticTokensRangeResult::Partial(partial)
- }
-}
-
-#[cfg(test)]
-mod tests {
- use super::*;
- use crate::tests::{test_deserialization, test_serialization};
-
- #[test]
- fn test_semantic_tokens_support_serialization() {
- test_serialization(
- &SemanticTokens {
- result_id: None,
- data: vec![],
- },
- r#"{"data":[]}"#,
- );
-
- test_serialization(
- &SemanticTokens {
- result_id: None,
- data: vec![SemanticToken {
- delta_line: 2,
- delta_start: 5,
- length: 3,
- token_type: 0,
- token_modifiers_bitset: 3,
- }],
- },
- r#"{"data":[2,5,3,0,3]}"#,
- );
-
- test_serialization(
- &SemanticTokens {
- result_id: None,
- data: vec![
- SemanticToken {
- delta_line: 2,
- delta_start: 5,
- length: 3,
- token_type: 0,
- token_modifiers_bitset: 3,
- },
- SemanticToken {
- delta_line: 0,
- delta_start: 5,
- length: 4,
- token_type: 1,
- token_modifiers_bitset: 0,
- },
- ],
- },
- r#"{"data":[2,5,3,0,3,0,5,4,1,0]}"#,
- );
- }
-
- #[test]
- fn test_semantic_tokens_support_deserialization() {
- test_deserialization(
- r#"{"data":[]}"#,
- &SemanticTokens {
- result_id: None,
- data: vec![],
- },
- );
-
- test_deserialization(
- r#"{"data":[2,5,3,0,3]}"#,
- &SemanticTokens {
- result_id: None,
- data: vec![SemanticToken {
- delta_line: 2,
- delta_start: 5,
- length: 3,
- token_type: 0,
- token_modifiers_bitset: 3,
- }],
- },
- );
-
- test_deserialization(
- r#"{"data":[2,5,3,0,3,0,5,4,1,0]}"#,
- &SemanticTokens {
- result_id: None,
- data: vec![
- SemanticToken {
- delta_line: 2,
- delta_start: 5,
- length: 3,
- token_type: 0,
- token_modifiers_bitset: 3,
- },
- SemanticToken {
- delta_line: 0,
- delta_start: 5,
- length: 4,
- token_type: 1,
- token_modifiers_bitset: 0,
- },
- ],
- },
- );
- }
-
- #[test]
- #[should_panic]
- fn test_semantic_tokens_support_deserialization_err() {
- test_deserialization(
- r#"{"data":[1]}"#,
- &SemanticTokens {
- result_id: None,
- data: vec![],
- },
- );
- }
-
- #[test]
- fn test_semantic_tokens_edit_support_deserialization() {
- test_deserialization(
- r#"{"start":0,"deleteCount":1,"data":[2,5,3,0,3,0,5,4,1,0]}"#,
- &SemanticTokensEdit {
- start: 0,
- delete_count: 1,
- data: Some(vec![
- SemanticToken {
- delta_line: 2,
- delta_start: 5,
- length: 3,
- token_type: 0,
- token_modifiers_bitset: 3,
- },
- SemanticToken {
- delta_line: 0,
- delta_start: 5,
- length: 4,
- token_type: 1,
- token_modifiers_bitset: 0,
- },
- ]),
- },
- );
-
- test_deserialization(
- r#"{"start":0,"deleteCount":1}"#,
- &SemanticTokensEdit {
- start: 0,
- delete_count: 1,
- data: None,
- },
- );
- }
-
- #[test]
- fn test_semantic_tokens_edit_support_serialization() {
- test_serialization(
- &SemanticTokensEdit {
- start: 0,
- delete_count: 1,
- data: Some(vec![
- SemanticToken {
- delta_line: 2,
- delta_start: 5,
- length: 3,
- token_type: 0,
- token_modifiers_bitset: 3,
- },
- SemanticToken {
- delta_line: 0,
- delta_start: 5,
- length: 4,
- token_type: 1,
- token_modifiers_bitset: 0,
- },
- ]),
- },
- r#"{"start":0,"deleteCount":1,"data":[2,5,3,0,3,0,5,4,1,0]}"#,
- );
-
- test_serialization(
- &SemanticTokensEdit {
- start: 0,
- delete_count: 1,
- data: None,
- },
- r#"{"start":0,"deleteCount":1}"#,
- );
- }
-}
+use std::borrow::Cow;\r
+\r
+use serde::ser::SerializeSeq;\r
+use serde::{Deserialize, Serialize};\r
+\r
+use crate::{\r
+ PartialResultParams, Range, StaticRegistrationOptions, TextDocumentIdentifier,\r
+ TextDocumentRegistrationOptions, WorkDoneProgressOptions, WorkDoneProgressParams,\r
+};\r
+/// A set of predefined token types. This set is not fixed\r
+/// and clients can specify additional token types via the\r
+/// corresponding client capabilities.\r
+/// since @3.16.0\r
+#[derive(Debug, Eq, PartialEq, Hash, PartialOrd, Clone, Deserialize, Serialize)]\r
+pub struct SemanticTokenType(Cow<'static, str>);\r
+\r
+impl SemanticTokenType {\r
+ pub const NAMESPACE: SemanticTokenType = SemanticTokenType::new("namespace");\r
+ pub const TYPE: SemanticTokenType = SemanticTokenType::new("type");\r
+ pub const CLASS: SemanticTokenType = SemanticTokenType::new("class");\r
+ pub const ENUM: SemanticTokenType = SemanticTokenType::new("enum");\r
+ pub const INTERFACE: SemanticTokenType = SemanticTokenType::new("interface");\r
+ pub const STRUCT: SemanticTokenType = SemanticTokenType::new("struct");\r
+ pub const TYPE_PARAMETER: SemanticTokenType = SemanticTokenType::new("typeParameter");\r
+ pub const PARAMETER: SemanticTokenType = SemanticTokenType::new("parameter");\r
+ pub const VARIABLE: SemanticTokenType = SemanticTokenType::new("variable");\r
+ pub const PROPERTY: SemanticTokenType = SemanticTokenType::new("property");\r
+ pub const ENUM_MEMBER: SemanticTokenType = SemanticTokenType::new("enumMember");\r
+ pub const EVENT: SemanticTokenType = SemanticTokenType::new("event");\r
+ pub const FUNCTION: SemanticTokenType = SemanticTokenType::new("function");\r
+ pub const METHOD: SemanticTokenType = SemanticTokenType::new("method");\r
+ pub const MACRO: SemanticTokenType = SemanticTokenType::new("macro");\r
+ pub const KEYWORD: SemanticTokenType = SemanticTokenType::new("keyword");\r
+ pub const MODIFIER: SemanticTokenType = SemanticTokenType::new("modifier");\r
+ pub const COMMENT: SemanticTokenType = SemanticTokenType::new("comment");\r
+ pub const STRING: SemanticTokenType = SemanticTokenType::new("string");\r
+ pub const NUMBER: SemanticTokenType = SemanticTokenType::new("number");\r
+ pub const REGEXP: SemanticTokenType = SemanticTokenType::new("regexp");\r
+ pub const OPERATOR: SemanticTokenType = SemanticTokenType::new("operator");\r
+\r
+ /// since @3.17.0\r
+ pub const DECORATOR: SemanticTokenType = SemanticTokenType::new("decorator");\r
+\r
+ pub const fn new(tag: &'static str) -> Self {\r
+ SemanticTokenType(Cow::Borrowed(tag))\r
+ }\r
+\r
+ pub fn as_str(&self) -> &str {\r
+ &self.0\r
+ }\r
+}\r
+\r
+impl From<String> for SemanticTokenType {\r
+ fn from(from: String) -> Self {\r
+ SemanticTokenType(Cow::from(from))\r
+ }\r
+}\r
+\r
+impl From<&'static str> for SemanticTokenType {\r
+ fn from(from: &'static str) -> Self {\r
+ SemanticTokenType::new(from)\r
+ }\r
+}\r
+\r
+/// A set of predefined token modifiers. This set is not fixed\r
+/// and clients can specify additional token types via the\r
+/// corresponding client capabilities.\r
+///\r
+/// @since 3.16.0\r
+#[derive(Debug, Eq, PartialEq, Hash, PartialOrd, Clone, Deserialize, Serialize)]\r
+pub struct SemanticTokenModifier(Cow<'static, str>);\r
+\r
+impl SemanticTokenModifier {\r
+ pub const DECLARATION: SemanticTokenModifier = SemanticTokenModifier::new("declaration");\r
+ pub const DEFINITION: SemanticTokenModifier = SemanticTokenModifier::new("definition");\r
+ pub const READONLY: SemanticTokenModifier = SemanticTokenModifier::new("readonly");\r
+ pub const STATIC: SemanticTokenModifier = SemanticTokenModifier::new("static");\r
+ pub const DEPRECATED: SemanticTokenModifier = SemanticTokenModifier::new("deprecated");\r
+ pub const ABSTRACT: SemanticTokenModifier = SemanticTokenModifier::new("abstract");\r
+ pub const ASYNC: SemanticTokenModifier = SemanticTokenModifier::new("async");\r
+ pub const MODIFICATION: SemanticTokenModifier = SemanticTokenModifier::new("modification");\r
+ pub const DOCUMENTATION: SemanticTokenModifier = SemanticTokenModifier::new("documentation");\r
+ pub const DEFAULT_LIBRARY: SemanticTokenModifier = SemanticTokenModifier::new("defaultLibrary");\r
+\r
+ pub const fn new(tag: &'static str) -> Self {\r
+ SemanticTokenModifier(Cow::Borrowed(tag))\r
+ }\r
+\r
+ pub fn as_str(&self) -> &str {\r
+ &self.0\r
+ }\r
+}\r
+\r
+impl From<String> for SemanticTokenModifier {\r
+ fn from(from: String) -> Self {\r
+ SemanticTokenModifier(Cow::from(from))\r
+ }\r
+}\r
+\r
+impl From<&'static str> for SemanticTokenModifier {\r
+ fn from(from: &'static str) -> Self {\r
+ SemanticTokenModifier::new(from)\r
+ }\r
+}\r
+\r
+#[derive(Debug, Eq, PartialEq, Hash, PartialOrd, Clone, Deserialize, Serialize)]\r
+pub struct TokenFormat(Cow<'static, str>);\r
+\r
+impl TokenFormat {\r
+ pub const RELATIVE: TokenFormat = TokenFormat::new("relative");\r
+\r
+ pub const fn new(tag: &'static str) -> Self {\r
+ TokenFormat(Cow::Borrowed(tag))\r
+ }\r
+\r
+ pub fn as_str(&self) -> &str {\r
+ &self.0\r
+ }\r
+}\r
+\r
+impl From<String> for TokenFormat {\r
+ fn from(from: String) -> Self {\r
+ TokenFormat(Cow::from(from))\r
+ }\r
+}\r
+\r
+impl From<&'static str> for TokenFormat {\r
+ fn from(from: &'static str) -> Self {\r
+ TokenFormat::new(from)\r
+ }\r
+}\r
+\r
+/// @since 3.16.0\r
+#[derive(Debug, Eq, PartialEq, Clone, Default, Deserialize, Serialize)]\r
+#[serde(rename_all = "camelCase")]\r
+pub struct SemanticTokensLegend {\r
+ /// The token types a server uses.\r
+ pub token_types: Vec<SemanticTokenType>,\r
+\r
+ /// The token modifiers a server uses.\r
+ pub token_modifiers: Vec<SemanticTokenModifier>,\r
+}\r
+\r
+/// The actual tokens.\r
+#[derive(Debug, Eq, PartialEq, Copy, Clone, Default)]\r
+pub struct SemanticToken {\r
+ pub delta_line: u32,\r
+ pub delta_start: u32,\r
+ pub length: u32,\r
+ pub token_type: u32,\r
+ pub token_modifiers_bitset: u32,\r
+}\r
+\r
+impl SemanticToken {\r
+ fn deserialize_tokens<'de, D>(deserializer: D) -> Result<Vec<SemanticToken>, D::Error>\r
+ where\r
+ D: serde::Deserializer<'de>,\r
+ {\r
+ let data = Vec::<u32>::deserialize(deserializer)?;\r
+ let chunks = data.chunks_exact(5);\r
+\r
+ if !chunks.remainder().is_empty() {\r
+ return Result::Err(serde::de::Error::custom("Length is not divisible by 5"));\r
+ }\r
+\r
+ Result::Ok(\r
+ chunks\r
+ .map(|chunk| SemanticToken {\r
+ delta_line: chunk[0],\r
+ delta_start: chunk[1],\r
+ length: chunk[2],\r
+ token_type: chunk[3],\r
+ token_modifiers_bitset: chunk[4],\r
+ })\r
+ .collect(),\r
+ )\r
+ }\r
+\r
+ fn serialize_tokens<S>(tokens: &[SemanticToken], serializer: S) -> Result<S::Ok, S::Error>\r
+ where\r
+ S: serde::Serializer,\r
+ {\r
+ let mut seq = serializer.serialize_seq(Some(tokens.len() * 5))?;\r
+ for token in tokens.iter() {\r
+ seq.serialize_element(&token.delta_line)?;\r
+ seq.serialize_element(&token.delta_start)?;\r
+ seq.serialize_element(&token.length)?;\r
+ seq.serialize_element(&token.token_type)?;\r
+ seq.serialize_element(&token.token_modifiers_bitset)?;\r
+ }\r
+ seq.end()\r
+ }\r
+\r
+ fn deserialize_tokens_opt<'de, D>(\r
+ deserializer: D,\r
+ ) -> Result<Option<Vec<SemanticToken>>, D::Error>\r
+ where\r
+ D: serde::Deserializer<'de>,\r
+ {\r
+ #[derive(Deserialize)]\r
+ #[serde(transparent)]\r
+ struct Wrapper {\r
+ #[serde(deserialize_with = "SemanticToken::deserialize_tokens")]\r
+ tokens: Vec<SemanticToken>,\r
+ }\r
+\r
+ Ok(Option::<Wrapper>::deserialize(deserializer)?.map(|wrapper| wrapper.tokens))\r
+ }\r
+\r
+ fn serialize_tokens_opt<S>(\r
+ data: &Option<Vec<SemanticToken>>,\r
+ serializer: S,\r
+ ) -> Result<S::Ok, S::Error>\r
+ where\r
+ S: serde::Serializer,\r
+ {\r
+ #[derive(Serialize)]\r
+ #[serde(transparent)]\r
+ struct Wrapper {\r
+ #[serde(serialize_with = "SemanticToken::serialize_tokens")]\r
+ tokens: Vec<SemanticToken>,\r
+ }\r
+\r
+ let opt = data.as_ref().map(|t| Wrapper { tokens: t.to_vec() });\r
+\r
+ opt.serialize(serializer)\r
+ }\r
+}\r
+\r
+/// @since 3.16.0\r
+#[derive(Debug, Eq, PartialEq, Clone, Default, Deserialize, Serialize)]\r
+#[serde(rename_all = "camelCase")]\r
+pub struct SemanticTokens {\r
+ /// An optional result id. If provided and clients support delta updating\r
+ /// the client will include the result id in the next semantic token request.\r
+ /// A server can then instead of computing all semantic tokens again simply\r
+ /// send a delta.\r
+ #[serde(skip_serializing_if = "Option::is_none")]\r
+ pub result_id: Option<String>,\r
+\r
+ /// The actual tokens. For a detailed description about how the data is\r
+ /// structured please see\r
+ /// <https://github.com/microsoft/vscode-extension-samples/blob/5ae1f7787122812dcc84e37427ca90af5ee09f14/semantic-tokens-sample/vscode.proposed.d.ts#L71>\r
+ #[serde(\r
+ deserialize_with = "SemanticToken::deserialize_tokens",\r
+ serialize_with = "SemanticToken::serialize_tokens"\r
+ )]\r
+ pub data: Vec<SemanticToken>,\r
+}\r
+\r
+/// @since 3.16.0\r
+#[derive(Debug, Eq, PartialEq, Clone, Default, Deserialize, Serialize)]\r
+#[serde(rename_all = "camelCase")]\r
+pub struct SemanticTokensPartialResult {\r
+ #[serde(\r
+ deserialize_with = "SemanticToken::deserialize_tokens",\r
+ serialize_with = "SemanticToken::serialize_tokens"\r
+ )]\r
+ pub data: Vec<SemanticToken>,\r
+}\r
+\r
+#[derive(Debug, Eq, PartialEq, Clone, Deserialize, Serialize)]\r
+#[serde(rename_all = "camelCase")]\r
+#[serde(untagged)]\r
+pub enum SemanticTokensResult {\r
+ Tokens(SemanticTokens),\r
+ Partial(SemanticTokensPartialResult),\r
+}\r
+\r
+impl From<SemanticTokens> for SemanticTokensResult {\r
+ fn from(from: SemanticTokens) -> Self {\r
+ SemanticTokensResult::Tokens(from)\r
+ }\r
+}\r
+\r
+impl From<SemanticTokensPartialResult> for SemanticTokensResult {\r
+ fn from(from: SemanticTokensPartialResult) -> Self {\r
+ SemanticTokensResult::Partial(from)\r
+ }\r
+}\r
+\r
+/// @since 3.16.0\r
+#[derive(Debug, Eq, PartialEq, Clone, Default, Deserialize, Serialize)]\r
+#[serde(rename_all = "camelCase")]\r
+pub struct SemanticTokensEdit {\r
+ pub start: u32,\r
+ pub delete_count: u32,\r
+\r
+ #[serde(\r
+ default,\r
+ skip_serializing_if = "Option::is_none",\r
+ deserialize_with = "SemanticToken::deserialize_tokens_opt",\r
+ serialize_with = "SemanticToken::serialize_tokens_opt"\r
+ )]\r
+ pub data: Option<Vec<SemanticToken>>,\r
+}\r
+\r
+#[derive(Debug, Eq, PartialEq, Clone, Deserialize, Serialize)]\r
+#[serde(rename_all = "camelCase")]\r
+#[serde(untagged)]\r
+pub enum SemanticTokensFullDeltaResult {\r
+ Tokens(SemanticTokens),\r
+ TokensDelta(SemanticTokensDelta),\r
+ PartialTokensDelta { edits: Vec<SemanticTokensEdit> },\r
+}\r
+\r
+impl From<SemanticTokens> for SemanticTokensFullDeltaResult {\r
+ fn from(from: SemanticTokens) -> Self {\r
+ SemanticTokensFullDeltaResult::Tokens(from)\r
+ }\r
+}\r
+\r
+impl From<SemanticTokensDelta> for SemanticTokensFullDeltaResult {\r
+ fn from(from: SemanticTokensDelta) -> Self {\r
+ SemanticTokensFullDeltaResult::TokensDelta(from)\r
+ }\r
+}\r
+\r
+/// @since 3.16.0\r
+#[derive(Debug, Eq, PartialEq, Clone, Default, Deserialize, Serialize)]\r
+#[serde(rename_all = "camelCase")]\r
+pub struct SemanticTokensDelta {\r
+ #[serde(skip_serializing_if = "Option::is_none")]\r
+ pub result_id: Option<String>,\r
+ /// For a detailed description how these edits are structured please see\r
+ /// <https://github.com/microsoft/vscode-extension-samples/blob/5ae1f7787122812dcc84e37427ca90af5ee09f14/semantic-tokens-sample/vscode.proposed.d.ts#L131>\r
+ pub edits: Vec<SemanticTokensEdit>,\r
+}\r
+\r
+/// Capabilities specific to the `textDocument/semanticTokens/*` requests.\r
+///\r
+/// @since 3.16.0\r
+#[derive(Debug, Eq, PartialEq, Clone, Default, Deserialize, Serialize)]\r
+#[serde(rename_all = "camelCase")]\r
+pub struct SemanticTokensClientCapabilities {\r
+ /// Whether implementation supports dynamic registration. If this is set to `true`\r
+ /// the client supports the new `(TextDocumentRegistrationOptions & StaticRegistrationOptions)`\r
+ /// return value for the corresponding server capability as well.\r
+ #[serde(skip_serializing_if = "Option::is_none")]\r
+ pub dynamic_registration: Option<bool>,\r
+\r
+ /// Which requests the client supports and might send to the server\r
+ /// depending on the server's capability. Please note that clients might not\r
+ /// show semantic tokens or degrade some of the user experience if a range\r
+ /// or full request is advertised by the client but not provided by the\r
+ /// server. If for example the client capability `requests.full` and\r
+ /// `request.range` are both set to true but the server only provides a\r
+ /// range provider the client might not render a minimap correctly or might\r
+ /// even decide to not show any semantic tokens at all.\r
+ pub requests: SemanticTokensClientCapabilitiesRequests,\r
+\r
+ /// The token types that the client supports.\r
+ pub token_types: Vec<SemanticTokenType>,\r
+\r
+ /// The token modifiers that the client supports.\r
+ pub token_modifiers: Vec<SemanticTokenModifier>,\r
+\r
+ /// The token formats the clients supports.\r
+ pub formats: Vec<TokenFormat>,\r
+\r
+ /// Whether the client supports tokens that can overlap each other.\r
+ #[serde(skip_serializing_if = "Option::is_none")]\r
+ pub overlapping_token_support: Option<bool>,\r
+\r
+ /// Whether the client supports tokens that can span multiple lines.\r
+ #[serde(skip_serializing_if = "Option::is_none")]\r
+ pub multiline_token_support: Option<bool>,\r
+\r
+ /// Whether the client allows the server to actively cancel a\r
+ /// semantic token request, e.g. supports returning\r
+ /// ErrorCodes.ServerCancelled. If a server does the client\r
+ /// needs to retrigger the request.\r
+ ///\r
+ /// since @3.17.0\r
+ #[serde(skip_serializing_if = "Option::is_none")]\r
+ pub server_cancel_support: Option<bool>,\r
+\r
+ /// Whether the client uses semantic tokens to augment existing\r
+ /// syntax tokens. If set to `true` client side created syntax\r
+ /// tokens and semantic tokens are both used for colorization. If\r
+ /// set to `false` the client only uses the returned semantic tokens\r
+ /// for colorization.\r
+ ///\r
+ /// If the value is `undefined` then the client behavior is not\r
+ /// specified.\r
+ ///\r
+ /// @since 3.17.0\r
+ #[serde(skip_serializing_if = "Option::is_none")]\r
+ pub augments_syntax_tokens: Option<bool>,\r
+}\r
+\r
+#[derive(Debug, Eq, PartialEq, Clone, Default, Deserialize, Serialize)]\r
+#[serde(rename_all = "camelCase")]\r
+pub struct SemanticTokensClientCapabilitiesRequests {\r
+ /// The client will send the `textDocument/semanticTokens/range` request if the server provides a corresponding handler.\r
+ #[serde(skip_serializing_if = "Option::is_none")]\r
+ pub range: Option<bool>,\r
+\r
+ /// The client will send the `textDocument/semanticTokens/full` request if the server provides a corresponding handler.\r
+ #[serde(skip_serializing_if = "Option::is_none")]\r
+ pub full: Option<SemanticTokensFullOptions>,\r
+}\r
+\r
+#[derive(Debug, Eq, PartialEq, Clone, Deserialize, Serialize)]\r
+#[serde(rename_all = "camelCase")]\r
+#[serde(untagged)]\r
+pub enum SemanticTokensFullOptions {\r
+ Bool(bool),\r
+ Delta {\r
+ /// The client will send the `textDocument/semanticTokens/full/delta` request if the server provides a corresponding handler.\r
+ /// The server supports deltas for full documents.\r
+ #[serde(skip_serializing_if = "Option::is_none")]\r
+ delta: Option<bool>,\r
+ },\r
+}\r
+\r
+/// @since 3.16.0\r
+#[derive(Debug, Eq, PartialEq, Clone, Default, Deserialize, Serialize)]\r
+#[serde(rename_all = "camelCase")]\r
+pub struct SemanticTokensOptions {\r
+ #[serde(flatten)]\r
+ pub work_done_progress_options: WorkDoneProgressOptions,\r
+\r
+ /// The legend used by the server\r
+ pub legend: SemanticTokensLegend,\r
+\r
+ /// Server supports providing semantic tokens for a sepcific range\r
+ /// of a document.\r
+ #[serde(skip_serializing_if = "Option::is_none")]\r
+ pub range: Option<bool>,\r
+\r
+ /// Server supports providing semantic tokens for a full document.\r
+ #[serde(skip_serializing_if = "Option::is_none")]\r
+ pub full: Option<SemanticTokensFullOptions>,\r
+}\r
+\r
+#[derive(Debug, Eq, PartialEq, Clone, Deserialize, Serialize)]\r
+#[serde(rename_all = "camelCase")]\r
+pub struct SemanticTokensRegistrationOptions {\r
+ #[serde(flatten)]\r
+ pub text_document_registration_options: TextDocumentRegistrationOptions,\r
+\r
+ #[serde(flatten)]\r
+ pub semantic_tokens_options: SemanticTokensOptions,\r
+\r
+ #[serde(flatten)]\r
+ pub static_registration_options: StaticRegistrationOptions,\r
+}\r
+\r
+#[derive(Debug, Eq, PartialEq, Clone, Deserialize, Serialize)]\r
+#[serde(rename_all = "camelCase")]\r
+#[serde(untagged)]\r
+pub enum SemanticTokensServerCapabilities {\r
+ SemanticTokensOptions(SemanticTokensOptions),\r
+ SemanticTokensRegistrationOptions(SemanticTokensRegistrationOptions),\r
+}\r
+\r
+impl From<SemanticTokensOptions> for SemanticTokensServerCapabilities {\r
+ fn from(from: SemanticTokensOptions) -> Self {\r
+ SemanticTokensServerCapabilities::SemanticTokensOptions(from)\r
+ }\r
+}\r
+\r
+impl From<SemanticTokensRegistrationOptions> for SemanticTokensServerCapabilities {\r
+ fn from(from: SemanticTokensRegistrationOptions) -> Self {\r
+ SemanticTokensServerCapabilities::SemanticTokensRegistrationOptions(from)\r
+ }\r
+}\r
+\r
+#[derive(Debug, Eq, PartialEq, Clone, Deserialize, Serialize)]\r
+#[serde(rename_all = "camelCase")]\r
+pub struct SemanticTokensWorkspaceClientCapabilities {\r
+ /// Whether the client implementation supports a refresh request sent from\r
+ /// the server to the client.\r
+ ///\r
+ /// Note that this event is global and will force the client to refresh all\r
+ /// semantic tokens currently shown. It should be used with absolute care\r
+ /// and is useful for situation where a server for example detect a project\r
+ /// wide change that requires such a calculation.\r
+ pub refresh_support: Option<bool>,\r
+}\r
+\r
+#[derive(Debug, Eq, PartialEq, Clone, Deserialize, Serialize)]\r
+#[serde(rename_all = "camelCase")]\r
+pub struct SemanticTokensParams {\r
+ #[serde(flatten)]\r
+ pub work_done_progress_params: WorkDoneProgressParams,\r
+\r
+ #[serde(flatten)]\r
+ pub partial_result_params: PartialResultParams,\r
+\r
+ /// The text document.\r
+ pub text_document: TextDocumentIdentifier,\r
+}\r
+\r
+#[derive(Debug, Eq, PartialEq, Clone, Deserialize, Serialize)]\r
+#[serde(rename_all = "camelCase")]\r
+pub struct SemanticTokensDeltaParams {\r
+ #[serde(flatten)]\r
+ pub work_done_progress_params: WorkDoneProgressParams,\r
+\r
+ #[serde(flatten)]\r
+ pub partial_result_params: PartialResultParams,\r
+\r
+ /// The text document.\r
+ pub text_document: TextDocumentIdentifier,\r
+\r
+ /// The result id of a previous response. The result Id can either point to a full response\r
+ /// or a delta response depending on what was recevied last.\r
+ pub previous_result_id: String,\r
+}\r
+\r
+#[derive(Debug, Eq, PartialEq, Clone, Deserialize, Serialize)]\r
+#[serde(rename_all = "camelCase")]\r
+pub struct SemanticTokensRangeParams {\r
+ #[serde(flatten)]\r
+ pub work_done_progress_params: WorkDoneProgressParams,\r
+\r
+ #[serde(flatten)]\r
+ pub partial_result_params: PartialResultParams,\r
+\r
+ /// The text document.\r
+ pub text_document: TextDocumentIdentifier,\r
+\r
+ /// The range the semantic tokens are requested for.\r
+ pub range: Range,\r
+}\r
+\r
+#[derive(Debug, Eq, PartialEq, Clone, Deserialize, Serialize)]\r
+#[serde(rename_all = "camelCase")]\r
+#[serde(untagged)]\r
+pub enum SemanticTokensRangeResult {\r
+ Tokens(SemanticTokens),\r
+ Partial(SemanticTokensPartialResult),\r
+}\r
+\r
+impl From<SemanticTokens> for SemanticTokensRangeResult {\r
+ fn from(tokens: SemanticTokens) -> Self {\r
+ SemanticTokensRangeResult::Tokens(tokens)\r
+ }\r
+}\r
+\r
+impl From<SemanticTokensPartialResult> for SemanticTokensRangeResult {\r
+ fn from(partial: SemanticTokensPartialResult) -> Self {\r
+ SemanticTokensRangeResult::Partial(partial)\r
+ }\r
+}\r
+\r
+#[cfg(test)]\r
+mod tests {\r
+ use super::*;\r
+ use crate::tests::{test_deserialization, test_serialization};\r
+\r
+ #[test]\r
+ fn test_semantic_tokens_support_serialization() {\r
+ test_serialization(\r
+ &SemanticTokens {\r
+ result_id: None,\r
+ data: vec![],\r
+ },\r
+ r#"{"data":[]}"#,\r
+ );\r
+\r
+ test_serialization(\r
+ &SemanticTokens {\r
+ result_id: None,\r
+ data: vec![SemanticToken {\r
+ delta_line: 2,\r
+ delta_start: 5,\r
+ length: 3,\r
+ token_type: 0,\r
+ token_modifiers_bitset: 3,\r
+ }],\r
+ },\r
+ r#"{"data":[2,5,3,0,3]}"#,\r
+ );\r
+\r
+ test_serialization(\r
+ &SemanticTokens {\r
+ result_id: None,\r
+ data: vec![\r
+ SemanticToken {\r
+ delta_line: 2,\r
+ delta_start: 5,\r
+ length: 3,\r
+ token_type: 0,\r
+ token_modifiers_bitset: 3,\r
+ },\r
+ SemanticToken {\r
+ delta_line: 0,\r
+ delta_start: 5,\r
+ length: 4,\r
+ token_type: 1,\r
+ token_modifiers_bitset: 0,\r
+ },\r
+ ],\r
+ },\r
+ r#"{"data":[2,5,3,0,3,0,5,4,1,0]}"#,\r
+ );\r
+ }\r
+\r
+ #[test]\r
+ fn test_semantic_tokens_support_deserialization() {\r
+ test_deserialization(\r
+ r#"{"data":[]}"#,\r
+ &SemanticTokens {\r
+ result_id: None,\r
+ data: vec![],\r
+ },\r
+ );\r
+\r
+ test_deserialization(\r
+ r#"{"data":[2,5,3,0,3]}"#,\r
+ &SemanticTokens {\r
+ result_id: None,\r
+ data: vec![SemanticToken {\r
+ delta_line: 2,\r
+ delta_start: 5,\r
+ length: 3,\r
+ token_type: 0,\r
+ token_modifiers_bitset: 3,\r
+ }],\r
+ },\r
+ );\r
+\r
+ test_deserialization(\r
+ r#"{"data":[2,5,3,0,3,0,5,4,1,0]}"#,\r
+ &SemanticTokens {\r
+ result_id: None,\r
+ data: vec![\r
+ SemanticToken {\r
+ delta_line: 2,\r
+ delta_start: 5,\r
+ length: 3,\r
+ token_type: 0,\r
+ token_modifiers_bitset: 3,\r
+ },\r
+ SemanticToken {\r
+ delta_line: 0,\r
+ delta_start: 5,\r
+ length: 4,\r
+ token_type: 1,\r
+ token_modifiers_bitset: 0,\r
+ },\r
+ ],\r
+ },\r
+ );\r
+ }\r
+\r
+ #[test]\r
+ #[should_panic]\r
+ fn test_semantic_tokens_support_deserialization_err() {\r
+ test_deserialization(\r
+ r#"{"data":[1]}"#,\r
+ &SemanticTokens {\r
+ result_id: None,\r
+ data: vec![],\r
+ },\r
+ );\r
+ }\r
+\r
+ #[test]\r
+ fn test_semantic_tokens_edit_support_deserialization() {\r
+ test_deserialization(\r
+ r#"{"start":0,"deleteCount":1,"data":[2,5,3,0,3,0,5,4,1,0]}"#,\r
+ &SemanticTokensEdit {\r
+ start: 0,\r
+ delete_count: 1,\r
+ data: Some(vec![\r
+ SemanticToken {\r
+ delta_line: 2,\r
+ delta_start: 5,\r
+ length: 3,\r
+ token_type: 0,\r
+ token_modifiers_bitset: 3,\r
+ },\r
+ SemanticToken {\r
+ delta_line: 0,\r
+ delta_start: 5,\r
+ length: 4,\r
+ token_type: 1,\r
+ token_modifiers_bitset: 0,\r
+ },\r
+ ]),\r
+ },\r
+ );\r
+\r
+ test_deserialization(\r
+ r#"{"start":0,"deleteCount":1}"#,\r
+ &SemanticTokensEdit {\r
+ start: 0,\r
+ delete_count: 1,\r
+ data: None,\r
+ },\r
+ );\r
+ }\r
+\r
+ #[test]\r
+ fn test_semantic_tokens_edit_support_serialization() {\r
+ test_serialization(\r
+ &SemanticTokensEdit {\r
+ start: 0,\r
+ delete_count: 1,\r
+ data: Some(vec![\r
+ SemanticToken {\r
+ delta_line: 2,\r
+ delta_start: 5,\r
+ length: 3,\r
+ token_type: 0,\r
+ token_modifiers_bitset: 3,\r
+ },\r
+ SemanticToken {\r
+ delta_line: 0,\r
+ delta_start: 5,\r
+ length: 4,\r
+ token_type: 1,\r
+ token_modifiers_bitset: 0,\r
+ },\r
+ ]),\r
+ },\r
+ r#"{"start":0,"deleteCount":1,"data":[2,5,3,0,3,0,5,4,1,0]}"#,\r
+ );\r
+\r
+ test_serialization(\r
+ &SemanticTokensEdit {\r
+ start: 0,\r
+ delete_count: 1,\r
+ data: None,\r
+ },\r
+ r#"{"start":0,"deleteCount":1}"#,\r
+ );\r
+ }\r
+}\r
projects / rustc.git / blobdiff