1//! The `language` crate provides a large chunk of Zed's language-related
   2//! features (the other big contributors being project and lsp crates that revolve around LSP features).
   3//! Namely, this crate:
   4//! - Provides [`Language`], [`Grammar`] and [`LanguageRegistry`] types that
   5//!   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)
   6//! - 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.
   7//!
   8//! 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 its API.
   9mod buffer;
  10mod diagnostic_set;
  11mod highlight_map;
  12mod language_registry;
  13pub mod language_settings;
  14mod manifest;
  15mod outline;
  16pub mod proto;
  17mod syntax_map;
  18mod task_context;
  19mod text_diff;
  20mod toolchain;
  21
  22#[cfg(test)]
  23pub mod buffer_tests;
  24
  25pub use crate::language_settings::EditPredictionsMode;
  26use crate::language_settings::SoftWrap;
  27use anyhow::{Context as _, Result, anyhow};
  28use async_trait::async_trait;
  29use collections::{HashMap, HashSet, IndexSet};
  30use fs::Fs;
  31use futures::Future;
  32use gpui::{App, AsyncApp, Entity, SharedString, Task};
  33pub use highlight_map::HighlightMap;
  34use http_client::HttpClient;
  35pub use language_registry::{LanguageName, LoadedLanguage};
  36use lsp::{CodeActionKind, InitializeParams, LanguageServerBinary, LanguageServerBinaryOptions};
  37pub use manifest::{ManifestName, ManifestProvider, ManifestQuery};
  38use parking_lot::Mutex;
  39use regex::Regex;
  40use schemars::{
  41    JsonSchema,
  42    r#gen::SchemaGenerator,
  43    schema::{InstanceType, Schema, SchemaObject},
  44};
  45use serde::{Deserialize, Deserializer, Serialize, Serializer, de};
  46use serde_json::Value;
  47use settings::WorktreeId;
  48use smol::future::FutureExt as _;
  49use std::{
  50    any::Any,
  51    ffi::OsStr,
  52    fmt::Debug,
  53    hash::Hash,
  54    mem,
  55    ops::{DerefMut, Range},
  56    path::{Path, PathBuf},
  57    pin::Pin,
  58    str,
  59    sync::{
  60        Arc, LazyLock,
  61        atomic::{AtomicU64, AtomicUsize, Ordering::SeqCst},
  62    },
  63};
  64use std::{num::NonZeroU32, sync::OnceLock};
  65use syntax_map::{QueryCursorHandle, SyntaxSnapshot};
  66use task::RunnableTag;
  67pub use task_context::{ContextProvider, RunnableRange};
  68pub use text_diff::{DiffOptions, line_diff, text_diff, text_diff_with_options, unified_diff};
  69use theme::SyntaxTheme;
  70pub use toolchain::{LanguageToolchainStore, Toolchain, ToolchainList, ToolchainLister};
  71use tree_sitter::{self, Query, QueryCursor, WasmStore, wasmtime};
  72use util::serde::default_true;
  73
  74pub use buffer::Operation;
  75pub use buffer::*;
  76pub use diagnostic_set::{DiagnosticEntry, DiagnosticGroup};
  77pub use language_registry::{
  78    AvailableLanguage, BinaryStatus, LanguageNotFound, LanguageQueries, LanguageRegistry,
  79    QUERY_FILENAME_PREFIXES,
  80};
  81pub use lsp::{LanguageServerId, LanguageServerName};
  82pub use outline::*;
  83pub use syntax_map::{OwnedSyntaxLayer, SyntaxLayer, ToTreeSitterPoint, TreeSitterOptions};
  84pub use text::{AnchorRangeExt, LineEnding};
  85pub use tree_sitter::{Node, Parser, Tree, TreeCursor};
  86
  87/// Initializes the `language` crate.
  88///
  89/// This should be called before making use of items from the create.
  90pub fn init(cx: &mut App) {
  91    language_settings::init(cx);
  92}
  93
  94static QUERY_CURSORS: Mutex<Vec<QueryCursor>> = Mutex::new(vec![]);
  95static PARSERS: Mutex<Vec<Parser>> = Mutex::new(vec![]);
  96
  97pub fn with_parser<F, R>(func: F) -> R
  98where
  99    F: FnOnce(&mut Parser) -> R,
 100{
 101    let mut parser = PARSERS.lock().pop().unwrap_or_else(|| {
 102        let mut parser = Parser::new();
 103        parser
 104            .set_wasm_store(WasmStore::new(&WASM_ENGINE).unwrap())
 105            .unwrap();
 106        parser
 107    });
 108    parser.set_included_ranges(&[]).unwrap();
 109    let result = func(&mut parser);
 110    PARSERS.lock().push(parser);
 111    result
 112}
 113
 114pub fn with_query_cursor<F, R>(func: F) -> R
 115where
 116    F: FnOnce(&mut QueryCursor) -> R,
 117{
 118    let mut cursor = QueryCursorHandle::new();
 119    func(cursor.deref_mut())
 120}
 121
 122static NEXT_LANGUAGE_ID: LazyLock<AtomicUsize> = LazyLock::new(Default::default);
 123static NEXT_GRAMMAR_ID: LazyLock<AtomicUsize> = LazyLock::new(Default::default);
 124static WASM_ENGINE: LazyLock<wasmtime::Engine> = LazyLock::new(|| {
 125    wasmtime::Engine::new(&wasmtime::Config::new()).expect("Failed to create Wasmtime engine")
 126});
 127
 128/// A shared grammar for plain text, exposed for reuse by downstream crates.
 129pub static PLAIN_TEXT: LazyLock<Arc<Language>> = LazyLock::new(|| {
 130    Arc::new(Language::new(
 131        LanguageConfig {
 132            name: "Plain Text".into(),
 133            soft_wrap: Some(SoftWrap::EditorWidth),
 134            matcher: LanguageMatcher {
 135                path_suffixes: vec!["txt".to_owned()],
 136                first_line_pattern: None,
 137            },
 138            ..Default::default()
 139        },
 140        None,
 141    ))
 142});
 143
 144/// Types that represent a position in a buffer, and can be converted into
 145/// an LSP position, to send to a language server.
 146pub trait ToLspPosition {
 147    /// Converts the value into an LSP position.
 148    fn to_lsp_position(self) -> lsp::Position;
 149}
 150
 151#[derive(Debug, Clone, PartialEq, Eq, Hash)]
 152pub struct Location {
 153    pub buffer: Entity<Buffer>,
 154    pub range: Range<Anchor>,
 155}
 156
 157/// Represents a Language Server, with certain cached sync properties.
 158/// Uses [`LspAdapter`] under the hood, but calls all 'static' methods
 159/// once at startup, and caches the results.
 160pub struct CachedLspAdapter {
 161    pub name: LanguageServerName,
 162    pub disk_based_diagnostic_sources: Vec<String>,
 163    pub disk_based_diagnostics_progress_token: Option<String>,
 164    language_ids: HashMap<String, String>,
 165    pub adapter: Arc<dyn LspAdapter>,
 166    pub reinstall_attempt_count: AtomicU64,
 167    cached_binary: futures::lock::Mutex<Option<LanguageServerBinary>>,
 168    manifest_name: OnceLock<Option<ManifestName>>,
 169    attach_kind: OnceLock<Attach>,
 170}
 171
 172impl Debug for CachedLspAdapter {
 173    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 174        f.debug_struct("CachedLspAdapter")
 175            .field("name", &self.name)
 176            .field(
 177                "disk_based_diagnostic_sources",
 178                &self.disk_based_diagnostic_sources,
 179            )
 180            .field(
 181                "disk_based_diagnostics_progress_token",
 182                &self.disk_based_diagnostics_progress_token,
 183            )
 184            .field("language_ids", &self.language_ids)
 185            .field("reinstall_attempt_count", &self.reinstall_attempt_count)
 186            .finish_non_exhaustive()
 187    }
 188}
 189
 190impl CachedLspAdapter {
 191    pub fn new(adapter: Arc<dyn LspAdapter>) -> Arc<Self> {
 192        let name = adapter.name();
 193        let disk_based_diagnostic_sources = adapter.disk_based_diagnostic_sources();
 194        let disk_based_diagnostics_progress_token = adapter.disk_based_diagnostics_progress_token();
 195        let language_ids = adapter.language_ids();
 196
 197        Arc::new(CachedLspAdapter {
 198            name,
 199            disk_based_diagnostic_sources,
 200            disk_based_diagnostics_progress_token,
 201            language_ids,
 202            adapter,
 203            cached_binary: Default::default(),
 204            reinstall_attempt_count: AtomicU64::new(0),
 205            attach_kind: Default::default(),
 206            manifest_name: Default::default(),
 207        })
 208    }
 209
 210    pub fn name(&self) -> LanguageServerName {
 211        self.adapter.name().clone()
 212    }
 213
 214    pub async fn get_language_server_command(
 215        self: Arc<Self>,
 216        delegate: Arc<dyn LspAdapterDelegate>,
 217        toolchains: Arc<dyn LanguageToolchainStore>,
 218        binary_options: LanguageServerBinaryOptions,
 219        cx: &mut AsyncApp,
 220    ) -> Result<LanguageServerBinary> {
 221        let cached_binary = self.cached_binary.lock().await;
 222        self.adapter
 223            .clone()
 224            .get_language_server_command(delegate, toolchains, binary_options, cached_binary, cx)
 225            .await
 226    }
 227
 228    pub fn code_action_kinds(&self) -> Option<Vec<CodeActionKind>> {
 229        self.adapter.code_action_kinds()
 230    }
 231
 232    pub fn process_diagnostics(
 233        &self,
 234        params: &mut lsp::PublishDiagnosticsParams,
 235        server_id: LanguageServerId,
 236        existing_diagnostics: Option<&'_ Buffer>,
 237    ) {
 238        self.adapter
 239            .process_diagnostics(params, server_id, existing_diagnostics)
 240    }
 241
 242    pub fn retain_old_diagnostic(&self, previous_diagnostic: &Diagnostic, cx: &App) -> bool {
 243        self.adapter.retain_old_diagnostic(previous_diagnostic, cx)
 244    }
 245
 246    pub fn diagnostic_message_to_markdown(&self, message: &str) -> Option<String> {
 247        self.adapter.diagnostic_message_to_markdown(message)
 248    }
 249
 250    pub async fn process_completions(&self, completion_items: &mut [lsp::CompletionItem]) {
 251        self.adapter.process_completions(completion_items).await
 252    }
 253
 254    pub async fn labels_for_completions(
 255        &self,
 256        completion_items: &[lsp::CompletionItem],
 257        language: &Arc<Language>,
 258    ) -> Result<Vec<Option<CodeLabel>>> {
 259        self.adapter
 260            .clone()
 261            .labels_for_completions(completion_items, language)
 262            .await
 263    }
 264
 265    pub async fn labels_for_symbols(
 266        &self,
 267        symbols: &[(String, lsp::SymbolKind)],
 268        language: &Arc<Language>,
 269    ) -> Result<Vec<Option<CodeLabel>>> {
 270        self.adapter
 271            .clone()
 272            .labels_for_symbols(symbols, language)
 273            .await
 274    }
 275
 276    pub fn language_id(&self, language_name: &LanguageName) -> String {
 277        self.language_ids
 278            .get(language_name.as_ref())
 279            .cloned()
 280            .unwrap_or_else(|| language_name.lsp_id())
 281    }
 282    pub fn manifest_name(&self) -> Option<ManifestName> {
 283        self.manifest_name
 284            .get_or_init(|| self.adapter.manifest_name())
 285            .clone()
 286    }
 287    pub fn attach_kind(&self) -> Attach {
 288        *self.attach_kind.get_or_init(|| self.adapter.attach_kind())
 289    }
 290}
 291
 292#[derive(Clone, Copy, Debug, PartialEq)]
 293pub enum Attach {
 294    /// Create a single language server instance per subproject root.
 295    InstancePerRoot,
 296    /// Use one shared language server instance for all subprojects within a project.
 297    Shared,
 298}
 299
 300impl Attach {
 301    pub fn root_path(
 302        &self,
 303        root_subproject_path: (WorktreeId, Arc<Path>),
 304    ) -> (WorktreeId, Arc<Path>) {
 305        match self {
 306            Attach::InstancePerRoot => root_subproject_path,
 307            Attach::Shared => (root_subproject_path.0, Arc::from(Path::new(""))),
 308        }
 309    }
 310}
 311
 312/// [`LspAdapterDelegate`] allows [`LspAdapter]` implementations to interface with the application
 313// e.g. to display a notification or fetch data from the web.
 314#[async_trait]
 315pub trait LspAdapterDelegate: Send + Sync {
 316    fn show_notification(&self, message: &str, cx: &mut App);
 317    fn http_client(&self) -> Arc<dyn HttpClient>;
 318    fn worktree_id(&self) -> WorktreeId;
 319    fn worktree_root_path(&self) -> &Path;
 320    fn exists(&self, path: &Path, is_dir: Option<bool>) -> bool;
 321    fn update_status(&self, language: LanguageServerName, status: BinaryStatus);
 322    fn registered_lsp_adapters(&self) -> Vec<Arc<dyn LspAdapter>>;
 323    async fn language_server_download_dir(&self, name: &LanguageServerName) -> Option<Arc<Path>>;
 324
 325    async fn npm_package_installed_version(
 326        &self,
 327        package_name: &str,
 328    ) -> Result<Option<(PathBuf, String)>>;
 329    async fn which(&self, command: &OsStr) -> Option<PathBuf>;
 330    async fn shell_env(&self) -> HashMap<String, String>;
 331    async fn read_text_file(&self, path: PathBuf) -> Result<String>;
 332    async fn try_exec(&self, binary: LanguageServerBinary) -> Result<()>;
 333}
 334
 335#[async_trait(?Send)]
 336pub trait LspAdapter: 'static + Send + Sync {
 337    fn name(&self) -> LanguageServerName;
 338
 339    fn get_language_server_command<'a>(
 340        self: Arc<Self>,
 341        delegate: Arc<dyn LspAdapterDelegate>,
 342        toolchains: Arc<dyn LanguageToolchainStore>,
 343        binary_options: LanguageServerBinaryOptions,
 344        mut cached_binary: futures::lock::MutexGuard<'a, Option<LanguageServerBinary>>,
 345        cx: &'a mut AsyncApp,
 346    ) -> Pin<Box<dyn 'a + Future<Output = Result<LanguageServerBinary>>>> {
 347        async move {
 348            // First we check whether the adapter can give us a user-installed binary.
 349            // If so, we do *not* want to cache that, because each worktree might give us a different
 350            // binary:
 351            //
 352            //      worktree 1: user-installed at `.bin/gopls`
 353            //      worktree 2: user-installed at `~/bin/gopls`
 354            //      worktree 3: no gopls found in PATH -> fallback to Zed installation
 355            //
 356            // We only want to cache when we fall back to the global one,
 357            // because we don't want to download and overwrite our global one
 358            // for each worktree we might have open.
 359            if binary_options.allow_path_lookup {
 360                if let Some(binary) = self.check_if_user_installed(delegate.as_ref(), toolchains, cx).await {
 361                    log::info!(
 362                        "found user-installed language server for {}. path: {:?}, arguments: {:?}",
 363                        self.name().0,
 364                        binary.path,
 365                        binary.arguments
 366                    );
 367                    return Ok(binary);
 368                }
 369            }
 370
 371            if !binary_options.allow_binary_download {
 372                return Err(anyhow!("downloading language servers disabled"));
 373            }
 374
 375            if let Some(cached_binary) = cached_binary.as_ref() {
 376                return Ok(cached_binary.clone());
 377            }
 378
 379            let Some(container_dir) = delegate.language_server_download_dir(&self.name()).await else {
 380                anyhow::bail!("no language server download dir defined")
 381            };
 382
 383            let mut binary = try_fetch_server_binary(self.as_ref(), &delegate, container_dir.to_path_buf(), cx).await;
 384
 385            if let Err(error) = binary.as_ref() {
 386                if let Some(prev_downloaded_binary) = self
 387                    .cached_server_binary(container_dir.to_path_buf(), delegate.as_ref())
 388                    .await
 389                {
 390                    log::info!(
 391                        "failed to fetch newest version of language server {:?}. error: {:?}, falling back to using {:?}",
 392                        self.name(),
 393                        error,
 394                        prev_downloaded_binary.path
 395                    );
 396                    binary = Ok(prev_downloaded_binary);
 397                } else {
 398                    delegate.update_status(
 399                        self.name(),
 400                        BinaryStatus::Failed {
 401                            error: format!("{error:?}"),
 402                        },
 403                    );
 404                }
 405            }
 406
 407            if let Ok(binary) = &binary {
 408                *cached_binary = Some(binary.clone());
 409            }
 410
 411            binary
 412        }
 413        .boxed_local()
 414    }
 415
 416    async fn check_if_user_installed(
 417        &self,
 418        _: &dyn LspAdapterDelegate,
 419        _: Arc<dyn LanguageToolchainStore>,
 420        _: &AsyncApp,
 421    ) -> Option<LanguageServerBinary> {
 422        None
 423    }
 424
 425    async fn fetch_latest_server_version(
 426        &self,
 427        delegate: &dyn LspAdapterDelegate,
 428    ) -> Result<Box<dyn 'static + Send + Any>>;
 429
 430    fn will_fetch_server(
 431        &self,
 432        _: &Arc<dyn LspAdapterDelegate>,
 433        _: &mut AsyncApp,
 434    ) -> Option<Task<Result<()>>> {
 435        None
 436    }
 437
 438    async fn check_if_version_installed(
 439        &self,
 440        _version: &(dyn 'static + Send + Any),
 441        _container_dir: &PathBuf,
 442        _delegate: &dyn LspAdapterDelegate,
 443    ) -> Option<LanguageServerBinary> {
 444        None
 445    }
 446
 447    async fn fetch_server_binary(
 448        &self,
 449        latest_version: Box<dyn 'static + Send + Any>,
 450        container_dir: PathBuf,
 451        delegate: &dyn LspAdapterDelegate,
 452    ) -> Result<LanguageServerBinary>;
 453
 454    async fn cached_server_binary(
 455        &self,
 456        container_dir: PathBuf,
 457        delegate: &dyn LspAdapterDelegate,
 458    ) -> Option<LanguageServerBinary>;
 459
 460    fn process_diagnostics(
 461        &self,
 462        _: &mut lsp::PublishDiagnosticsParams,
 463        _: LanguageServerId,
 464        _: Option<&'_ Buffer>,
 465    ) {
 466    }
 467
 468    /// When processing new `lsp::PublishDiagnosticsParams` diagnostics, whether to retain previous one(s) or not.
 469    fn retain_old_diagnostic(&self, _previous_diagnostic: &Diagnostic, _cx: &App) -> bool {
 470        false
 471    }
 472
 473    /// Post-processes completions provided by the language server.
 474    async fn process_completions(&self, _: &mut [lsp::CompletionItem]) {}
 475
 476    fn diagnostic_message_to_markdown(&self, _message: &str) -> Option<String> {
 477        None
 478    }
 479
 480    async fn labels_for_completions(
 481        self: Arc<Self>,
 482        completions: &[lsp::CompletionItem],
 483        language: &Arc<Language>,
 484    ) -> Result<Vec<Option<CodeLabel>>> {
 485        let mut labels = Vec::new();
 486        for (ix, completion) in completions.iter().enumerate() {
 487            let label = self.label_for_completion(completion, language).await;
 488            if let Some(label) = label {
 489                labels.resize(ix + 1, None);
 490                *labels.last_mut().unwrap() = Some(label);
 491            }
 492        }
 493        Ok(labels)
 494    }
 495
 496    async fn label_for_completion(
 497        &self,
 498        _: &lsp::CompletionItem,
 499        _: &Arc<Language>,
 500    ) -> Option<CodeLabel> {
 501        None
 502    }
 503
 504    async fn labels_for_symbols(
 505        self: Arc<Self>,
 506        symbols: &[(String, lsp::SymbolKind)],
 507        language: &Arc<Language>,
 508    ) -> Result<Vec<Option<CodeLabel>>> {
 509        let mut labels = Vec::new();
 510        for (ix, (name, kind)) in symbols.iter().enumerate() {
 511            let label = self.label_for_symbol(name, *kind, language).await;
 512            if let Some(label) = label {
 513                labels.resize(ix + 1, None);
 514                *labels.last_mut().unwrap() = Some(label);
 515            }
 516        }
 517        Ok(labels)
 518    }
 519
 520    async fn label_for_symbol(
 521        &self,
 522        _: &str,
 523        _: lsp::SymbolKind,
 524        _: &Arc<Language>,
 525    ) -> Option<CodeLabel> {
 526        None
 527    }
 528
 529    /// Returns initialization options that are going to be sent to a LSP server as a part of [`lsp::InitializeParams`]
 530    async fn initialization_options(
 531        self: Arc<Self>,
 532        _: &dyn Fs,
 533        _: &Arc<dyn LspAdapterDelegate>,
 534    ) -> Result<Option<Value>> {
 535        Ok(None)
 536    }
 537
 538    async fn workspace_configuration(
 539        self: Arc<Self>,
 540        _: &dyn Fs,
 541        _: &Arc<dyn LspAdapterDelegate>,
 542        _: Arc<dyn LanguageToolchainStore>,
 543        _cx: &mut AsyncApp,
 544    ) -> Result<Value> {
 545        Ok(serde_json::json!({}))
 546    }
 547
 548    async fn additional_initialization_options(
 549        self: Arc<Self>,
 550        _target_language_server_id: LanguageServerName,
 551        _: &dyn Fs,
 552        _: &Arc<dyn LspAdapterDelegate>,
 553    ) -> Result<Option<Value>> {
 554        Ok(None)
 555    }
 556
 557    async fn additional_workspace_configuration(
 558        self: Arc<Self>,
 559        _target_language_server_id: LanguageServerName,
 560        _: &dyn Fs,
 561        _: &Arc<dyn LspAdapterDelegate>,
 562        _: Arc<dyn LanguageToolchainStore>,
 563        _cx: &mut AsyncApp,
 564    ) -> Result<Option<Value>> {
 565        Ok(None)
 566    }
 567
 568    /// Returns a list of code actions supported by a given LspAdapter
 569    fn code_action_kinds(&self) -> Option<Vec<CodeActionKind>> {
 570        None
 571    }
 572
 573    fn disk_based_diagnostic_sources(&self) -> Vec<String> {
 574        Default::default()
 575    }
 576
 577    fn disk_based_diagnostics_progress_token(&self) -> Option<String> {
 578        None
 579    }
 580
 581    fn language_ids(&self) -> HashMap<String, String> {
 582        Default::default()
 583    }
 584
 585    /// Support custom initialize params.
 586    fn prepare_initialize_params(
 587        &self,
 588        original: InitializeParams,
 589        _: &App,
 590    ) -> Result<InitializeParams> {
 591        Ok(original)
 592    }
 593
 594    fn attach_kind(&self) -> Attach {
 595        Attach::Shared
 596    }
 597
 598    fn manifest_name(&self) -> Option<ManifestName> {
 599        None
 600    }
 601
 602    /// Method only implemented by the default JSON language server adapter.
 603    /// Used to provide dynamic reloading of the JSON schemas used to
 604    /// provide autocompletion and diagnostics in Zed setting and keybind
 605    /// files
 606    fn is_primary_zed_json_schema_adapter(&self) -> bool {
 607        false
 608    }
 609
 610    /// Method only implemented by the default JSON language server adapter.
 611    /// Used to clear the cache of JSON schemas that are used to provide
 612    /// autocompletion and diagnostics in Zed settings and keybinds files.
 613    /// Should not be called unless the callee is sure that
 614    /// `Self::is_primary_zed_json_schema_adapter` returns `true`
 615    async fn clear_zed_json_schema_cache(&self) {
 616        unreachable!(
 617            "Not implemented for this adapter. This method should only be called on the default JSON language server adapter"
 618        );
 619    }
 620}
 621
 622async fn try_fetch_server_binary<L: LspAdapter + 'static + Send + Sync + ?Sized>(
 623    adapter: &L,
 624    delegate: &Arc<dyn LspAdapterDelegate>,
 625    container_dir: PathBuf,
 626    cx: &mut AsyncApp,
 627) -> Result<LanguageServerBinary> {
 628    if let Some(task) = adapter.will_fetch_server(delegate, cx) {
 629        task.await?;
 630    }
 631
 632    let name = adapter.name();
 633    log::info!("fetching latest version of language server {:?}", name.0);
 634    delegate.update_status(name.clone(), BinaryStatus::CheckingForUpdate);
 635
 636    let latest_version = adapter
 637        .fetch_latest_server_version(delegate.as_ref())
 638        .await?;
 639
 640    if let Some(binary) = adapter
 641        .check_if_version_installed(latest_version.as_ref(), &container_dir, delegate.as_ref())
 642        .await
 643    {
 644        log::info!("language server {:?} is already installed", name.0);
 645        delegate.update_status(name.clone(), BinaryStatus::None);
 646        Ok(binary)
 647    } else {
 648        log::info!("downloading language server {:?}", name.0);
 649        delegate.update_status(adapter.name(), BinaryStatus::Downloading);
 650        let binary = adapter
 651            .fetch_server_binary(latest_version, container_dir, delegate.as_ref())
 652            .await;
 653
 654        delegate.update_status(name.clone(), BinaryStatus::None);
 655        binary
 656    }
 657}
 658
 659#[derive(Clone, Debug, Default, PartialEq, Eq)]
 660pub struct CodeLabel {
 661    /// The text to display.
 662    pub text: String,
 663    /// Syntax highlighting runs.
 664    pub runs: Vec<(Range<usize>, HighlightId)>,
 665    /// The portion of the text that should be used in fuzzy filtering.
 666    pub filter_range: Range<usize>,
 667}
 668
 669#[derive(Clone, Deserialize, JsonSchema)]
 670pub struct LanguageConfig {
 671    /// Human-readable name of the language.
 672    pub name: LanguageName,
 673    /// The name of this language for a Markdown code fence block
 674    pub code_fence_block_name: Option<Arc<str>>,
 675    // The name of the grammar in a WASM bundle (experimental).
 676    pub grammar: Option<Arc<str>>,
 677    /// The criteria for matching this language to a given file.
 678    #[serde(flatten)]
 679    pub matcher: LanguageMatcher,
 680    /// List of bracket types in a language.
 681    #[serde(default)]
 682    #[schemars(schema_with = "bracket_pair_config_json_schema")]
 683    pub brackets: BracketPairConfig,
 684    /// If set to true, indicates the language uses significant whitespace/indentation
 685    /// for syntax structure (like Python) rather than brackets/braces for code blocks.
 686    #[serde(default)]
 687    pub significant_indentation: bool,
 688    /// If set to true, auto indentation uses last non empty line to determine
 689    /// the indentation level for a new line.
 690    #[serde(default = "auto_indent_using_last_non_empty_line_default")]
 691    pub auto_indent_using_last_non_empty_line: bool,
 692    // Whether indentation of pasted content should be adjusted based on the context.
 693    #[serde(default)]
 694    pub auto_indent_on_paste: Option<bool>,
 695    /// A regex that is used to determine whether the indentation level should be
 696    /// increased in the following line.
 697    #[serde(default, deserialize_with = "deserialize_regex")]
 698    #[schemars(schema_with = "regex_json_schema")]
 699    pub increase_indent_pattern: Option<Regex>,
 700    /// A regex that is used to determine whether the indentation level should be
 701    /// decreased in the following line.
 702    #[serde(default, deserialize_with = "deserialize_regex")]
 703    #[schemars(schema_with = "regex_json_schema")]
 704    pub decrease_indent_pattern: Option<Regex>,
 705    /// A list of characters that trigger the automatic insertion of a closing
 706    /// bracket when they immediately precede the point where an opening
 707    /// bracket is inserted.
 708    #[serde(default)]
 709    pub autoclose_before: String,
 710    /// A placeholder used internally by Semantic Index.
 711    #[serde(default)]
 712    pub collapsed_placeholder: String,
 713    /// A line comment string that is inserted in e.g. `toggle comments` action.
 714    /// A language can have multiple flavours of line comments. All of the provided line comments are
 715    /// used for comment continuations on the next line, but only the first one is used for Editor::ToggleComments.
 716    #[serde(default)]
 717    pub line_comments: Vec<Arc<str>>,
 718    /// Starting and closing characters of a block comment.
 719    #[serde(default)]
 720    pub block_comment: Option<(Arc<str>, Arc<str>)>,
 721    /// A list of language servers that are allowed to run on subranges of a given language.
 722    #[serde(default)]
 723    pub scope_opt_in_language_servers: Vec<LanguageServerName>,
 724    #[serde(default)]
 725    pub overrides: HashMap<String, LanguageConfigOverride>,
 726    /// A list of characters that Zed should treat as word characters for the
 727    /// purpose of features that operate on word boundaries, like 'move to next word end'
 728    /// or a whole-word search in buffer search.
 729    #[serde(default)]
 730    pub word_characters: HashSet<char>,
 731    /// Whether to indent lines using tab characters, as opposed to multiple
 732    /// spaces.
 733    #[serde(default)]
 734    pub hard_tabs: Option<bool>,
 735    /// How many columns a tab should occupy.
 736    #[serde(default)]
 737    pub tab_size: Option<NonZeroU32>,
 738    /// How to soft-wrap long lines of text.
 739    #[serde(default)]
 740    pub soft_wrap: Option<SoftWrap>,
 741    /// The name of a Prettier parser that will be used for this language when no file path is available.
 742    /// If there's a parser name in the language settings, that will be used instead.
 743    #[serde(default)]
 744    pub prettier_parser_name: Option<String>,
 745    /// If true, this language is only for syntax highlighting via an injection into other
 746    /// languages, but should not appear to the user as a distinct language.
 747    #[serde(default)]
 748    pub hidden: bool,
 749    /// If configured, this language contains JSX style tags, and should support auto-closing of those tags.
 750    #[serde(default)]
 751    pub jsx_tag_auto_close: Option<JsxTagAutoCloseConfig>,
 752    /// A list of characters that Zed should treat as word characters for completion queries.
 753    #[serde(default)]
 754    pub completion_query_characters: HashSet<char>,
 755    /// A list of preferred debuggers for this language.
 756    #[serde(default)]
 757    pub debuggers: IndexSet<SharedString>,
 758    /// Whether to treat documentation comment of this language differently by
 759    /// auto adding prefix on new line, adjusting the indenting , etc.
 760    #[serde(default)]
 761    pub documentation: Option<DocumentationConfig>,
 762}
 763
 764#[derive(Clone, Debug, Serialize, Deserialize, Default, JsonSchema)]
 765pub struct LanguageMatcher {
 766    /// 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`.
 767    #[serde(default)]
 768    pub path_suffixes: Vec<String>,
 769    /// A regex pattern that determines whether the language should be assigned to a file or not.
 770    #[serde(
 771        default,
 772        serialize_with = "serialize_regex",
 773        deserialize_with = "deserialize_regex"
 774    )]
 775    #[schemars(schema_with = "regex_json_schema")]
 776    pub first_line_pattern: Option<Regex>,
 777}
 778
 779/// The configuration for JSX tag auto-closing.
 780#[derive(Clone, Deserialize, JsonSchema)]
 781pub struct JsxTagAutoCloseConfig {
 782    /// The name of the node for a opening tag
 783    pub open_tag_node_name: String,
 784    /// The name of the node for an closing tag
 785    pub close_tag_node_name: String,
 786    /// The name of the node for a complete element with children for open and close tags
 787    pub jsx_element_node_name: String,
 788    /// The name of the node found within both opening and closing
 789    /// tags that describes the tag name
 790    pub tag_name_node_name: String,
 791    /// Alternate Node names for tag names.
 792    /// Specifically needed as TSX represents the name in `<Foo.Bar>`
 793    /// as `member_expression` rather than `identifier` as usual
 794    #[serde(default)]
 795    pub tag_name_node_name_alternates: Vec<String>,
 796    /// Some grammars are smart enough to detect a closing tag
 797    /// that is not valid i.e. doesn't match it's corresponding
 798    /// opening tag or does not have a corresponding opening tag
 799    /// This should be set to the name of the node for invalid
 800    /// closing tags if the grammar contains such a node, otherwise
 801    /// detecting already closed tags will not work properly
 802    #[serde(default)]
 803    pub erroneous_close_tag_node_name: Option<String>,
 804    /// See above for erroneous_close_tag_node_name for details
 805    /// This should be set if the node used for the tag name
 806    /// within erroneous closing tags is different from the
 807    /// normal tag name node name
 808    #[serde(default)]
 809    pub erroneous_close_tag_name_node_name: Option<String>,
 810}
 811
 812/// The configuration for documentation block for this language.
 813#[derive(Clone, Deserialize, JsonSchema)]
 814pub struct DocumentationConfig {
 815    /// A start tag of documentation block.
 816    pub start: Arc<str>,
 817    /// A end tag of documentation block.
 818    pub end: Arc<str>,
 819    /// A character to add as a prefix when a new line is added to a documentation block.
 820    pub prefix: Arc<str>,
 821    /// A indent to add for prefix and end line upon new line.
 822    pub tab_size: NonZeroU32,
 823}
 824
 825/// Represents a language for the given range. Some languages (e.g. HTML)
 826/// interleave several languages together, thus a single buffer might actually contain
 827/// several nested scopes.
 828#[derive(Clone, Debug)]
 829pub struct LanguageScope {
 830    language: Arc<Language>,
 831    override_id: Option<u32>,
 832}
 833
 834#[derive(Clone, Deserialize, Default, Debug, JsonSchema)]
 835pub struct LanguageConfigOverride {
 836    #[serde(default)]
 837    pub line_comments: Override<Vec<Arc<str>>>,
 838    #[serde(default)]
 839    pub block_comment: Override<(Arc<str>, Arc<str>)>,
 840    #[serde(skip)]
 841    pub disabled_bracket_ixs: Vec<u16>,
 842    #[serde(default)]
 843    pub word_characters: Override<HashSet<char>>,
 844    #[serde(default)]
 845    pub completion_query_characters: Override<HashSet<char>>,
 846    #[serde(default)]
 847    pub opt_into_language_servers: Vec<LanguageServerName>,
 848    #[serde(default)]
 849    pub prefer_label_for_snippet: Option<bool>,
 850}
 851
 852#[derive(Clone, Deserialize, Debug, Serialize, JsonSchema)]
 853#[serde(untagged)]
 854pub enum Override<T> {
 855    Remove { remove: bool },
 856    Set(T),
 857}
 858
 859impl<T> Default for Override<T> {
 860    fn default() -> Self {
 861        Override::Remove { remove: false }
 862    }
 863}
 864
 865impl<T> Override<T> {
 866    fn as_option<'a>(this: Option<&'a Self>, original: Option<&'a T>) -> Option<&'a T> {
 867        match this {
 868            Some(Self::Set(value)) => Some(value),
 869            Some(Self::Remove { remove: true }) => None,
 870            Some(Self::Remove { remove: false }) | None => original,
 871        }
 872    }
 873}
 874
 875impl Default for LanguageConfig {
 876    fn default() -> Self {
 877        Self {
 878            name: LanguageName::new(""),
 879            code_fence_block_name: None,
 880            grammar: None,
 881            matcher: LanguageMatcher::default(),
 882            brackets: Default::default(),
 883            auto_indent_using_last_non_empty_line: auto_indent_using_last_non_empty_line_default(),
 884            auto_indent_on_paste: None,
 885            increase_indent_pattern: Default::default(),
 886            decrease_indent_pattern: Default::default(),
 887            autoclose_before: Default::default(),
 888            line_comments: Default::default(),
 889            block_comment: Default::default(),
 890            scope_opt_in_language_servers: Default::default(),
 891            overrides: Default::default(),
 892            word_characters: Default::default(),
 893            collapsed_placeholder: Default::default(),
 894            hard_tabs: None,
 895            tab_size: None,
 896            soft_wrap: None,
 897            prettier_parser_name: None,
 898            hidden: false,
 899            jsx_tag_auto_close: None,
 900            completion_query_characters: Default::default(),
 901            debuggers: Default::default(),
 902            significant_indentation: Default::default(),
 903            documentation: None,
 904        }
 905    }
 906}
 907
 908fn auto_indent_using_last_non_empty_line_default() -> bool {
 909    true
 910}
 911
 912fn deserialize_regex<'de, D: Deserializer<'de>>(d: D) -> Result<Option<Regex>, D::Error> {
 913    let source = Option::<String>::deserialize(d)?;
 914    if let Some(source) = source {
 915        Ok(Some(regex::Regex::new(&source).map_err(de::Error::custom)?))
 916    } else {
 917        Ok(None)
 918    }
 919}
 920
 921fn regex_json_schema(_: &mut SchemaGenerator) -> Schema {
 922    Schema::Object(SchemaObject {
 923        instance_type: Some(InstanceType::String.into()),
 924        ..Default::default()
 925    })
 926}
 927
 928fn serialize_regex<S>(regex: &Option<Regex>, serializer: S) -> Result<S::Ok, S::Error>
 929where
 930    S: Serializer,
 931{
 932    match regex {
 933        Some(regex) => serializer.serialize_str(regex.as_str()),
 934        None => serializer.serialize_none(),
 935    }
 936}
 937
 938#[doc(hidden)]
 939#[cfg(any(test, feature = "test-support"))]
 940pub struct FakeLspAdapter {
 941    pub name: &'static str,
 942    pub initialization_options: Option<Value>,
 943    pub prettier_plugins: Vec<&'static str>,
 944    pub disk_based_diagnostics_progress_token: Option<String>,
 945    pub disk_based_diagnostics_sources: Vec<String>,
 946    pub language_server_binary: LanguageServerBinary,
 947
 948    pub capabilities: lsp::ServerCapabilities,
 949    pub initializer: Option<Box<dyn 'static + Send + Sync + Fn(&mut lsp::FakeLanguageServer)>>,
 950    pub label_for_completion: Option<
 951        Box<
 952            dyn 'static
 953                + Send
 954                + Sync
 955                + Fn(&lsp::CompletionItem, &Arc<Language>) -> Option<CodeLabel>,
 956        >,
 957    >,
 958}
 959
 960/// Configuration of handling bracket pairs for a given language.
 961///
 962/// This struct includes settings for defining which pairs of characters are considered brackets and
 963/// also specifies any language-specific scopes where these pairs should be ignored for bracket matching purposes.
 964#[derive(Clone, Debug, Default, JsonSchema)]
 965pub struct BracketPairConfig {
 966    /// A list of character pairs that should be treated as brackets in the context of a given language.
 967    pub pairs: Vec<BracketPair>,
 968    /// A list of tree-sitter scopes for which a given bracket should not be active.
 969    /// N-th entry in `[Self::disabled_scopes_by_bracket_ix]` contains a list of disabled scopes for an n-th entry in `[Self::pairs]`
 970    #[serde(skip)]
 971    pub disabled_scopes_by_bracket_ix: Vec<Vec<String>>,
 972}
 973
 974impl BracketPairConfig {
 975    pub fn is_closing_brace(&self, c: char) -> bool {
 976        self.pairs.iter().any(|pair| pair.end.starts_with(c))
 977    }
 978}
 979
 980fn bracket_pair_config_json_schema(r#gen: &mut SchemaGenerator) -> Schema {
 981    Option::<Vec<BracketPairContent>>::json_schema(r#gen)
 982}
 983
 984#[derive(Deserialize, JsonSchema)]
 985pub struct BracketPairContent {
 986    #[serde(flatten)]
 987    pub bracket_pair: BracketPair,
 988    #[serde(default)]
 989    pub not_in: Vec<String>,
 990}
 991
 992impl<'de> Deserialize<'de> for BracketPairConfig {
 993    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
 994    where
 995        D: Deserializer<'de>,
 996    {
 997        let result = Vec::<BracketPairContent>::deserialize(deserializer)?;
 998        let mut brackets = Vec::with_capacity(result.len());
 999        let mut disabled_scopes_by_bracket_ix = Vec::with_capacity(result.len());
1000        for entry in result {
1001            brackets.push(entry.bracket_pair);
1002            disabled_scopes_by_bracket_ix.push(entry.not_in);
1003        }
1004
1005        Ok(BracketPairConfig {
1006            pairs: brackets,
1007            disabled_scopes_by_bracket_ix,
1008        })
1009    }
1010}
1011
1012/// Describes a single bracket pair and how an editor should react to e.g. inserting
1013/// an opening bracket or to a newline character insertion in between `start` and `end` characters.
1014#[derive(Clone, Debug, Default, Deserialize, PartialEq, JsonSchema)]
1015pub struct BracketPair {
1016    /// Starting substring for a bracket.
1017    pub start: String,
1018    /// Ending substring for a bracket.
1019    pub end: String,
1020    /// True if `end` should be automatically inserted right after `start` characters.
1021    pub close: bool,
1022    /// True if selected text should be surrounded by `start` and `end` characters.
1023    #[serde(default = "default_true")]
1024    pub surround: bool,
1025    /// True if an extra newline should be inserted while the cursor is in the middle
1026    /// of that bracket pair.
1027    pub newline: bool,
1028}
1029
1030#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Clone, Copy)]
1031pub struct LanguageId(usize);
1032
1033impl LanguageId {
1034    pub(crate) fn new() -> Self {
1035        Self(NEXT_LANGUAGE_ID.fetch_add(1, SeqCst))
1036    }
1037}
1038
1039pub struct Language {
1040    pub(crate) id: LanguageId,
1041    pub(crate) config: LanguageConfig,
1042    pub(crate) grammar: Option<Arc<Grammar>>,
1043    pub(crate) context_provider: Option<Arc<dyn ContextProvider>>,
1044    pub(crate) toolchain: Option<Arc<dyn ToolchainLister>>,
1045}
1046
1047#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Clone, Copy)]
1048pub struct GrammarId(pub usize);
1049
1050impl GrammarId {
1051    pub(crate) fn new() -> Self {
1052        Self(NEXT_GRAMMAR_ID.fetch_add(1, SeqCst))
1053    }
1054}
1055
1056pub struct Grammar {
1057    id: GrammarId,
1058    pub ts_language: tree_sitter::Language,
1059    pub(crate) error_query: Option<Query>,
1060    pub(crate) highlights_query: Option<Query>,
1061    pub(crate) brackets_config: Option<BracketsConfig>,
1062    pub(crate) redactions_config: Option<RedactionConfig>,
1063    pub(crate) runnable_config: Option<RunnableConfig>,
1064    pub(crate) indents_config: Option<IndentConfig>,
1065    pub outline_config: Option<OutlineConfig>,
1066    pub text_object_config: Option<TextObjectConfig>,
1067    pub embedding_config: Option<EmbeddingConfig>,
1068    pub(crate) injection_config: Option<InjectionConfig>,
1069    pub(crate) override_config: Option<OverrideConfig>,
1070    pub(crate) highlight_map: Mutex<HighlightMap>,
1071}
1072
1073struct IndentConfig {
1074    query: Query,
1075    indent_capture_ix: u32,
1076    start_capture_ix: Option<u32>,
1077    end_capture_ix: Option<u32>,
1078    outdent_capture_ix: Option<u32>,
1079}
1080
1081pub struct OutlineConfig {
1082    pub query: Query,
1083    pub item_capture_ix: u32,
1084    pub name_capture_ix: u32,
1085    pub context_capture_ix: Option<u32>,
1086    pub extra_context_capture_ix: Option<u32>,
1087    pub open_capture_ix: Option<u32>,
1088    pub close_capture_ix: Option<u32>,
1089    pub annotation_capture_ix: Option<u32>,
1090}
1091
1092#[derive(Debug, Clone, Copy, PartialEq)]
1093pub enum TextObject {
1094    InsideFunction,
1095    AroundFunction,
1096    InsideClass,
1097    AroundClass,
1098    InsideComment,
1099    AroundComment,
1100}
1101
1102impl TextObject {
1103    pub fn from_capture_name(name: &str) -> Option<TextObject> {
1104        match name {
1105            "function.inside" => Some(TextObject::InsideFunction),
1106            "function.around" => Some(TextObject::AroundFunction),
1107            "class.inside" => Some(TextObject::InsideClass),
1108            "class.around" => Some(TextObject::AroundClass),
1109            "comment.inside" => Some(TextObject::InsideComment),
1110            "comment.around" => Some(TextObject::AroundComment),
1111            _ => None,
1112        }
1113    }
1114
1115    pub fn around(&self) -> Option<Self> {
1116        match self {
1117            TextObject::InsideFunction => Some(TextObject::AroundFunction),
1118            TextObject::InsideClass => Some(TextObject::AroundClass),
1119            TextObject::InsideComment => Some(TextObject::AroundComment),
1120            _ => None,
1121        }
1122    }
1123}
1124
1125pub struct TextObjectConfig {
1126    pub query: Query,
1127    pub text_objects_by_capture_ix: Vec<(u32, TextObject)>,
1128}
1129
1130#[derive(Debug)]
1131pub struct EmbeddingConfig {
1132    pub query: Query,
1133    pub item_capture_ix: u32,
1134    pub name_capture_ix: Option<u32>,
1135    pub context_capture_ix: Option<u32>,
1136    pub collapse_capture_ix: Option<u32>,
1137    pub keep_capture_ix: Option<u32>,
1138}
1139
1140struct InjectionConfig {
1141    query: Query,
1142    content_capture_ix: u32,
1143    language_capture_ix: Option<u32>,
1144    patterns: Vec<InjectionPatternConfig>,
1145}
1146
1147struct RedactionConfig {
1148    pub query: Query,
1149    pub redaction_capture_ix: u32,
1150}
1151
1152#[derive(Clone, Debug, PartialEq)]
1153enum RunnableCapture {
1154    Named(SharedString),
1155    Run,
1156}
1157
1158struct RunnableConfig {
1159    pub query: Query,
1160    /// A mapping from capture indice to capture kind
1161    pub extra_captures: Vec<RunnableCapture>,
1162}
1163
1164struct OverrideConfig {
1165    query: Query,
1166    values: HashMap<u32, OverrideEntry>,
1167}
1168
1169#[derive(Debug)]
1170struct OverrideEntry {
1171    name: String,
1172    range_is_inclusive: bool,
1173    value: LanguageConfigOverride,
1174}
1175
1176#[derive(Default, Clone)]
1177struct InjectionPatternConfig {
1178    language: Option<Box<str>>,
1179    combined: bool,
1180}
1181
1182struct BracketsConfig {
1183    query: Query,
1184    open_capture_ix: u32,
1185    close_capture_ix: u32,
1186    patterns: Vec<BracketsPatternConfig>,
1187}
1188
1189#[derive(Clone, Debug, Default)]
1190struct BracketsPatternConfig {
1191    newline_only: bool,
1192}
1193
1194impl Language {
1195    pub fn new(config: LanguageConfig, ts_language: Option<tree_sitter::Language>) -> Self {
1196        Self::new_with_id(LanguageId::new(), config, ts_language)
1197    }
1198
1199    pub fn id(&self) -> LanguageId {
1200        self.id
1201    }
1202
1203    fn new_with_id(
1204        id: LanguageId,
1205        config: LanguageConfig,
1206        ts_language: Option<tree_sitter::Language>,
1207    ) -> Self {
1208        Self {
1209            id,
1210            config,
1211            grammar: ts_language.map(|ts_language| {
1212                Arc::new(Grammar {
1213                    id: GrammarId::new(),
1214                    highlights_query: None,
1215                    brackets_config: None,
1216                    outline_config: None,
1217                    text_object_config: None,
1218                    embedding_config: None,
1219                    indents_config: None,
1220                    injection_config: None,
1221                    override_config: None,
1222                    redactions_config: None,
1223                    runnable_config: None,
1224                    error_query: Query::new(&ts_language, "(ERROR) @error").ok(),
1225                    ts_language,
1226                    highlight_map: Default::default(),
1227                })
1228            }),
1229            context_provider: None,
1230            toolchain: None,
1231        }
1232    }
1233
1234    pub fn with_context_provider(mut self, provider: Option<Arc<dyn ContextProvider>>) -> Self {
1235        self.context_provider = provider;
1236        self
1237    }
1238
1239    pub fn with_toolchain_lister(mut self, provider: Option<Arc<dyn ToolchainLister>>) -> Self {
1240        self.toolchain = provider;
1241        self
1242    }
1243
1244    pub fn with_queries(mut self, queries: LanguageQueries) -> Result<Self> {
1245        if let Some(query) = queries.highlights {
1246            self = self
1247                .with_highlights_query(query.as_ref())
1248                .context("Error loading highlights query")?;
1249        }
1250        if let Some(query) = queries.brackets {
1251            self = self
1252                .with_brackets_query(query.as_ref())
1253                .context("Error loading brackets query")?;
1254        }
1255        if let Some(query) = queries.indents {
1256            self = self
1257                .with_indents_query(query.as_ref())
1258                .context("Error loading indents query")?;
1259        }
1260        if let Some(query) = queries.outline {
1261            self = self
1262                .with_outline_query(query.as_ref())
1263                .context("Error loading outline query")?;
1264        }
1265        if let Some(query) = queries.embedding {
1266            self = self
1267                .with_embedding_query(query.as_ref())
1268                .context("Error loading embedding query")?;
1269        }
1270        if let Some(query) = queries.injections {
1271            self = self
1272                .with_injection_query(query.as_ref())
1273                .context("Error loading injection query")?;
1274        }
1275        if let Some(query) = queries.overrides {
1276            self = self
1277                .with_override_query(query.as_ref())
1278                .context("Error loading override query")?;
1279        }
1280        if let Some(query) = queries.redactions {
1281            self = self
1282                .with_redaction_query(query.as_ref())
1283                .context("Error loading redaction query")?;
1284        }
1285        if let Some(query) = queries.runnables {
1286            self = self
1287                .with_runnable_query(query.as_ref())
1288                .context("Error loading runnables query")?;
1289        }
1290        if let Some(query) = queries.text_objects {
1291            self = self
1292                .with_text_object_query(query.as_ref())
1293                .context("Error loading textobject query")?;
1294        }
1295        Ok(self)
1296    }
1297
1298    pub fn with_highlights_query(mut self, source: &str) -> Result<Self> {
1299        let grammar = self
1300            .grammar_mut()
1301            .ok_or_else(|| anyhow!("cannot mutate grammar"))?;
1302        grammar.highlights_query = Some(Query::new(&grammar.ts_language, source)?);
1303        Ok(self)
1304    }
1305
1306    pub fn with_runnable_query(mut self, source: &str) -> Result<Self> {
1307        let grammar = self
1308            .grammar_mut()
1309            .ok_or_else(|| anyhow!("cannot mutate grammar"))?;
1310
1311        let query = Query::new(&grammar.ts_language, source)?;
1312        let mut extra_captures = Vec::with_capacity(query.capture_names().len());
1313
1314        for name in query.capture_names().iter() {
1315            let kind = if *name == "run" {
1316                RunnableCapture::Run
1317            } else {
1318                RunnableCapture::Named(name.to_string().into())
1319            };
1320            extra_captures.push(kind);
1321        }
1322
1323        grammar.runnable_config = Some(RunnableConfig {
1324            extra_captures,
1325            query,
1326        });
1327
1328        Ok(self)
1329    }
1330
1331    pub fn with_outline_query(mut self, source: &str) -> Result<Self> {
1332        let grammar = self
1333            .grammar_mut()
1334            .ok_or_else(|| anyhow!("cannot mutate grammar"))?;
1335        let query = Query::new(&grammar.ts_language, source)?;
1336        let mut item_capture_ix = None;
1337        let mut name_capture_ix = None;
1338        let mut context_capture_ix = None;
1339        let mut extra_context_capture_ix = None;
1340        let mut open_capture_ix = None;
1341        let mut close_capture_ix = None;
1342        let mut annotation_capture_ix = None;
1343        get_capture_indices(
1344            &query,
1345            &mut [
1346                ("item", &mut item_capture_ix),
1347                ("name", &mut name_capture_ix),
1348                ("context", &mut context_capture_ix),
1349                ("context.extra", &mut extra_context_capture_ix),
1350                ("open", &mut open_capture_ix),
1351                ("close", &mut close_capture_ix),
1352                ("annotation", &mut annotation_capture_ix),
1353            ],
1354        );
1355        if let Some((item_capture_ix, name_capture_ix)) = item_capture_ix.zip(name_capture_ix) {
1356            grammar.outline_config = Some(OutlineConfig {
1357                query,
1358                item_capture_ix,
1359                name_capture_ix,
1360                context_capture_ix,
1361                extra_context_capture_ix,
1362                open_capture_ix,
1363                close_capture_ix,
1364                annotation_capture_ix,
1365            });
1366        }
1367        Ok(self)
1368    }
1369
1370    pub fn with_text_object_query(mut self, source: &str) -> Result<Self> {
1371        let grammar = self
1372            .grammar_mut()
1373            .ok_or_else(|| anyhow!("cannot mutate grammar"))?;
1374        let query = Query::new(&grammar.ts_language, source)?;
1375
1376        let mut text_objects_by_capture_ix = Vec::new();
1377        for (ix, name) in query.capture_names().iter().enumerate() {
1378            if let Some(text_object) = TextObject::from_capture_name(name) {
1379                text_objects_by_capture_ix.push((ix as u32, text_object));
1380            }
1381        }
1382
1383        grammar.text_object_config = Some(TextObjectConfig {
1384            query,
1385            text_objects_by_capture_ix,
1386        });
1387        Ok(self)
1388    }
1389
1390    pub fn with_embedding_query(mut self, source: &str) -> Result<Self> {
1391        let grammar = self
1392            .grammar_mut()
1393            .ok_or_else(|| anyhow!("cannot mutate grammar"))?;
1394        let query = Query::new(&grammar.ts_language, source)?;
1395        let mut item_capture_ix = None;
1396        let mut name_capture_ix = None;
1397        let mut context_capture_ix = None;
1398        let mut collapse_capture_ix = None;
1399        let mut keep_capture_ix = None;
1400        get_capture_indices(
1401            &query,
1402            &mut [
1403                ("item", &mut item_capture_ix),
1404                ("name", &mut name_capture_ix),
1405                ("context", &mut context_capture_ix),
1406                ("keep", &mut keep_capture_ix),
1407                ("collapse", &mut collapse_capture_ix),
1408            ],
1409        );
1410        if let Some(item_capture_ix) = item_capture_ix {
1411            grammar.embedding_config = Some(EmbeddingConfig {
1412                query,
1413                item_capture_ix,
1414                name_capture_ix,
1415                context_capture_ix,
1416                collapse_capture_ix,
1417                keep_capture_ix,
1418            });
1419        }
1420        Ok(self)
1421    }
1422
1423    pub fn with_brackets_query(mut self, source: &str) -> Result<Self> {
1424        let grammar = self
1425            .grammar_mut()
1426            .ok_or_else(|| anyhow!("cannot mutate grammar"))?;
1427        let query = Query::new(&grammar.ts_language, source)?;
1428        let mut open_capture_ix = None;
1429        let mut close_capture_ix = None;
1430        get_capture_indices(
1431            &query,
1432            &mut [
1433                ("open", &mut open_capture_ix),
1434                ("close", &mut close_capture_ix),
1435            ],
1436        );
1437        let patterns = (0..query.pattern_count())
1438            .map(|ix| {
1439                let mut config = BracketsPatternConfig::default();
1440                for setting in query.property_settings(ix) {
1441                    match setting.key.as_ref() {
1442                        "newline.only" => config.newline_only = true,
1443                        _ => {}
1444                    }
1445                }
1446                config
1447            })
1448            .collect();
1449        if let Some((open_capture_ix, close_capture_ix)) = open_capture_ix.zip(close_capture_ix) {
1450            grammar.brackets_config = Some(BracketsConfig {
1451                query,
1452                open_capture_ix,
1453                close_capture_ix,
1454                patterns,
1455            });
1456        }
1457        Ok(self)
1458    }
1459
1460    pub fn with_indents_query(mut self, source: &str) -> Result<Self> {
1461        let grammar = self
1462            .grammar_mut()
1463            .ok_or_else(|| anyhow!("cannot mutate grammar"))?;
1464        let query = Query::new(&grammar.ts_language, source)?;
1465        let mut indent_capture_ix = None;
1466        let mut start_capture_ix = None;
1467        let mut end_capture_ix = None;
1468        let mut outdent_capture_ix = None;
1469        get_capture_indices(
1470            &query,
1471            &mut [
1472                ("indent", &mut indent_capture_ix),
1473                ("start", &mut start_capture_ix),
1474                ("end", &mut end_capture_ix),
1475                ("outdent", &mut outdent_capture_ix),
1476            ],
1477        );
1478        if let Some(indent_capture_ix) = indent_capture_ix {
1479            grammar.indents_config = Some(IndentConfig {
1480                query,
1481                indent_capture_ix,
1482                start_capture_ix,
1483                end_capture_ix,
1484                outdent_capture_ix,
1485            });
1486        }
1487        Ok(self)
1488    }
1489
1490    pub fn with_injection_query(mut self, source: &str) -> Result<Self> {
1491        let grammar = self
1492            .grammar_mut()
1493            .ok_or_else(|| anyhow!("cannot mutate grammar"))?;
1494        let query = Query::new(&grammar.ts_language, source)?;
1495        let mut language_capture_ix = None;
1496        let mut injection_language_capture_ix = None;
1497        let mut content_capture_ix = None;
1498        let mut injection_content_capture_ix = None;
1499        get_capture_indices(
1500            &query,
1501            &mut [
1502                ("language", &mut language_capture_ix),
1503                ("injection.language", &mut injection_language_capture_ix),
1504                ("content", &mut content_capture_ix),
1505                ("injection.content", &mut injection_content_capture_ix),
1506            ],
1507        );
1508        language_capture_ix = match (language_capture_ix, injection_language_capture_ix) {
1509            (None, Some(ix)) => Some(ix),
1510            (Some(_), Some(_)) => {
1511                return Err(anyhow!(
1512                    "both language and injection.language captures are present"
1513                ));
1514            }
1515            _ => language_capture_ix,
1516        };
1517        content_capture_ix = match (content_capture_ix, injection_content_capture_ix) {
1518            (None, Some(ix)) => Some(ix),
1519            (Some(_), Some(_)) => {
1520                return Err(anyhow!(
1521                    "both content and injection.content captures are present"
1522                ));
1523            }
1524            _ => content_capture_ix,
1525        };
1526        let patterns = (0..query.pattern_count())
1527            .map(|ix| {
1528                let mut config = InjectionPatternConfig::default();
1529                for setting in query.property_settings(ix) {
1530                    match setting.key.as_ref() {
1531                        "language" | "injection.language" => {
1532                            config.language.clone_from(&setting.value);
1533                        }
1534                        "combined" | "injection.combined" => {
1535                            config.combined = true;
1536                        }
1537                        _ => {}
1538                    }
1539                }
1540                config
1541            })
1542            .collect();
1543        if let Some(content_capture_ix) = content_capture_ix {
1544            grammar.injection_config = Some(InjectionConfig {
1545                query,
1546                language_capture_ix,
1547                content_capture_ix,
1548                patterns,
1549            });
1550        }
1551        Ok(self)
1552    }
1553
1554    pub fn with_override_query(mut self, source: &str) -> anyhow::Result<Self> {
1555        let query = {
1556            let grammar = self
1557                .grammar
1558                .as_ref()
1559                .ok_or_else(|| anyhow!("no grammar for language"))?;
1560            Query::new(&grammar.ts_language, source)?
1561        };
1562
1563        let mut override_configs_by_id = HashMap::default();
1564        for (ix, mut name) in query.capture_names().iter().copied().enumerate() {
1565            let mut range_is_inclusive = false;
1566            if name.starts_with('_') {
1567                continue;
1568            }
1569            if let Some(prefix) = name.strip_suffix(".inclusive") {
1570                name = prefix;
1571                range_is_inclusive = true;
1572            }
1573
1574            let value = self.config.overrides.get(name).cloned().unwrap_or_default();
1575            for server_name in &value.opt_into_language_servers {
1576                if !self
1577                    .config
1578                    .scope_opt_in_language_servers
1579                    .contains(server_name)
1580                {
1581                    util::debug_panic!(
1582                        "Server {server_name:?} has been opted-in by scope {name:?} but has not been marked as an opt-in server"
1583                    );
1584                }
1585            }
1586
1587            override_configs_by_id.insert(
1588                ix as u32,
1589                OverrideEntry {
1590                    name: name.to_string(),
1591                    range_is_inclusive,
1592                    value,
1593                },
1594            );
1595        }
1596
1597        let referenced_override_names = self.config.overrides.keys().chain(
1598            self.config
1599                .brackets
1600                .disabled_scopes_by_bracket_ix
1601                .iter()
1602                .flatten(),
1603        );
1604
1605        for referenced_name in referenced_override_names {
1606            if !override_configs_by_id
1607                .values()
1608                .any(|entry| entry.name == *referenced_name)
1609            {
1610                Err(anyhow!(
1611                    "language {:?} has overrides in config not in query: {referenced_name:?}",
1612                    self.config.name
1613                ))?;
1614            }
1615        }
1616
1617        for entry in override_configs_by_id.values_mut() {
1618            entry.value.disabled_bracket_ixs = self
1619                .config
1620                .brackets
1621                .disabled_scopes_by_bracket_ix
1622                .iter()
1623                .enumerate()
1624                .filter_map(|(ix, disabled_scope_names)| {
1625                    if disabled_scope_names.contains(&entry.name) {
1626                        Some(ix as u16)
1627                    } else {
1628                        None
1629                    }
1630                })
1631                .collect();
1632        }
1633
1634        self.config.brackets.disabled_scopes_by_bracket_ix.clear();
1635
1636        let grammar = self
1637            .grammar_mut()
1638            .ok_or_else(|| anyhow!("cannot mutate grammar"))?;
1639        grammar.override_config = Some(OverrideConfig {
1640            query,
1641            values: override_configs_by_id,
1642        });
1643        Ok(self)
1644    }
1645
1646    pub fn with_redaction_query(mut self, source: &str) -> anyhow::Result<Self> {
1647        let grammar = self
1648            .grammar_mut()
1649            .ok_or_else(|| anyhow!("cannot mutate grammar"))?;
1650
1651        let query = Query::new(&grammar.ts_language, source)?;
1652        let mut redaction_capture_ix = None;
1653        get_capture_indices(&query, &mut [("redact", &mut redaction_capture_ix)]);
1654
1655        if let Some(redaction_capture_ix) = redaction_capture_ix {
1656            grammar.redactions_config = Some(RedactionConfig {
1657                query,
1658                redaction_capture_ix,
1659            });
1660        }
1661
1662        Ok(self)
1663    }
1664
1665    fn grammar_mut(&mut self) -> Option<&mut Grammar> {
1666        Arc::get_mut(self.grammar.as_mut()?)
1667    }
1668
1669    pub fn name(&self) -> LanguageName {
1670        self.config.name.clone()
1671    }
1672
1673    pub fn code_fence_block_name(&self) -> Arc<str> {
1674        self.config
1675            .code_fence_block_name
1676            .clone()
1677            .unwrap_or_else(|| self.config.name.as_ref().to_lowercase().into())
1678    }
1679
1680    pub fn context_provider(&self) -> Option<Arc<dyn ContextProvider>> {
1681        self.context_provider.clone()
1682    }
1683
1684    pub fn toolchain_lister(&self) -> Option<Arc<dyn ToolchainLister>> {
1685        self.toolchain.clone()
1686    }
1687
1688    pub fn highlight_text<'a>(
1689        self: &'a Arc<Self>,
1690        text: &'a Rope,
1691        range: Range<usize>,
1692    ) -> Vec<(Range<usize>, HighlightId)> {
1693        let mut result = Vec::new();
1694        if let Some(grammar) = &self.grammar {
1695            let tree = grammar.parse_text(text, None);
1696            let captures =
1697                SyntaxSnapshot::single_tree_captures(range.clone(), text, &tree, self, |grammar| {
1698                    grammar.highlights_query.as_ref()
1699                });
1700            let highlight_maps = vec![grammar.highlight_map()];
1701            let mut offset = 0;
1702            for chunk in
1703                BufferChunks::new(text, range, Some((captures, highlight_maps)), false, None)
1704            {
1705                let end_offset = offset + chunk.text.len();
1706                if let Some(highlight_id) = chunk.syntax_highlight_id {
1707                    if !highlight_id.is_default() {
1708                        result.push((offset..end_offset, highlight_id));
1709                    }
1710                }
1711                offset = end_offset;
1712            }
1713        }
1714        result
1715    }
1716
1717    pub fn path_suffixes(&self) -> &[String] {
1718        &self.config.matcher.path_suffixes
1719    }
1720
1721    pub fn should_autoclose_before(&self, c: char) -> bool {
1722        c.is_whitespace() || self.config.autoclose_before.contains(c)
1723    }
1724
1725    pub fn set_theme(&self, theme: &SyntaxTheme) {
1726        if let Some(grammar) = self.grammar.as_ref() {
1727            if let Some(highlights_query) = &grammar.highlights_query {
1728                *grammar.highlight_map.lock() =
1729                    HighlightMap::new(highlights_query.capture_names(), theme);
1730            }
1731        }
1732    }
1733
1734    pub fn grammar(&self) -> Option<&Arc<Grammar>> {
1735        self.grammar.as_ref()
1736    }
1737
1738    pub fn default_scope(self: &Arc<Self>) -> LanguageScope {
1739        LanguageScope {
1740            language: self.clone(),
1741            override_id: None,
1742        }
1743    }
1744
1745    pub fn lsp_id(&self) -> String {
1746        self.config.name.lsp_id()
1747    }
1748
1749    pub fn prettier_parser_name(&self) -> Option<&str> {
1750        self.config.prettier_parser_name.as_deref()
1751    }
1752
1753    pub fn config(&self) -> &LanguageConfig {
1754        &self.config
1755    }
1756}
1757
1758impl LanguageScope {
1759    pub fn path_suffixes(&self) -> &[String] {
1760        &self.language.path_suffixes()
1761    }
1762
1763    pub fn language_name(&self) -> LanguageName {
1764        self.language.config.name.clone()
1765    }
1766
1767    pub fn collapsed_placeholder(&self) -> &str {
1768        self.language.config.collapsed_placeholder.as_ref()
1769    }
1770
1771    /// Returns line prefix that is inserted in e.g. line continuations or
1772    /// in `toggle comments` action.
1773    pub fn line_comment_prefixes(&self) -> &[Arc<str>] {
1774        Override::as_option(
1775            self.config_override().map(|o| &o.line_comments),
1776            Some(&self.language.config.line_comments),
1777        )
1778        .map_or([].as_slice(), |e| e.as_slice())
1779    }
1780
1781    pub fn block_comment_delimiters(&self) -> Option<(&Arc<str>, &Arc<str>)> {
1782        Override::as_option(
1783            self.config_override().map(|o| &o.block_comment),
1784            self.language.config.block_comment.as_ref(),
1785        )
1786        .map(|e| (&e.0, &e.1))
1787    }
1788
1789    /// Returns a list of language-specific word characters.
1790    ///
1791    /// By default, Zed treats alphanumeric characters (and '_') as word characters for
1792    /// the purpose of actions like 'move to next word end` or whole-word search.
1793    /// It additionally accounts for language's additional word characters.
1794    pub fn word_characters(&self) -> Option<&HashSet<char>> {
1795        Override::as_option(
1796            self.config_override().map(|o| &o.word_characters),
1797            Some(&self.language.config.word_characters),
1798        )
1799    }
1800
1801    /// Returns a list of language-specific characters that are considered part of
1802    /// a completion query.
1803    pub fn completion_query_characters(&self) -> Option<&HashSet<char>> {
1804        Override::as_option(
1805            self.config_override()
1806                .map(|o| &o.completion_query_characters),
1807            Some(&self.language.config.completion_query_characters),
1808        )
1809    }
1810
1811    /// Returns whether to prefer snippet `label` over `new_text` to replace text when
1812    /// completion is accepted.
1813    ///
1814    /// In cases like when cursor is in string or renaming existing function,
1815    /// you don't want to expand function signature instead just want function name
1816    /// to replace existing one.
1817    pub fn prefers_label_for_snippet_in_completion(&self) -> bool {
1818        self.config_override()
1819            .and_then(|o| o.prefer_label_for_snippet)
1820            .unwrap_or(false)
1821    }
1822
1823    /// Returns config to documentation block for this language.
1824    ///
1825    /// Used for documentation styles that require a leading character on each line,
1826    /// such as the asterisk in JSDoc, Javadoc, etc.
1827    pub fn documentation(&self) -> Option<&DocumentationConfig> {
1828        self.language.config.documentation.as_ref()
1829    }
1830
1831    /// Returns a list of bracket pairs for a given language with an additional
1832    /// piece of information about whether the particular bracket pair is currently active for a given language.
1833    pub fn brackets(&self) -> impl Iterator<Item = (&BracketPair, bool)> {
1834        let mut disabled_ids = self
1835            .config_override()
1836            .map_or(&[] as _, |o| o.disabled_bracket_ixs.as_slice());
1837        self.language
1838            .config
1839            .brackets
1840            .pairs
1841            .iter()
1842            .enumerate()
1843            .map(move |(ix, bracket)| {
1844                let mut is_enabled = true;
1845                if let Some(next_disabled_ix) = disabled_ids.first() {
1846                    if ix == *next_disabled_ix as usize {
1847                        disabled_ids = &disabled_ids[1..];
1848                        is_enabled = false;
1849                    }
1850                }
1851                (bracket, is_enabled)
1852            })
1853    }
1854
1855    pub fn should_autoclose_before(&self, c: char) -> bool {
1856        c.is_whitespace() || self.language.config.autoclose_before.contains(c)
1857    }
1858
1859    pub fn language_allowed(&self, name: &LanguageServerName) -> bool {
1860        let config = &self.language.config;
1861        let opt_in_servers = &config.scope_opt_in_language_servers;
1862        if opt_in_servers.contains(name) {
1863            if let Some(over) = self.config_override() {
1864                over.opt_into_language_servers.contains(name)
1865            } else {
1866                false
1867            }
1868        } else {
1869            true
1870        }
1871    }
1872
1873    pub fn override_name(&self) -> Option<&str> {
1874        let id = self.override_id?;
1875        let grammar = self.language.grammar.as_ref()?;
1876        let override_config = grammar.override_config.as_ref()?;
1877        override_config.values.get(&id).map(|e| e.name.as_str())
1878    }
1879
1880    fn config_override(&self) -> Option<&LanguageConfigOverride> {
1881        let id = self.override_id?;
1882        let grammar = self.language.grammar.as_ref()?;
1883        let override_config = grammar.override_config.as_ref()?;
1884        override_config.values.get(&id).map(|e| &e.value)
1885    }
1886}
1887
1888impl Hash for Language {
1889    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
1890        self.id.hash(state)
1891    }
1892}
1893
1894impl PartialEq for Language {
1895    fn eq(&self, other: &Self) -> bool {
1896        self.id.eq(&other.id)
1897    }
1898}
1899
1900impl Eq for Language {}
1901
1902impl Debug for Language {
1903    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1904        f.debug_struct("Language")
1905            .field("name", &self.config.name)
1906            .finish()
1907    }
1908}
1909
1910impl Grammar {
1911    pub fn id(&self) -> GrammarId {
1912        self.id
1913    }
1914
1915    fn parse_text(&self, text: &Rope, old_tree: Option<Tree>) -> Tree {
1916        with_parser(|parser| {
1917            parser
1918                .set_language(&self.ts_language)
1919                .expect("incompatible grammar");
1920            let mut chunks = text.chunks_in_range(0..text.len());
1921            parser
1922                .parse_with_options(
1923                    &mut move |offset, _| {
1924                        chunks.seek(offset);
1925                        chunks.next().unwrap_or("").as_bytes()
1926                    },
1927                    old_tree.as_ref(),
1928                    None,
1929                )
1930                .unwrap()
1931        })
1932    }
1933
1934    pub fn highlight_map(&self) -> HighlightMap {
1935        self.highlight_map.lock().clone()
1936    }
1937
1938    pub fn highlight_id_for_name(&self, name: &str) -> Option<HighlightId> {
1939        let capture_id = self
1940            .highlights_query
1941            .as_ref()?
1942            .capture_index_for_name(name)?;
1943        Some(self.highlight_map.lock().get(capture_id))
1944    }
1945}
1946
1947impl CodeLabel {
1948    pub fn fallback_for_completion(
1949        item: &lsp::CompletionItem,
1950        language: Option<&Language>,
1951    ) -> Self {
1952        let highlight_id = item.kind.and_then(|kind| {
1953            let grammar = language?.grammar()?;
1954            use lsp::CompletionItemKind as Kind;
1955            match kind {
1956                Kind::CLASS => grammar.highlight_id_for_name("type"),
1957                Kind::CONSTANT => grammar.highlight_id_for_name("constant"),
1958                Kind::CONSTRUCTOR => grammar.highlight_id_for_name("constructor"),
1959                Kind::ENUM => grammar
1960                    .highlight_id_for_name("enum")
1961                    .or_else(|| grammar.highlight_id_for_name("type")),
1962                Kind::ENUM_MEMBER => grammar
1963                    .highlight_id_for_name("variant")
1964                    .or_else(|| grammar.highlight_id_for_name("property")),
1965                Kind::FIELD => grammar.highlight_id_for_name("property"),
1966                Kind::FUNCTION => grammar.highlight_id_for_name("function"),
1967                Kind::INTERFACE => grammar.highlight_id_for_name("type"),
1968                Kind::METHOD => grammar
1969                    .highlight_id_for_name("function.method")
1970                    .or_else(|| grammar.highlight_id_for_name("function")),
1971                Kind::OPERATOR => grammar.highlight_id_for_name("operator"),
1972                Kind::PROPERTY => grammar.highlight_id_for_name("property"),
1973                Kind::STRUCT => grammar.highlight_id_for_name("type"),
1974                Kind::VARIABLE => grammar.highlight_id_for_name("variable"),
1975                Kind::KEYWORD => grammar.highlight_id_for_name("keyword"),
1976                _ => None,
1977            }
1978        });
1979
1980        let label = &item.label;
1981        let label_length = label.len();
1982        let runs = highlight_id
1983            .map(|highlight_id| vec![(0..label_length, highlight_id)])
1984            .unwrap_or_default();
1985        let text = if let Some(detail) = item.detail.as_deref().filter(|detail| detail != label) {
1986            format!("{label} {detail}")
1987        } else if let Some(description) = item
1988            .label_details
1989            .as_ref()
1990            .and_then(|label_details| label_details.description.as_deref())
1991            .filter(|description| description != label)
1992        {
1993            format!("{label} {description}")
1994        } else {
1995            label.clone()
1996        };
1997        Self {
1998            text,
1999            runs,
2000            filter_range: 0..label_length,
2001        }
2002    }
2003
2004    pub fn plain(text: String, filter_text: Option<&str>) -> Self {
2005        let mut result = Self {
2006            runs: Vec::new(),
2007            filter_range: 0..text.len(),
2008            text,
2009        };
2010        if let Some(filter_text) = filter_text {
2011            if let Some(ix) = result.text.find(filter_text) {
2012                result.filter_range = ix..ix + filter_text.len();
2013            }
2014        }
2015        result
2016    }
2017
2018    pub fn push_str(&mut self, text: &str, highlight: Option<HighlightId>) {
2019        let start_ix = self.text.len();
2020        self.text.push_str(text);
2021        let end_ix = self.text.len();
2022        if let Some(highlight) = highlight {
2023            self.runs.push((start_ix..end_ix, highlight));
2024        }
2025    }
2026
2027    pub fn text(&self) -> &str {
2028        self.text.as_str()
2029    }
2030
2031    pub fn filter_text(&self) -> &str {
2032        &self.text[self.filter_range.clone()]
2033    }
2034}
2035
2036impl From<String> for CodeLabel {
2037    fn from(value: String) -> Self {
2038        Self::plain(value, None)
2039    }
2040}
2041
2042impl From<&str> for CodeLabel {
2043    fn from(value: &str) -> Self {
2044        Self::plain(value.to_string(), None)
2045    }
2046}
2047
2048impl Ord for LanguageMatcher {
2049    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
2050        self.path_suffixes.cmp(&other.path_suffixes).then_with(|| {
2051            self.first_line_pattern
2052                .as_ref()
2053                .map(Regex::as_str)
2054                .cmp(&other.first_line_pattern.as_ref().map(Regex::as_str))
2055        })
2056    }
2057}
2058
2059impl PartialOrd for LanguageMatcher {
2060    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
2061        Some(self.cmp(other))
2062    }
2063}
2064
2065impl Eq for LanguageMatcher {}
2066
2067impl PartialEq for LanguageMatcher {
2068    fn eq(&self, other: &Self) -> bool {
2069        self.path_suffixes == other.path_suffixes
2070            && self.first_line_pattern.as_ref().map(Regex::as_str)
2071                == other.first_line_pattern.as_ref().map(Regex::as_str)
2072    }
2073}
2074
2075#[cfg(any(test, feature = "test-support"))]
2076impl Default for FakeLspAdapter {
2077    fn default() -> Self {
2078        Self {
2079            name: "the-fake-language-server",
2080            capabilities: lsp::LanguageServer::full_capabilities(),
2081            initializer: None,
2082            disk_based_diagnostics_progress_token: None,
2083            initialization_options: None,
2084            disk_based_diagnostics_sources: Vec::new(),
2085            prettier_plugins: Vec::new(),
2086            language_server_binary: LanguageServerBinary {
2087                path: "/the/fake/lsp/path".into(),
2088                arguments: vec![],
2089                env: Default::default(),
2090            },
2091            label_for_completion: None,
2092        }
2093    }
2094}
2095
2096#[cfg(any(test, feature = "test-support"))]
2097#[async_trait(?Send)]
2098impl LspAdapter for FakeLspAdapter {
2099    fn name(&self) -> LanguageServerName {
2100        LanguageServerName(self.name.into())
2101    }
2102
2103    async fn check_if_user_installed(
2104        &self,
2105        _: &dyn LspAdapterDelegate,
2106        _: Arc<dyn LanguageToolchainStore>,
2107        _: &AsyncApp,
2108    ) -> Option<LanguageServerBinary> {
2109        Some(self.language_server_binary.clone())
2110    }
2111
2112    fn get_language_server_command<'a>(
2113        self: Arc<Self>,
2114        _: Arc<dyn LspAdapterDelegate>,
2115        _: Arc<dyn LanguageToolchainStore>,
2116        _: LanguageServerBinaryOptions,
2117        _: futures::lock::MutexGuard<'a, Option<LanguageServerBinary>>,
2118        _: &'a mut AsyncApp,
2119    ) -> Pin<Box<dyn 'a + Future<Output = Result<LanguageServerBinary>>>> {
2120        async move { Ok(self.language_server_binary.clone()) }.boxed_local()
2121    }
2122
2123    async fn fetch_latest_server_version(
2124        &self,
2125        _: &dyn LspAdapterDelegate,
2126    ) -> Result<Box<dyn 'static + Send + Any>> {
2127        unreachable!();
2128    }
2129
2130    async fn fetch_server_binary(
2131        &self,
2132        _: Box<dyn 'static + Send + Any>,
2133        _: PathBuf,
2134        _: &dyn LspAdapterDelegate,
2135    ) -> Result<LanguageServerBinary> {
2136        unreachable!();
2137    }
2138
2139    async fn cached_server_binary(
2140        &self,
2141        _: PathBuf,
2142        _: &dyn LspAdapterDelegate,
2143    ) -> Option<LanguageServerBinary> {
2144        unreachable!();
2145    }
2146
2147    fn disk_based_diagnostic_sources(&self) -> Vec<String> {
2148        self.disk_based_diagnostics_sources.clone()
2149    }
2150
2151    fn disk_based_diagnostics_progress_token(&self) -> Option<String> {
2152        self.disk_based_diagnostics_progress_token.clone()
2153    }
2154
2155    async fn initialization_options(
2156        self: Arc<Self>,
2157        _: &dyn Fs,
2158        _: &Arc<dyn LspAdapterDelegate>,
2159    ) -> Result<Option<Value>> {
2160        Ok(self.initialization_options.clone())
2161    }
2162
2163    async fn label_for_completion(
2164        &self,
2165        item: &lsp::CompletionItem,
2166        language: &Arc<Language>,
2167    ) -> Option<CodeLabel> {
2168        let label_for_completion = self.label_for_completion.as_ref()?;
2169        label_for_completion(item, language)
2170    }
2171}
2172
2173fn get_capture_indices(query: &Query, captures: &mut [(&str, &mut Option<u32>)]) {
2174    for (ix, name) in query.capture_names().iter().enumerate() {
2175        for (capture_name, index) in captures.iter_mut() {
2176            if capture_name == name {
2177                **index = Some(ix as u32);
2178                break;
2179            }
2180        }
2181    }
2182}
2183
2184pub fn point_to_lsp(point: PointUtf16) -> lsp::Position {
2185    lsp::Position::new(point.row, point.column)
2186}
2187
2188pub fn point_from_lsp(point: lsp::Position) -> Unclipped<PointUtf16> {
2189    Unclipped(PointUtf16::new(point.line, point.character))
2190}
2191
2192pub fn range_to_lsp(range: Range<PointUtf16>) -> Result<lsp::Range> {
2193    if range.start > range.end {
2194        Err(anyhow!(
2195            "Inverted range provided to an LSP request: {:?}-{:?}",
2196            range.start,
2197            range.end
2198        ))
2199    } else {
2200        Ok(lsp::Range {
2201            start: point_to_lsp(range.start),
2202            end: point_to_lsp(range.end),
2203        })
2204    }
2205}
2206
2207pub fn range_from_lsp(range: lsp::Range) -> Range<Unclipped<PointUtf16>> {
2208    let mut start = point_from_lsp(range.start);
2209    let mut end = point_from_lsp(range.end);
2210    if start > end {
2211        log::warn!("range_from_lsp called with inverted range {start:?}-{end:?}");
2212        mem::swap(&mut start, &mut end);
2213    }
2214    start..end
2215}
2216
2217#[cfg(test)]
2218mod tests {
2219    use super::*;
2220    use gpui::TestAppContext;
2221
2222    #[gpui::test(iterations = 10)]
2223    async fn test_language_loading(cx: &mut TestAppContext) {
2224        let languages = LanguageRegistry::test(cx.executor());
2225        let languages = Arc::new(languages);
2226        languages.register_native_grammars([
2227            ("json", tree_sitter_json::LANGUAGE),
2228            ("rust", tree_sitter_rust::LANGUAGE),
2229        ]);
2230        languages.register_test_language(LanguageConfig {
2231            name: "JSON".into(),
2232            grammar: Some("json".into()),
2233            matcher: LanguageMatcher {
2234                path_suffixes: vec!["json".into()],
2235                ..Default::default()
2236            },
2237            ..Default::default()
2238        });
2239        languages.register_test_language(LanguageConfig {
2240            name: "Rust".into(),
2241            grammar: Some("rust".into()),
2242            matcher: LanguageMatcher {
2243                path_suffixes: vec!["rs".into()],
2244                ..Default::default()
2245            },
2246            ..Default::default()
2247        });
2248        assert_eq!(
2249            languages.language_names(),
2250            &[
2251                "JSON".to_string(),
2252                "Plain Text".to_string(),
2253                "Rust".to_string(),
2254            ]
2255        );
2256
2257        let rust1 = languages.language_for_name("Rust");
2258        let rust2 = languages.language_for_name("Rust");
2259
2260        // Ensure language is still listed even if it's being loaded.
2261        assert_eq!(
2262            languages.language_names(),
2263            &[
2264                "JSON".to_string(),
2265                "Plain Text".to_string(),
2266                "Rust".to_string(),
2267            ]
2268        );
2269
2270        let (rust1, rust2) = futures::join!(rust1, rust2);
2271        assert!(Arc::ptr_eq(&rust1.unwrap(), &rust2.unwrap()));
2272
2273        // Ensure language is still listed even after loading it.
2274        assert_eq!(
2275            languages.language_names(),
2276            &[
2277                "JSON".to_string(),
2278                "Plain Text".to_string(),
2279                "Rust".to_string(),
2280            ]
2281        );
2282
2283        // Loading an unknown language returns an error.
2284        assert!(languages.language_for_name("Unknown").await.is_err());
2285    }
2286
2287    #[gpui::test]
2288    async fn test_completion_label_omits_duplicate_data() {
2289        let regular_completion_item_1 = lsp::CompletionItem {
2290            label: "regular1".to_string(),
2291            detail: Some("detail1".to_string()),
2292            label_details: Some(lsp::CompletionItemLabelDetails {
2293                detail: None,
2294                description: Some("description 1".to_string()),
2295            }),
2296            ..lsp::CompletionItem::default()
2297        };
2298
2299        let regular_completion_item_2 = lsp::CompletionItem {
2300            label: "regular2".to_string(),
2301            label_details: Some(lsp::CompletionItemLabelDetails {
2302                detail: None,
2303                description: Some("description 2".to_string()),
2304            }),
2305            ..lsp::CompletionItem::default()
2306        };
2307
2308        let completion_item_with_duplicate_detail_and_proper_description = lsp::CompletionItem {
2309            detail: Some(regular_completion_item_1.label.clone()),
2310            ..regular_completion_item_1.clone()
2311        };
2312
2313        let completion_item_with_duplicate_detail = lsp::CompletionItem {
2314            detail: Some(regular_completion_item_1.label.clone()),
2315            label_details: None,
2316            ..regular_completion_item_1.clone()
2317        };
2318
2319        let completion_item_with_duplicate_description = lsp::CompletionItem {
2320            label_details: Some(lsp::CompletionItemLabelDetails {
2321                detail: None,
2322                description: Some(regular_completion_item_2.label.clone()),
2323            }),
2324            ..regular_completion_item_2.clone()
2325        };
2326
2327        assert_eq!(
2328            CodeLabel::fallback_for_completion(&regular_completion_item_1, None).text,
2329            format!(
2330                "{} {}",
2331                regular_completion_item_1.label,
2332                regular_completion_item_1.detail.unwrap()
2333            ),
2334            "LSP completion items with both detail and label_details.description should prefer detail"
2335        );
2336        assert_eq!(
2337            CodeLabel::fallback_for_completion(&regular_completion_item_2, None).text,
2338            format!(
2339                "{} {}",
2340                regular_completion_item_2.label,
2341                regular_completion_item_2
2342                    .label_details
2343                    .as_ref()
2344                    .unwrap()
2345                    .description
2346                    .as_ref()
2347                    .unwrap()
2348            ),
2349            "LSP completion items without detail but with label_details.description should use that"
2350        );
2351        assert_eq!(
2352            CodeLabel::fallback_for_completion(
2353                &completion_item_with_duplicate_detail_and_proper_description,
2354                None
2355            )
2356            .text,
2357            format!(
2358                "{} {}",
2359                regular_completion_item_1.label,
2360                regular_completion_item_1
2361                    .label_details
2362                    .as_ref()
2363                    .unwrap()
2364                    .description
2365                    .as_ref()
2366                    .unwrap()
2367            ),
2368            "LSP completion items with both detail and label_details.description should prefer description only if the detail duplicates the completion label"
2369        );
2370        assert_eq!(
2371            CodeLabel::fallback_for_completion(&completion_item_with_duplicate_detail, None).text,
2372            regular_completion_item_1.label,
2373            "LSP completion items with duplicate label and detail, should omit the detail"
2374        );
2375        assert_eq!(
2376            CodeLabel::fallback_for_completion(&completion_item_with_duplicate_description, None)
2377                .text,
2378            regular_completion_item_2.label,
2379            "LSP completion items with duplicate label and detail, should omit the detail"
2380        );
2381    }
2382}