//! The `language` crate provides a large chunk of Zed's language-related//! features (the other big contributors being project and lsp crates that revolve around LSP features).//! Namely, this crate://! - Provides [`Language`], [`Grammar`] and [`LanguageRegistry`] types that//! use Tree-sitter to provide syntax highlighting to the editor; note though that `language` doesn't perform the highlighting by itself. It only maps ranges in a buffer to colors. Treesitter is also used for buffer outlines (lists of symbols in a buffer)//! - Exposes [`LanguageConfig`] that describes how constructs (like brackets or line comments) should be handled by the editor for a source file of a particular language.//!//! Notably we do *not* assign a single language to a single file; in real world a single file can consist of multiple programming languages - HTML is a good example of that - and `language` crate tends to reflect that status quo in it's API.mod buffer;mod diagnostic_set;mod highlight_map;pub mod language_settings;mod outline;pub mod proto;mod syntax_map; #[cfg(test)]mod buffer_tests;pub mod markdown; use anyhow::{anyhow, Context, Result};use async_trait::async_trait;use collections::{HashMap, HashSet};use futures::{ channel::{mpsc, oneshot}, future::Shared, FutureExt, TryFutureExt as _,};use gpui::{AppContext, AsyncAppContext, BackgroundExecutor, Task};pub use highlight_map::HighlightMap;use lazy_static::lazy_static;use lsp::{CodeActionKind, LanguageServerBinary};use parking_lot::{Mutex, RwLock};use postage::watch;use regex::Regex;use serde::{de, Deserialize, Deserializer};use serde_json::Value;use std::{ any::Any, borrow::Cow, cell::RefCell, fmt::Debug, hash::Hash, mem, ops::{Not, Range}, path::{Path, PathBuf}, str, sync::{ atomic::{AtomicU64, AtomicUsize, Ordering::SeqCst}, Arc, },};use syntax_map::SyntaxSnapshot;use theme::{SyntaxTheme, Theme};use tree_sitter::{self, Query};use unicase::UniCase;use util::{http::HttpClient, paths::PathExt};use util::{post_inc, ResultExt, TryFutureExt as _, UnwrapFuture}; pub use buffer::Operation;pub use buffer::*;pub use diagnostic_set::DiagnosticEntry;pub use lsp::LanguageServerId;pub use outline::{Outline, OutlineItem};pub use syntax_map::{OwnedSyntaxLayer, SyntaxLayer};pub use text::LineEnding;pub use tree_sitter::{Parser, Tree}; /// Initializes the `language` crate.////// This should be called before making use of items from the create.pub fn init(cx: &mut AppContext) { language_settings::init(cx);} #[derive(Clone, Default)]struct LspBinaryStatusSender { txs: Arc<Mutex<Vec<mpsc::UnboundedSender<(Arc<Language>, LanguageServerBinaryStatus)>>>>,} impl LspBinaryStatusSender { fn subscribe(&self) -> mpsc::UnboundedReceiver<(Arc<Language>, LanguageServerBinaryStatus)> { let (tx, rx) = mpsc::unbounded(); self.txs.lock().push(tx); rx } fn send(&self, language: Arc<Language>, status: LanguageServerBinaryStatus) { let mut txs = self.txs.lock(); txs.retain(|tx| { tx.unbounded_send((language.clone(), status.clone())) .is_ok() }); }} thread_local! { static PARSER: RefCell<Parser> = { RefCell::new(Parser::new()) };} lazy_static! { pub(crate) static ref NEXT_GRAMMAR_ID: AtomicUsize = Default::default(); /// A shared grammar for plain text, exposed for reuse by downstream crates. #[doc(hidden)] pub static ref PLAIN_TEXT: Arc<Language> = Arc::new(Language::new( LanguageConfig { name: "Plain Text".into(), ..Default::default() }, None, ));} /// Types that represent a position in a buffer, and can be converted into/// an LSP position, to send to a language server.pub trait ToLspPosition { /// Converts the value into an LSP position. fn to_lsp_position(self) -> lsp::Position;} /// A name of a language server.#[derive(Clone, Debug, PartialEq, Eq, Hash)]pub struct LanguageServerName(pub Arc<str>); /// Represents a Language Server, with certain cached sync properties./// Uses [`LspAdapter`] under the hood, but calls all 'static' methods/// once at startup, and caches the results.pub struct CachedLspAdapter { pub name: LanguageServerName, pub short_name: &'static str, pub disk_based_diagnostic_sources: Vec<String>, pub disk_based_diagnostics_progress_token: Option<String>, pub language_ids: HashMap<String, String>, pub adapter: Arc<dyn LspAdapter>, pub reinstall_attempt_count: AtomicU64,} impl CachedLspAdapter { pub async fn new(adapter: Arc<dyn LspAdapter>) -> Arc<Self> { let name = adapter.name(); let short_name = adapter.short_name(); let disk_based_diagnostic_sources = adapter.disk_based_diagnostic_sources(); let disk_based_diagnostics_progress_token = adapter.disk_based_diagnostics_progress_token(); let language_ids = adapter.language_ids(); Arc::new(CachedLspAdapter { name, short_name, disk_based_diagnostic_sources, disk_based_diagnostics_progress_token, language_ids, adapter, reinstall_attempt_count: AtomicU64::new(0), }) } pub async fn fetch_latest_server_version( &self, delegate: &dyn LspAdapterDelegate, ) -> Result<Box<dyn 'static + Send + Any>> { self.adapter.fetch_latest_server_version(delegate).await } pub fn will_fetch_server( &self, delegate: &Arc<dyn LspAdapterDelegate>, cx: &mut AsyncAppContext, ) -> Option<Task<Result<()>>> { self.adapter.will_fetch_server(delegate, cx) } pub fn will_start_server( &self, delegate: &Arc<dyn LspAdapterDelegate>, cx: &mut AsyncAppContext, ) -> Option<Task<Result<()>>> { self.adapter.will_start_server(delegate, cx) } pub async fn fetch_server_binary( &self, version: Box<dyn 'static + Send + Any>, container_dir: PathBuf, delegate: &dyn LspAdapterDelegate, ) -> Result<LanguageServerBinary> { self.adapter .fetch_server_binary(version, container_dir, delegate) .await } pub async fn cached_server_binary( &self, container_dir: PathBuf, delegate: &dyn LspAdapterDelegate, ) -> Option<LanguageServerBinary> { self.adapter .cached_server_binary(container_dir, delegate) .await } pub fn can_be_reinstalled(&self) -> bool { self.adapter.can_be_reinstalled() } pub async fn installation_test_binary( &self, container_dir: PathBuf, ) -> Option<LanguageServerBinary> { self.adapter.installation_test_binary(container_dir).await } pub fn code_action_kinds(&self) -> Option<Vec<CodeActionKind>> { self.adapter.code_action_kinds() } pub fn workspace_configuration(&self, workspace_root: &Path, cx: &mut AppContext) -> Value { self.adapter.workspace_configuration(workspace_root, cx) } pub fn process_diagnostics(&self, params: &mut lsp::PublishDiagnosticsParams) { self.adapter.process_diagnostics(params) } pub async fn process_completion(&self, completion_item: &mut lsp::CompletionItem) { self.adapter.process_completion(completion_item).await } pub async fn label_for_completion( &self, completion_item: &lsp::CompletionItem, language: &Arc<Language>, ) -> Option<CodeLabel> { self.adapter .label_for_completion(completion_item, language) .await } pub async fn label_for_symbol( &self, name: &str, kind: lsp::SymbolKind, language: &Arc<Language>, ) -> Option<CodeLabel> { self.adapter.label_for_symbol(name, kind, language).await } pub fn prettier_plugins(&self) -> &[&'static str] { self.adapter.prettier_plugins() }} /// [`LspAdapterDelegate`] allows [`LspAdapter]` implementations to interface with the application// e.g. to display a notification or fetch data from the web.pub trait LspAdapterDelegate: Send + Sync { fn show_notification(&self, message: &str, cx: &mut AppContext); fn http_client(&self) -> Arc<dyn HttpClient>;} #[async_trait]pub trait LspAdapter: 'static + Send + Sync { fn name(&self) -> LanguageServerName; fn short_name(&self) -> &'static str; async fn fetch_latest_server_version( &self, delegate: &dyn LspAdapterDelegate, ) -> Result<Box<dyn 'static + Send + Any>>; fn will_fetch_server( &self, _: &Arc<dyn LspAdapterDelegate>, _: &mut AsyncAppContext, ) -> Option<Task<Result<()>>> { None } fn will_start_server( &self, _: &Arc<dyn LspAdapterDelegate>, _: &mut AsyncAppContext, ) -> Option<Task<Result<()>>> { None } async fn fetch_server_binary( &self, version: Box<dyn 'static + Send + Any>, container_dir: PathBuf, delegate: &dyn LspAdapterDelegate, ) -> Result<LanguageServerBinary>; async fn cached_server_binary( &self, container_dir: PathBuf, delegate: &dyn LspAdapterDelegate, ) -> Option<LanguageServerBinary>; /// Returns `true` if a language server can be reinstalled. /// /// If language server initialization fails, a reinstallation will be attempted unless the value returned from this method is `false`. /// /// Implementations that rely on software already installed on user's system /// should have [`can_be_reinstalled`](Self::can_be_reinstalled) return `false`. fn can_be_reinstalled(&self) -> bool { true } async fn installation_test_binary( &self, container_dir: PathBuf, ) -> Option<LanguageServerBinary>; fn process_diagnostics(&self, _: &mut lsp::PublishDiagnosticsParams) {} /// A callback called for each [`lsp::CompletionItem`] obtained from LSP server. /// Some LspAdapter implementations might want to modify the obtained item to /// change how it's displayed. async fn process_completion(&self, _: &mut lsp::CompletionItem) {} async fn label_for_completion( &self, _: &lsp::CompletionItem, _: &Arc<Language>, ) -> Option<CodeLabel> { None } async fn label_for_symbol( &self, _: &str, _: lsp::SymbolKind, _: &Arc<Language>, ) -> Option<CodeLabel> { None } /// Returns initialization options that are going to be sent to a LSP server as a part of [`lsp::InitializeParams`] fn initialization_options(&self) -> Option<Value> { None } fn workspace_configuration(&self, _workspace_root: &Path, _cx: &mut AppContext) -> Value { serde_json::json!({}) } /// Returns a list of code actions supported by a given LspAdapter fn code_action_kinds(&self) -> Option<Vec<CodeActionKind>> { Some(vec![ CodeActionKind::EMPTY, CodeActionKind::QUICKFIX, CodeActionKind::REFACTOR, CodeActionKind::REFACTOR_EXTRACT, CodeActionKind::SOURCE, ]) } fn disk_based_diagnostic_sources(&self) -> Vec<String> { Default::default() } fn disk_based_diagnostics_progress_token(&self) -> Option<String> { None } fn language_ids(&self) -> HashMap<String, String> { Default::default() } fn prettier_plugins(&self) -> &[&'static str] { &[] }} #[derive(Clone, Debug, PartialEq, Eq)]pub struct CodeLabel { /// The text to display. pub text: String, /// Syntax highlighting runs. pub runs: Vec<(Range<usize>, HighlightId)>, /// The portion of the text that should be used in fuzzy filtering. pub filter_range: Range<usize>,} #[derive(Clone, Deserialize)]pub struct LanguageConfig { /// Human-readable name of the language. pub name: Arc<str>, // The name of the grammar in a WASM bundle (experimental). pub grammar_name: Option<Arc<str>>, /// Given a list of `LanguageConfig`'s, the language of a file can be determined based on the path extension matching any of the `path_suffixes`. pub path_suffixes: Vec<String>, /// List of bracket types in a language. pub brackets: BracketPairConfig, /// A regex pattern that determines whether the language should be assigned to a file or not. #[serde(default, deserialize_with = "deserialize_regex")] pub first_line_pattern: Option<Regex>, /// If set to true, auto indentation uses last non empty line to determine /// the indentation level for a new line. #[serde(default = "auto_indent_using_last_non_empty_line_default")] pub auto_indent_using_last_non_empty_line: bool, /// A regex that is used to determine whether the indentation level should be /// increased in the following line. #[serde(default, deserialize_with = "deserialize_regex")] pub increase_indent_pattern: Option<Regex>, /// A regex that is used to determine whether the indentation level should be /// decreased in the following line. #[serde(default, deserialize_with = "deserialize_regex")] pub decrease_indent_pattern: Option<Regex>, /// A list of characters that trigger the automatic insertion of a closing /// bracket when they immediately precede the point where an opening /// bracket is inserted. #[serde(default)] pub autoclose_before: String, /// A placeholder used internally by Semantic Index. #[serde(default)] pub collapsed_placeholder: String, /// A line comment string that is inserted in e.g. `toggle comments` action. /// A language can have multiple flavours of line comments. All of the provided line comments are /// used for comment continuations on the next line, but only the first one is used for Editor::ToggleComments. #[serde(default)] pub line_comments: Vec<Arc<str>>, /// Starting and closing characters of a block comment. #[serde(default)] pub block_comment: Option<(Arc<str>, Arc<str>)>, /// A list of language servers that are allowed to run on subranges of a given language. #[serde(default)] pub scope_opt_in_language_servers: Vec<String>, #[serde(default)] pub overrides: HashMap<String, LanguageConfigOverride>, /// A list of characters that Zed should treat as word characters for the /// purpose of features that operate on word boundaries, like 'move to next word end' /// or a whole-word search in buffer search. #[serde(default)] pub word_characters: HashSet<char>, /// The name of a Prettier parser that should be used for this language. #[serde(default)] pub prettier_parser_name: Option<String>,} /// Tree-sitter language queries for a given language.#[derive(Debug, Default)]pub struct LanguageQueries { pub highlights: Option<Cow<'static, str>>, pub brackets: Option<Cow<'static, str>>, pub indents: Option<Cow<'static, str>>, pub outline: Option<Cow<'static, str>>, pub embedding: Option<Cow<'static, str>>, pub injections: Option<Cow<'static, str>>, pub overrides: Option<Cow<'static, str>>,} /// Represents a language for the given range. Some languages (e.g. HTML)/// interleave several languages together, thus a single buffer might actually contain/// several nested scopes.#[derive(Clone, Debug)]pub struct LanguageScope { language: Arc<Language>, override_id: Option<u32>,} #[derive(Clone, Deserialize, Default, Debug)]pub struct LanguageConfigOverride { #[serde(default)] pub line_comments: Override<Vec<Arc<str>>>, #[serde(default)] pub block_comment: Override<(Arc<str>, Arc<str>)>, #[serde(skip_deserializing)] pub disabled_bracket_ixs: Vec<u16>, #[serde(default)] pub word_characters: Override<HashSet<char>>, #[serde(default)] pub opt_into_language_servers: Vec<String>,} #[derive(Clone, Deserialize, Debug)]#[serde(untagged)]pub enum Override<T> { Remove { remove: bool }, Set(T),} impl<T> Default for Override<T> { fn default() -> Self { Override::Remove { remove: false } }} impl<T> Override<T> { fn as_option<'a>(this: Option<&'a Self>, original: Option<&'a T>) -> Option<&'a T> { match this { Some(Self::Set(value)) => Some(value), Some(Self::Remove { remove: true }) => None, Some(Self::Remove { remove: false }) | None => original, } }} Lines 1–500 of 2085. Load more
//! The `language` crate provides a large chunk of Zed's language-related //! features (the other big contributors being project and lsp crates that revolve around LSP features). //! Namely, this crate: //! - Provides [`Language`], [`Grammar`] and [`LanguageRegistry`] types that //! use Tree-sitter to provide syntax highlighting to the editor; note though that `language` doesn't perform the highlighting by itself. It only maps ranges in a buffer to colors. Treesitter is also used for buffer outlines (lists of symbols in a buffer) //! - Exposes [`LanguageConfig`] that describes how constructs (like brackets or line comments) should be handled by the editor for a source file of a particular language. //! //! Notably we do *not* assign a single language to a single file; in real world a single file can consist of multiple programming languages - HTML is a good example of that - and `language` crate tends to reflect that status quo in it's API. mod buffer; mod diagnostic_set; mod highlight_map; pub mod language_settings; mod outline; pub mod proto; mod syntax_map; #[cfg(test)] mod buffer_tests; pub mod markdown; use anyhow::{anyhow, Context, Result}; use async_trait::async_trait; use collections::{HashMap, HashSet}; use futures::{ channel::{mpsc, oneshot}, future::Shared, FutureExt, TryFutureExt as _, }; use gpui::{AppContext, AsyncAppContext, BackgroundExecutor, Task}; pub use highlight_map::HighlightMap; use lazy_static::lazy_static; use lsp::{CodeActionKind, LanguageServerBinary}; use parking_lot::{Mutex, RwLock}; use postage::watch; use regex::Regex; use serde::{de, Deserialize, Deserializer}; use serde_json::Value; use std::{ any::Any, borrow::Cow, cell::RefCell, fmt::Debug, hash::Hash, mem, ops::{Not, Range}, path::{Path, PathBuf}, str, sync::{ atomic::{AtomicU64, AtomicUsize, Ordering::SeqCst}, Arc, }, }; use syntax_map::SyntaxSnapshot; use theme::{SyntaxTheme, Theme}; use tree_sitter::{self, Query}; use unicase::UniCase; use util::{http::HttpClient, paths::PathExt}; use util::{post_inc, ResultExt, TryFutureExt as _, UnwrapFuture}; pub use buffer::Operation; pub use buffer::*; pub use diagnostic_set::DiagnosticEntry; pub use lsp::LanguageServerId; pub use outline::{Outline, OutlineItem}; pub use syntax_map::{OwnedSyntaxLayer, SyntaxLayer}; pub use text::LineEnding; pub use tree_sitter::{Parser, Tree}; /// Initializes the `language` crate. /// /// This should be called before making use of items from the create. pub fn init(cx: &mut AppContext) { language_settings::init(cx); } #[derive(Clone, Default)] struct LspBinaryStatusSender { txs: Arc<Mutex<Vec<mpsc::UnboundedSender<(Arc<Language>, LanguageServerBinaryStatus)>>>>, } impl LspBinaryStatusSender { fn subscribe(&self) -> mpsc::UnboundedReceiver<(Arc<Language>, LanguageServerBinaryStatus)> { let (tx, rx) = mpsc::unbounded(); self.txs.lock().push(tx); rx } fn send(&self, language: Arc<Language>, status: LanguageServerBinaryStatus) { let mut txs = self.txs.lock(); txs.retain(|tx| { tx.unbounded_send((language.clone(), status.clone())) .is_ok() }); } } thread_local! { static PARSER: RefCell<Parser> = { RefCell::new(Parser::new()) }; } lazy_static! { pub(crate) static ref NEXT_GRAMMAR_ID: AtomicUsize = Default::default(); /// A shared grammar for plain text, exposed for reuse by downstream crates. #[doc(hidden)] pub static ref PLAIN_TEXT: Arc<Language> = Arc::new(Language::new( LanguageConfig { name: "Plain Text".into(), ..Default::default() }, None, )); } /// Types that represent a position in a buffer, and can be converted into /// an LSP position, to send to a language server. pub trait ToLspPosition { /// Converts the value into an LSP position. fn to_lsp_position(self) -> lsp::Position; } /// A name of a language server. #[derive(Clone, Debug, PartialEq, Eq, Hash)] pub struct LanguageServerName(pub Arc<str>); /// Represents a Language Server, with certain cached sync properties. /// Uses [`LspAdapter`] under the hood, but calls all 'static' methods /// once at startup, and caches the results. pub struct CachedLspAdapter { pub name: LanguageServerName, pub short_name: &'static str, pub disk_based_diagnostic_sources: Vec<String>, pub disk_based_diagnostics_progress_token: Option<String>, pub language_ids: HashMap<String, String>, pub adapter: Arc<dyn LspAdapter>, pub reinstall_attempt_count: AtomicU64, } impl CachedLspAdapter { pub async fn new(adapter: Arc<dyn LspAdapter>) -> Arc<Self> { let name = adapter.name(); let short_name = adapter.short_name(); let disk_based_diagnostic_sources = adapter.disk_based_diagnostic_sources(); let disk_based_diagnostics_progress_token = adapter.disk_based_diagnostics_progress_token(); let language_ids = adapter.language_ids(); Arc::new(CachedLspAdapter { name, short_name, disk_based_diagnostic_sources, disk_based_diagnostics_progress_token, language_ids, adapter, reinstall_attempt_count: AtomicU64::new(0), }) } pub async fn fetch_latest_server_version( &self, delegate: &dyn LspAdapterDelegate, ) -> Result<Box<dyn 'static + Send + Any>> { self.adapter.fetch_latest_server_version(delegate).await } pub fn will_fetch_server( &self, delegate: &Arc<dyn LspAdapterDelegate>, cx: &mut AsyncAppContext, ) -> Option<Task<Result<()>>> { self.adapter.will_fetch_server(delegate, cx) } pub fn will_start_server( &self, delegate: &Arc<dyn LspAdapterDelegate>, cx: &mut AsyncAppContext, ) -> Option<Task<Result<()>>> { self.adapter.will_start_server(delegate, cx) } pub async fn fetch_server_binary( &self, version: Box<dyn 'static + Send + Any>, container_dir: PathBuf, delegate: &dyn LspAdapterDelegate, ) -> Result<LanguageServerBinary> { self.adapter .fetch_server_binary(version, container_dir, delegate) .await } pub async fn cached_server_binary( &self, container_dir: PathBuf, delegate: &dyn LspAdapterDelegate, ) -> Option<LanguageServerBinary> { self.adapter .cached_server_binary(container_dir, delegate) .await } pub fn can_be_reinstalled(&self) -> bool { self.adapter.can_be_reinstalled() } pub async fn installation_test_binary( &self, container_dir: PathBuf, ) -> Option<LanguageServerBinary> { self.adapter.installation_test_binary(container_dir).await } pub fn code_action_kinds(&self) -> Option<Vec<CodeActionKind>> { self.adapter.code_action_kinds() } pub fn workspace_configuration(&self, workspace_root: &Path, cx: &mut AppContext) -> Value { self.adapter.workspace_configuration(workspace_root, cx) } pub fn process_diagnostics(&self, params: &mut lsp::PublishDiagnosticsParams) { self.adapter.process_diagnostics(params) } pub async fn process_completion(&self, completion_item: &mut lsp::CompletionItem) { self.adapter.process_completion(completion_item).await } pub async fn label_for_completion( &self, completion_item: &lsp::CompletionItem, language: &Arc<Language>, ) -> Option<CodeLabel> { self.adapter .label_for_completion(completion_item, language) .await } pub async fn label_for_symbol( &self, name: &str, kind: lsp::SymbolKind, language: &Arc<Language>, ) -> Option<CodeLabel> { self.adapter.label_for_symbol(name, kind, language).await } pub fn prettier_plugins(&self) -> &[&'static str] { self.adapter.prettier_plugins() } } /// [`LspAdapterDelegate`] allows [`LspAdapter]` implementations to interface with the application // e.g. to display a notification or fetch data from the web. pub trait LspAdapterDelegate: Send + Sync { fn show_notification(&self, message: &str, cx: &mut AppContext); fn http_client(&self) -> Arc<dyn HttpClient>; } #[async_trait] pub trait LspAdapter: 'static + Send + Sync { fn name(&self) -> LanguageServerName; fn short_name(&self) -> &'static str; async fn fetch_latest_server_version( &self, delegate: &dyn LspAdapterDelegate, ) -> Result<Box<dyn 'static + Send + Any>>; fn will_fetch_server( &self, _: &Arc<dyn LspAdapterDelegate>, _: &mut AsyncAppContext, ) -> Option<Task<Result<()>>> { None } fn will_start_server( &self, _: &Arc<dyn LspAdapterDelegate>, _: &mut AsyncAppContext, ) -> Option<Task<Result<()>>> { None } async fn fetch_server_binary( &self, version: Box<dyn 'static + Send + Any>, container_dir: PathBuf, delegate: &dyn LspAdapterDelegate, ) -> Result<LanguageServerBinary>; async fn cached_server_binary( &self, container_dir: PathBuf, delegate: &dyn LspAdapterDelegate, ) -> Option<LanguageServerBinary>; /// Returns `true` if a language server can be reinstalled. /// /// If language server initialization fails, a reinstallation will be attempted unless the value returned from this method is `false`. /// /// Implementations that rely on software already installed on user's system /// should have [`can_be_reinstalled`](Self::can_be_reinstalled) return `false`. fn can_be_reinstalled(&self) -> bool { true } async fn installation_test_binary( &self, container_dir: PathBuf, ) -> Option<LanguageServerBinary>; fn process_diagnostics(&self, _: &mut lsp::PublishDiagnosticsParams) {} /// A callback called for each [`lsp::CompletionItem`] obtained from LSP server. /// Some LspAdapter implementations might want to modify the obtained item to /// change how it's displayed. async fn process_completion(&self, _: &mut lsp::CompletionItem) {} async fn label_for_completion( &self, _: &lsp::CompletionItem, _: &Arc<Language>, ) -> Option<CodeLabel> { None } async fn label_for_symbol( &self, _: &str, _: lsp::SymbolKind, _: &Arc<Language>, ) -> Option<CodeLabel> { None } /// Returns initialization options that are going to be sent to a LSP server as a part of [`lsp::InitializeParams`] fn initialization_options(&self) -> Option<Value> { None } fn workspace_configuration(&self, _workspace_root: &Path, _cx: &mut AppContext) -> Value { serde_json::json!({}) } /// Returns a list of code actions supported by a given LspAdapter fn code_action_kinds(&self) -> Option<Vec<CodeActionKind>> { Some(vec![ CodeActionKind::EMPTY, CodeActionKind::QUICKFIX, CodeActionKind::REFACTOR, CodeActionKind::REFACTOR_EXTRACT, CodeActionKind::SOURCE, ]) } fn disk_based_diagnostic_sources(&self) -> Vec<String> { Default::default() } fn disk_based_diagnostics_progress_token(&self) -> Option<String> { None } fn language_ids(&self) -> HashMap<String, String> { Default::default() } fn prettier_plugins(&self) -> &[&'static str] { &[] } } #[derive(Clone, Debug, PartialEq, Eq)] pub struct CodeLabel { /// The text to display. pub text: String, /// Syntax highlighting runs. pub runs: Vec<(Range<usize>, HighlightId)>, /// The portion of the text that should be used in fuzzy filtering. pub filter_range: Range<usize>, } #[derive(Clone, Deserialize)] pub struct LanguageConfig { /// Human-readable name of the language. pub name: Arc<str>, // The name of the grammar in a WASM bundle (experimental). pub grammar_name: Option<Arc<str>>, /// Given a list of `LanguageConfig`'s, the language of a file can be determined based on the path extension matching any of the `path_suffixes`. pub path_suffixes: Vec<String>, /// List of bracket types in a language. pub brackets: BracketPairConfig, /// A regex pattern that determines whether the language should be assigned to a file or not. #[serde(default, deserialize_with = "deserialize_regex")] pub first_line_pattern: Option<Regex>, /// If set to true, auto indentation uses last non empty line to determine /// the indentation level for a new line. #[serde(default = "auto_indent_using_last_non_empty_line_default")] pub auto_indent_using_last_non_empty_line: bool, /// A regex that is used to determine whether the indentation level should be /// increased in the following line. #[serde(default, deserialize_with = "deserialize_regex")] pub increase_indent_pattern: Option<Regex>, /// A regex that is used to determine whether the indentation level should be /// decreased in the following line. #[serde(default, deserialize_with = "deserialize_regex")] pub decrease_indent_pattern: Option<Regex>, /// A list of characters that trigger the automatic insertion of a closing /// bracket when they immediately precede the point where an opening /// bracket is inserted. #[serde(default)] pub autoclose_before: String, /// A placeholder used internally by Semantic Index. #[serde(default)] pub collapsed_placeholder: String, /// A line comment string that is inserted in e.g. `toggle comments` action. /// A language can have multiple flavours of line comments. All of the provided line comments are /// used for comment continuations on the next line, but only the first one is used for Editor::ToggleComments. #[serde(default)] pub line_comments: Vec<Arc<str>>, /// Starting and closing characters of a block comment. #[serde(default)] pub block_comment: Option<(Arc<str>, Arc<str>)>, /// A list of language servers that are allowed to run on subranges of a given language. #[serde(default)] pub scope_opt_in_language_servers: Vec<String>, #[serde(default)] pub overrides: HashMap<String, LanguageConfigOverride>, /// A list of characters that Zed should treat as word characters for the /// purpose of features that operate on word boundaries, like 'move to next word end' /// or a whole-word search in buffer search. #[serde(default)] pub word_characters: HashSet<char>, /// The name of a Prettier parser that should be used for this language. #[serde(default)] pub prettier_parser_name: Option<String>, } /// Tree-sitter language queries for a given language. #[derive(Debug, Default)] pub struct LanguageQueries { pub highlights: Option<Cow<'static, str>>, pub brackets: Option<Cow<'static, str>>, pub indents: Option<Cow<'static, str>>, pub outline: Option<Cow<'static, str>>, pub embedding: Option<Cow<'static, str>>, pub injections: Option<Cow<'static, str>>, pub overrides: Option<Cow<'static, str>>, } /// Represents a language for the given range. Some languages (e.g. HTML) /// interleave several languages together, thus a single buffer might actually contain /// several nested scopes. #[derive(Clone, Debug)] pub struct LanguageScope { language: Arc<Language>, override_id: Option<u32>, } #[derive(Clone, Deserialize, Default, Debug)] pub struct LanguageConfigOverride { #[serde(default)] pub line_comments: Override<Vec<Arc<str>>>, #[serde(default)] pub block_comment: Override<(Arc<str>, Arc<str>)>, #[serde(skip_deserializing)] pub disabled_bracket_ixs: Vec<u16>, #[serde(default)] pub word_characters: Override<HashSet<char>>, #[serde(default)] pub opt_into_language_servers: Vec<String>, } #[derive(Clone, Deserialize, Debug)] #[serde(untagged)] pub enum Override<T> { Remove { remove: bool }, Set(T), } impl<T> Default for Override<T> { fn default() -> Self { Override::Remove { remove: false } } } impl<T> Override<T> { fn as_option<'a>(this: Option<&'a Self>, original: Option<&'a T>) -> Option<&'a T> { match this { Some(Self::Set(value)) => Some(value), Some(Self::Remove { remove: true }) => None, Some(Self::Remove { remove: false }) | None => original, } } }