Struct CompletionItem 

pub struct CompletionItem<T: TypeProvider> {
    pub label: String,
    pub kind: Option<CompletionItemKind>,
    pub detail: Option<String>,
    pub documentation: Option<String>,
    pub sort_text: Option<String>,
    pub filter_text: Option<String>,
    pub insert_text: Option<String>,
    pub insert_text_format: Option<InsertTextFormat>,
    pub text_edit: Option<TextEdit>,
    pub additional_text_edits: Vec<TextEdit>,
    pub command: Option<T::Command>,
    pub data: T::CompletionData,
}

The actual completion item.

Fields

label: String

This is shown in the ui and also applied as the edit, if insert_text is not set.

kind: Option<CompletionItemKind>

This is used to resolve the icon in the ui.

detail: Option<String>

This is used to provide additional information.

documentation: Option<String>

A doc-comment.

sort_text: Option<String>

A sort text may be used to alter the sorting of this in relation to others.

filter_text: Option<String>

This is used to filter the completion items.

insert_text: Option<String>

The text to insert.

insert_text_format: Option<InsertTextFormat>

The format of the insert text.

text_edit: Option<TextEdit>

A optional edit to be applied to the document.

additional_text_edits: Vec<TextEdit>

An array of additional non overlapping edits.

command: Option<T::Command>

This command will be executed after inserting the completion.

data: T::CompletionData

Additional data to identify this completion item.

Trait Implementations

impl<T: Debug + TypeProvider> Debug for CompletionItem<T>

where T::Command: Debug, T::CompletionData: Debug,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de, T: TypeProvider> Deserialize<'de> for CompletionItem<T>

where T::CompletionData: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T: TypeProvider> Serialize for CompletionItem<T>

where T::CompletionData: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.