2085 lines · 68.2 KB · Rust
RawDownload
//! 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.

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t