1use crate::{
   2    buffer_store::{BufferStore, BufferStoreEvent},
   3    deserialize_code_actions,
   4    environment::ProjectEnvironment,
   5    lsp_command::{self, *},
   6    lsp_ext_command,
   7    prettier_store::{self, PrettierStore, PrettierStoreEvent},
   8    project_settings::{LspSettings, ProjectSettings},
   9    relativize_path, resolve_path,
  10    toolchain_store::{EmptyToolchainStore, ToolchainStoreEvent},
  11    worktree_store::{WorktreeStore, WorktreeStoreEvent},
  12    yarn::YarnPathStore,
  13    CodeAction, Completion, CoreCompletion, Hover, InlayHint, Item as _, ProjectPath,
  14    ProjectTransaction, ResolveState, Symbol, ToolchainStore,
  15};
  16use anyhow::{anyhow, Context as _, Result};
  17use async_trait::async_trait;
  18use client::{proto, TypedEnvelope};
  19use collections::{btree_map, BTreeMap, HashMap, HashSet};
  20use futures::{
  21    future::{join_all, Shared},
  22    select,
  23    stream::FuturesUnordered,
  24    AsyncWriteExt, Future, FutureExt, StreamExt,
  25};
  26use globset::{Glob, GlobSet, GlobSetBuilder};
  27use gpui::{
  28    AppContext, AsyncAppContext, Context, Entity, EventEmitter, Model, ModelContext, PromptLevel,
  29    Task, WeakModel,
  30};
  31use http_client::HttpClient;
  32use itertools::Itertools as _;
  33use language::{
  34    language_settings::{
  35        language_settings, FormatOnSave, Formatter, LanguageSettings, SelectedFormatter,
  36    },
  37    markdown, point_to_lsp, prepare_completion_documentation,
  38    proto::{deserialize_anchor, deserialize_version, serialize_anchor, serialize_version},
  39    range_from_lsp, Bias, Buffer, BufferSnapshot, CachedLspAdapter, CodeLabel, Diagnostic,
  40    DiagnosticEntry, DiagnosticSet, Diff, Documentation, File as _, Language, LanguageName,
  41    LanguageRegistry, LanguageServerBinaryStatus, LanguageToolchainStore, LocalFile, LspAdapter,
  42    LspAdapterDelegate, Patch, PointUtf16, TextBufferSnapshot, ToOffset, ToPointUtf16, Transaction,
  43    Unclipped,
  44};
  45use lsp::{
  46    CodeActionKind, CompletionContext, DiagnosticSeverity, DiagnosticTag,
  47    DidChangeWatchedFilesRegistrationOptions, Edit, FileSystemWatcher, InsertTextFormat,
  48    LanguageServer, LanguageServerBinary, LanguageServerBinaryOptions, LanguageServerId,
  49    LanguageServerName, LspRequestFuture, MessageActionItem, MessageType, OneOf,
  50    ServerHealthStatus, ServerStatus, SymbolKind, TextEdit, Url, WorkDoneProgressCancelParams,
  51    WorkspaceFolder,
  52};
  53use node_runtime::read_package_installed_version;
  54use parking_lot::{Mutex, RwLock};
  55use postage::watch;
  56use rand::prelude::*;
  57
  58use rpc::AnyProtoClient;
  59use serde::Serialize;
  60use settings::{Settings, SettingsLocation, SettingsStore};
  61use sha2::{Digest, Sha256};
  62use similar::{ChangeTag, TextDiff};
  63use smol::channel::Sender;
  64use snippet::Snippet;
  65use std::{
  66    any::Any,
  67    cmp::Ordering,
  68    convert::TryInto,
  69    ffi::OsStr,
  70    iter, mem,
  71    ops::{ControlFlow, Range},
  72    path::{self, Path, PathBuf},
  73    str,
  74    sync::Arc,
  75    time::{Duration, Instant},
  76};
  77use text::{Anchor, BufferId, LineEnding, Point, Selection};
  78use util::{
  79    debug_panic, defer, maybe, merge_json_value_into, post_inc, ResultExt, TryFutureExt as _,
  80};
  81
  82pub use fs::*;
  83pub use language::Location;
  84#[cfg(any(test, feature = "test-support"))]
  85pub use prettier::FORMAT_SUFFIX as TEST_PRETTIER_FORMAT_SUFFIX;
  86pub use worktree::{
  87    Entry, EntryKind, File, LocalWorktree, PathChange, ProjectEntryId, RepositoryEntry,
  88    UpdatedEntriesSet, UpdatedGitRepositoriesSet, Worktree, WorktreeId, WorktreeSettings,
  89    FS_WATCH_LATENCY,
  90};
  91
  92const SERVER_LAUNCHING_BEFORE_SHUTDOWN_TIMEOUT: Duration = Duration::from_secs(5);
  93pub const SERVER_PROGRESS_THROTTLE_TIMEOUT: Duration = Duration::from_millis(100);
  94
  95#[derive(Debug, Clone, Copy, PartialEq, Eq)]
  96pub enum FormatTrigger {
  97    Save,
  98    Manual,
  99}
 100
 101pub enum FormatTarget {
 102    Buffer,
 103    Ranges(Vec<Selection<Point>>),
 104}
 105
 106impl FormatTarget {
 107    pub fn as_selections(&self) -> Option<&[Selection<Point>]> {
 108        match self {
 109            FormatTarget::Buffer => None,
 110            FormatTarget::Ranges(selections) => Some(selections.as_slice()),
 111        }
 112    }
 113}
 114
 115// Currently, formatting operations are represented differently depending on
 116// whether they come from a language server or an external command.
 117#[derive(Debug)]
 118pub enum FormatOperation {
 119    Lsp(Vec<(Range<Anchor>, String)>),
 120    External(Diff),
 121    Prettier(Diff),
 122}
 123
 124impl FormatTrigger {
 125    fn from_proto(value: i32) -> FormatTrigger {
 126        match value {
 127            0 => FormatTrigger::Save,
 128            1 => FormatTrigger::Manual,
 129            _ => FormatTrigger::Save,
 130        }
 131    }
 132}
 133
 134pub struct LocalLspStore {
 135    http_client: Arc<dyn HttpClient>,
 136    environment: Model<ProjectEnvironment>,
 137    fs: Arc<dyn Fs>,
 138    yarn: Model<YarnPathStore>,
 139    pub language_servers: HashMap<LanguageServerId, LanguageServerState>,
 140    buffers_being_formatted: HashSet<BufferId>,
 141    last_workspace_edits_by_language_server: HashMap<LanguageServerId, ProjectTransaction>,
 142    language_server_watched_paths: HashMap<LanguageServerId, Model<LanguageServerWatchedPaths>>,
 143    language_server_watcher_registrations:
 144        HashMap<LanguageServerId, HashMap<String, Vec<FileSystemWatcher>>>,
 145    supplementary_language_servers:
 146        HashMap<LanguageServerId, (LanguageServerName, Arc<LanguageServer>)>,
 147    prettier_store: Model<PrettierStore>,
 148    current_lsp_settings: HashMap<LanguageServerName, LspSettings>,
 149    _subscription: gpui::Subscription,
 150}
 151
 152impl LocalLspStore {
 153    fn shutdown_language_servers(
 154        &mut self,
 155        _cx: &mut ModelContext<LspStore>,
 156    ) -> impl Future<Output = ()> {
 157        let shutdown_futures = self
 158            .language_servers
 159            .drain()
 160            .map(|(_, server_state)| async {
 161                use LanguageServerState::*;
 162                match server_state {
 163                    Running { server, .. } => server.shutdown()?.await,
 164                    Starting(task) => task.await?.shutdown()?.await,
 165                }
 166            })
 167            .collect::<Vec<_>>();
 168
 169        async move {
 170            futures::future::join_all(shutdown_futures).await;
 171        }
 172    }
 173
 174    async fn format_locally(
 175        lsp_store: WeakModel<LspStore>,
 176        mut buffers: Vec<FormattableBuffer>,
 177        push_to_history: bool,
 178        trigger: FormatTrigger,
 179        target: FormatTarget,
 180        mut cx: AsyncAppContext,
 181    ) -> anyhow::Result<ProjectTransaction> {
 182        // Do not allow multiple concurrent formatting requests for the
 183        // same buffer.
 184        lsp_store.update(&mut cx, |this, cx| {
 185            let this = this.as_local_mut().unwrap();
 186            buffers.retain(|buffer| {
 187                this.buffers_being_formatted
 188                    .insert(buffer.handle.read(cx).remote_id())
 189            });
 190        })?;
 191
 192        let _cleanup = defer({
 193            let this = lsp_store.clone();
 194            let mut cx = cx.clone();
 195            let buffers = &buffers;
 196            move || {
 197                this.update(&mut cx, |this, cx| {
 198                    let this = this.as_local_mut().unwrap();
 199                    for buffer in buffers {
 200                        this.buffers_being_formatted
 201                            .remove(&buffer.handle.read(cx).remote_id());
 202                    }
 203                })
 204                .ok();
 205            }
 206        });
 207
 208        let mut project_transaction = ProjectTransaction::default();
 209        for buffer in &buffers {
 210            let (primary_adapter_and_server, adapters_and_servers) =
 211                lsp_store.update(&mut cx, |lsp_store, cx| {
 212                    let buffer = buffer.handle.read(cx);
 213
 214                    let adapters_and_servers = lsp_store
 215                        .language_servers_for_buffer(buffer, cx)
 216                        .map(|(adapter, lsp)| (adapter.clone(), lsp.clone()))
 217                        .collect::<Vec<_>>();
 218
 219                    let primary_adapter = lsp_store
 220                        .primary_language_server_for_buffer(buffer, cx)
 221                        .map(|(adapter, lsp)| (adapter.clone(), lsp.clone()));
 222
 223                    (primary_adapter, adapters_and_servers)
 224                })?;
 225
 226            let settings = buffer.handle.update(&mut cx, |buffer, cx| {
 227                language_settings(buffer.language().map(|l| l.name()), buffer.file(), cx)
 228                    .into_owned()
 229            })?;
 230
 231            let remove_trailing_whitespace = settings.remove_trailing_whitespace_on_save;
 232            let ensure_final_newline = settings.ensure_final_newline_on_save;
 233
 234            // First, format buffer's whitespace according to the settings.
 235            let trailing_whitespace_diff = if remove_trailing_whitespace {
 236                Some(
 237                    buffer
 238                        .handle
 239                        .update(&mut cx, |b, cx| b.remove_trailing_whitespace(cx))?
 240                        .await,
 241                )
 242            } else {
 243                None
 244            };
 245            let whitespace_transaction_id = buffer.handle.update(&mut cx, |buffer, cx| {
 246                buffer.finalize_last_transaction();
 247                buffer.start_transaction();
 248                if let Some(diff) = trailing_whitespace_diff {
 249                    buffer.apply_diff(diff, cx);
 250                }
 251                if ensure_final_newline {
 252                    buffer.ensure_final_newline(cx);
 253                }
 254                buffer.end_transaction(cx)
 255            })?;
 256
 257            // Apply the `code_actions_on_format` before we run the formatter.
 258            let code_actions = deserialize_code_actions(&settings.code_actions_on_format);
 259            #[allow(clippy::nonminimal_bool)]
 260            if !code_actions.is_empty()
 261                && !(trigger == FormatTrigger::Save && settings.format_on_save == FormatOnSave::Off)
 262            {
 263                LspStore::execute_code_actions_on_servers(
 264                    &lsp_store,
 265                    &adapters_and_servers,
 266                    code_actions,
 267                    &buffer.handle,
 268                    push_to_history,
 269                    &mut project_transaction,
 270                    &mut cx,
 271                )
 272                .await?;
 273            }
 274
 275            // Apply language-specific formatting using either the primary language server
 276            // or external command.
 277            // Except for code actions, which are applied with all connected language servers.
 278            let primary_language_server =
 279                primary_adapter_and_server.map(|(_adapter, server)| server.clone());
 280            let server_and_buffer = primary_language_server
 281                .as_ref()
 282                .zip(buffer.abs_path.as_ref());
 283
 284            let prettier_settings = buffer.handle.read_with(&cx, |buffer, cx| {
 285                language_settings(buffer.language().map(|l| l.name()), buffer.file(), cx)
 286                    .prettier
 287                    .clone()
 288            })?;
 289
 290            let mut format_operations: Vec<FormatOperation> = vec![];
 291            {
 292                match trigger {
 293                    FormatTrigger::Save => {
 294                        match &settings.format_on_save {
 295                            FormatOnSave::Off => {
 296                                // nothing
 297                            }
 298                            FormatOnSave::On => {
 299                                match &settings.formatter {
 300                                    SelectedFormatter::Auto => {
 301                                        // do the auto-format: prefer prettier, fallback to primary language server
 302                                        let diff = {
 303                                            if prettier_settings.allowed {
 304                                                Self::perform_format(
 305                                                    &Formatter::Prettier,
 306                                                    &target,
 307                                                    server_and_buffer,
 308                                                    lsp_store.clone(),
 309                                                    buffer,
 310                                                    &settings,
 311                                                    &adapters_and_servers,
 312                                                    push_to_history,
 313                                                    &mut project_transaction,
 314                                                    &mut cx,
 315                                                )
 316                                                .await
 317                                            } else {
 318                                                Self::perform_format(
 319                                                    &Formatter::LanguageServer { name: None },
 320                                                    &target,
 321                                                    server_and_buffer,
 322                                                    lsp_store.clone(),
 323                                                    buffer,
 324                                                    &settings,
 325                                                    &adapters_and_servers,
 326                                                    push_to_history,
 327                                                    &mut project_transaction,
 328                                                    &mut cx,
 329                                                )
 330                                                .await
 331                                            }
 332                                        }?;
 333
 334                                        if let Some(op) = diff {
 335                                            format_operations.push(op);
 336                                        }
 337                                    }
 338                                    SelectedFormatter::List(formatters) => {
 339                                        for formatter in formatters.as_ref() {
 340                                            let diff = Self::perform_format(
 341                                                formatter,
 342                                                &target,
 343                                                server_and_buffer,
 344                                                lsp_store.clone(),
 345                                                buffer,
 346                                                &settings,
 347                                                &adapters_and_servers,
 348                                                push_to_history,
 349                                                &mut project_transaction,
 350                                                &mut cx,
 351                                            )
 352                                            .await?;
 353                                            if let Some(op) = diff {
 354                                                format_operations.push(op);
 355                                            }
 356
 357                                            // format with formatter
 358                                        }
 359                                    }
 360                                }
 361                            }
 362                            FormatOnSave::List(formatters) => {
 363                                for formatter in formatters.as_ref() {
 364                                    let diff = Self::perform_format(
 365                                        formatter,
 366                                        &target,
 367                                        server_and_buffer,
 368                                        lsp_store.clone(),
 369                                        buffer,
 370                                        &settings,
 371                                        &adapters_and_servers,
 372                                        push_to_history,
 373                                        &mut project_transaction,
 374                                        &mut cx,
 375                                    )
 376                                    .await?;
 377                                    if let Some(op) = diff {
 378                                        format_operations.push(op);
 379                                    }
 380                                }
 381                            }
 382                        }
 383                    }
 384                    FormatTrigger::Manual => {
 385                        match &settings.formatter {
 386                            SelectedFormatter::Auto => {
 387                                // do the auto-format: prefer prettier, fallback to primary language server
 388                                let diff = {
 389                                    if prettier_settings.allowed {
 390                                        Self::perform_format(
 391                                            &Formatter::Prettier,
 392                                            &target,
 393                                            server_and_buffer,
 394                                            lsp_store.clone(),
 395                                            buffer,
 396                                            &settings,
 397                                            &adapters_and_servers,
 398                                            push_to_history,
 399                                            &mut project_transaction,
 400                                            &mut cx,
 401                                        )
 402                                        .await
 403                                    } else {
 404                                        let formatter = Formatter::LanguageServer {
 405                                            name: primary_language_server
 406                                                .as_ref()
 407                                                .map(|server| server.name().to_string()),
 408                                        };
 409                                        Self::perform_format(
 410                                            &formatter,
 411                                            &target,
 412                                            server_and_buffer,
 413                                            lsp_store.clone(),
 414                                            buffer,
 415                                            &settings,
 416                                            &adapters_and_servers,
 417                                            push_to_history,
 418                                            &mut project_transaction,
 419                                            &mut cx,
 420                                        )
 421                                        .await
 422                                    }
 423                                }?;
 424
 425                                if let Some(op) = diff {
 426                                    format_operations.push(op)
 427                                }
 428                            }
 429                            SelectedFormatter::List(formatters) => {
 430                                for formatter in formatters.as_ref() {
 431                                    // format with formatter
 432                                    let diff = Self::perform_format(
 433                                        formatter,
 434                                        &target,
 435                                        server_and_buffer,
 436                                        lsp_store.clone(),
 437                                        buffer,
 438                                        &settings,
 439                                        &adapters_and_servers,
 440                                        push_to_history,
 441                                        &mut project_transaction,
 442                                        &mut cx,
 443                                    )
 444                                    .await?;
 445                                    if let Some(op) = diff {
 446                                        format_operations.push(op);
 447                                    }
 448                                }
 449                            }
 450                        }
 451                    }
 452                }
 453            }
 454
 455            buffer.handle.update(&mut cx, |b, cx| {
 456                // If the buffer had its whitespace formatted and was edited while the language-specific
 457                // formatting was being computed, avoid applying the language-specific formatting, because
 458                // it can't be grouped with the whitespace formatting in the undo history.
 459                if let Some(transaction_id) = whitespace_transaction_id {
 460                    if b.peek_undo_stack()
 461                        .map_or(true, |e| e.transaction_id() != transaction_id)
 462                    {
 463                        format_operations.clear();
 464                    }
 465                }
 466
 467                // Apply any language-specific formatting, and group the two formatting operations
 468                // in the buffer's undo history.
 469                for operation in format_operations {
 470                    match operation {
 471                        FormatOperation::Lsp(edits) => {
 472                            b.edit(edits, None, cx);
 473                        }
 474                        FormatOperation::External(diff) => {
 475                            b.apply_diff(diff, cx);
 476                        }
 477                        FormatOperation::Prettier(diff) => {
 478                            b.apply_diff(diff, cx);
 479                        }
 480                    }
 481
 482                    if let Some(transaction_id) = whitespace_transaction_id {
 483                        b.group_until_transaction(transaction_id);
 484                    } else if let Some(transaction) = project_transaction.0.get(&buffer.handle) {
 485                        b.group_until_transaction(transaction.id)
 486                    }
 487                }
 488
 489                if let Some(transaction) = b.finalize_last_transaction().cloned() {
 490                    if !push_to_history {
 491                        b.forget_transaction(transaction.id);
 492                    }
 493                    project_transaction
 494                        .0
 495                        .insert(buffer.handle.clone(), transaction);
 496                }
 497            })?;
 498        }
 499
 500        Ok(project_transaction)
 501    }
 502
 503    #[allow(clippy::too_many_arguments)]
 504    async fn perform_format(
 505        formatter: &Formatter,
 506        format_target: &FormatTarget,
 507        primary_server_and_buffer: Option<(&Arc<LanguageServer>, &PathBuf)>,
 508        lsp_store: WeakModel<LspStore>,
 509        buffer: &FormattableBuffer,
 510        settings: &LanguageSettings,
 511        adapters_and_servers: &[(Arc<CachedLspAdapter>, Arc<LanguageServer>)],
 512        push_to_history: bool,
 513        transaction: &mut ProjectTransaction,
 514        cx: &mut AsyncAppContext,
 515    ) -> Result<Option<FormatOperation>, anyhow::Error> {
 516        let result = match formatter {
 517            Formatter::LanguageServer { name } => {
 518                if let Some((language_server, buffer_abs_path)) = primary_server_and_buffer {
 519                    let language_server = if let Some(name) = name {
 520                        adapters_and_servers
 521                            .iter()
 522                            .find_map(|(adapter, server)| {
 523                                adapter.name.0.as_ref().eq(name.as_str()).then_some(server)
 524                            })
 525                            .unwrap_or(language_server)
 526                    } else {
 527                        language_server
 528                    };
 529
 530                    match format_target {
 531                        FormatTarget::Buffer => Some(FormatOperation::Lsp(
 532                            LspStore::format_via_lsp(
 533                                &lsp_store,
 534                                &buffer.handle,
 535                                buffer_abs_path,
 536                                language_server,
 537                                settings,
 538                                cx,
 539                            )
 540                            .await
 541                            .context("failed to format via language server")?,
 542                        )),
 543                        FormatTarget::Ranges(selections) => Some(FormatOperation::Lsp(
 544                            LspStore::format_range_via_lsp(
 545                                &lsp_store,
 546                                &buffer.handle,
 547                                selections.as_slice(),
 548                                buffer_abs_path,
 549                                language_server,
 550                                settings,
 551                                cx,
 552                            )
 553                            .await
 554                            .context("failed to format ranges via language server")?,
 555                        )),
 556                    }
 557                } else {
 558                    None
 559                }
 560            }
 561            Formatter::Prettier => {
 562                let prettier = lsp_store.update(cx, |lsp_store, _cx| {
 563                    lsp_store.prettier_store().unwrap().downgrade()
 564                })?;
 565                prettier_store::format_with_prettier(&prettier, &buffer.handle, cx)
 566                    .await
 567                    .transpose()?
 568            }
 569            Formatter::External { command, arguments } => {
 570                Self::format_via_external_command(buffer, command, arguments.as_deref(), cx)
 571                    .await
 572                    .context(format!(
 573                        "failed to format via external command {:?}",
 574                        command
 575                    ))?
 576                    .map(FormatOperation::External)
 577            }
 578            Formatter::CodeActions(code_actions) => {
 579                let code_actions = deserialize_code_actions(code_actions);
 580                if !code_actions.is_empty() {
 581                    LspStore::execute_code_actions_on_servers(
 582                        &lsp_store,
 583                        adapters_and_servers,
 584                        code_actions,
 585                        &buffer.handle,
 586                        push_to_history,
 587                        transaction,
 588                        cx,
 589                    )
 590                    .await?;
 591                }
 592                None
 593            }
 594        };
 595        anyhow::Ok(result)
 596    }
 597
 598    async fn format_via_external_command(
 599        buffer: &FormattableBuffer,
 600        command: &str,
 601        arguments: Option<&[String]>,
 602        cx: &mut AsyncAppContext,
 603    ) -> Result<Option<Diff>> {
 604        let working_dir_path = buffer.handle.update(cx, |buffer, cx| {
 605            let file = File::from_dyn(buffer.file())?;
 606            let worktree = file.worktree.read(cx);
 607            let mut worktree_path = worktree.abs_path().to_path_buf();
 608            if worktree.root_entry()?.is_file() {
 609                worktree_path.pop();
 610            }
 611            Some(worktree_path)
 612        })?;
 613
 614        let mut child = smol::process::Command::new(command);
 615        #[cfg(target_os = "windows")]
 616        {
 617            use smol::process::windows::CommandExt;
 618            child.creation_flags(windows::Win32::System::Threading::CREATE_NO_WINDOW.0);
 619        }
 620
 621        if let Some(buffer_env) = buffer.env.as_ref() {
 622            child.envs(buffer_env);
 623        }
 624
 625        if let Some(working_dir_path) = working_dir_path {
 626            child.current_dir(working_dir_path);
 627        }
 628
 629        if let Some(arguments) = arguments {
 630            child.args(arguments.iter().map(|arg| {
 631                if let Some(buffer_abs_path) = buffer.abs_path.as_ref() {
 632                    arg.replace("{buffer_path}", &buffer_abs_path.to_string_lossy())
 633                } else {
 634                    arg.replace("{buffer_path}", "Untitled")
 635                }
 636            }));
 637        }
 638
 639        let mut child = child
 640            .stdin(smol::process::Stdio::piped())
 641            .stdout(smol::process::Stdio::piped())
 642            .stderr(smol::process::Stdio::piped())
 643            .spawn()?;
 644
 645        let stdin = child
 646            .stdin
 647            .as_mut()
 648            .ok_or_else(|| anyhow!("failed to acquire stdin"))?;
 649        let text = buffer
 650            .handle
 651            .update(cx, |buffer, _| buffer.as_rope().clone())?;
 652        for chunk in text.chunks() {
 653            stdin.write_all(chunk.as_bytes()).await?;
 654        }
 655        stdin.flush().await?;
 656
 657        let output = child.output().await?;
 658        if !output.status.success() {
 659            return Err(anyhow!(
 660                "command failed with exit code {:?}:\nstdout: {}\nstderr: {}",
 661                output.status.code(),
 662                String::from_utf8_lossy(&output.stdout),
 663                String::from_utf8_lossy(&output.stderr),
 664            ));
 665        }
 666
 667        let stdout = String::from_utf8(output.stdout)?;
 668        Ok(Some(
 669            buffer
 670                .handle
 671                .update(cx, |buffer, cx| buffer.diff(stdout, cx))?
 672                .await,
 673        ))
 674    }
 675}
 676
 677#[derive(Debug)]
 678pub struct FormattableBuffer {
 679    handle: Model<Buffer>,
 680    abs_path: Option<PathBuf>,
 681    env: Option<HashMap<String, String>>,
 682}
 683
 684pub struct RemoteLspStore {
 685    upstream_client: Option<AnyProtoClient>,
 686    upstream_project_id: u64,
 687}
 688
 689#[allow(clippy::large_enum_variant)]
 690pub enum LspStoreMode {
 691    Local(LocalLspStore),   // ssh host and collab host
 692    Remote(RemoteLspStore), // collab guest
 693}
 694
 695impl LspStoreMode {
 696    fn is_local(&self) -> bool {
 697        matches!(self, LspStoreMode::Local(_))
 698    }
 699
 700    fn is_remote(&self) -> bool {
 701        matches!(self, LspStoreMode::Remote(_))
 702    }
 703}
 704
 705pub struct LspStore {
 706    mode: LspStoreMode,
 707    last_formatting_failure: Option<String>,
 708    downstream_client: Option<(AnyProtoClient, u64)>,
 709    nonce: u128,
 710    buffer_store: Model<BufferStore>,
 711    worktree_store: Model<WorktreeStore>,
 712    toolchain_store: Option<Model<ToolchainStore>>,
 713    buffer_snapshots: HashMap<BufferId, HashMap<LanguageServerId, Vec<LspBufferSnapshot>>>, // buffer_id -> server_id -> vec of snapshots
 714    pub languages: Arc<LanguageRegistry>,
 715    language_server_ids: HashMap<(WorktreeId, LanguageServerName), LanguageServerId>,
 716    pub language_server_statuses: BTreeMap<LanguageServerId, LanguageServerStatus>,
 717    active_entry: Option<ProjectEntryId>,
 718    _maintain_workspace_config: (Task<Result<()>>, watch::Sender<()>),
 719    _maintain_buffer_languages: Task<()>,
 720    next_diagnostic_group_id: usize,
 721    diagnostic_summaries:
 722        HashMap<WorktreeId, HashMap<Arc<Path>, HashMap<LanguageServerId, DiagnosticSummary>>>,
 723    diagnostics: HashMap<
 724        WorktreeId,
 725        HashMap<
 726            Arc<Path>,
 727            Vec<(
 728                LanguageServerId,
 729                Vec<DiagnosticEntry<Unclipped<PointUtf16>>>,
 730            )>,
 731        >,
 732    >,
 733}
 734
 735pub enum LspStoreEvent {
 736    LanguageServerAdded(LanguageServerId, LanguageServerName, Option<WorktreeId>),
 737    LanguageServerRemoved(LanguageServerId),
 738    LanguageServerUpdate {
 739        language_server_id: LanguageServerId,
 740        message: proto::update_language_server::Variant,
 741    },
 742    LanguageServerLog(LanguageServerId, LanguageServerLogType, String),
 743    LanguageServerPrompt(LanguageServerPromptRequest),
 744    LanguageDetected {
 745        buffer: Model<Buffer>,
 746        new_language: Option<Arc<Language>>,
 747    },
 748    Notification(String),
 749    RefreshInlayHints,
 750    DiagnosticsUpdated {
 751        language_server_id: LanguageServerId,
 752        path: ProjectPath,
 753    },
 754    DiskBasedDiagnosticsStarted {
 755        language_server_id: LanguageServerId,
 756    },
 757    DiskBasedDiagnosticsFinished {
 758        language_server_id: LanguageServerId,
 759    },
 760    SnippetEdit {
 761        buffer_id: BufferId,
 762        edits: Vec<(lsp::Range, Snippet)>,
 763        most_recent_edit: clock::Lamport,
 764    },
 765}
 766
 767#[derive(Clone, Debug, Serialize)]
 768pub struct LanguageServerStatus {
 769    pub name: String,
 770    pub pending_work: BTreeMap<String, LanguageServerProgress>,
 771    pub has_pending_diagnostic_updates: bool,
 772    progress_tokens: HashSet<String>,
 773}
 774
 775#[derive(Clone, Debug)]
 776struct CoreSymbol {
 777    pub language_server_name: LanguageServerName,
 778    pub source_worktree_id: WorktreeId,
 779    pub path: ProjectPath,
 780    pub name: String,
 781    pub kind: lsp::SymbolKind,
 782    pub range: Range<Unclipped<PointUtf16>>,
 783    pub signature: [u8; 32],
 784}
 785
 786impl LspStore {
 787    pub fn init(client: &AnyProtoClient) {
 788        client.add_model_request_handler(Self::handle_multi_lsp_query);
 789        client.add_model_request_handler(Self::handle_restart_language_servers);
 790        client.add_model_request_handler(Self::handle_cancel_language_server_work);
 791        client.add_model_message_handler(Self::handle_start_language_server);
 792        client.add_model_message_handler(Self::handle_update_language_server);
 793        client.add_model_message_handler(Self::handle_language_server_log);
 794        client.add_model_message_handler(Self::handle_update_diagnostic_summary);
 795        client.add_model_request_handler(Self::handle_format_buffers);
 796        client.add_model_request_handler(Self::handle_resolve_completion_documentation);
 797        client.add_model_request_handler(Self::handle_apply_code_action);
 798        client.add_model_request_handler(Self::handle_inlay_hints);
 799        client.add_model_request_handler(Self::handle_get_project_symbols);
 800        client.add_model_request_handler(Self::handle_resolve_inlay_hint);
 801        client.add_model_request_handler(Self::handle_open_buffer_for_symbol);
 802        client.add_model_request_handler(Self::handle_refresh_inlay_hints);
 803        client.add_model_request_handler(Self::handle_on_type_formatting);
 804        client.add_model_request_handler(Self::handle_apply_additional_edits_for_completion);
 805        client.add_model_request_handler(Self::handle_lsp_command::<GetCodeActions>);
 806        client.add_model_request_handler(Self::handle_lsp_command::<GetCompletions>);
 807        client.add_model_request_handler(Self::handle_lsp_command::<GetHover>);
 808        client.add_model_request_handler(Self::handle_lsp_command::<GetDefinition>);
 809        client.add_model_request_handler(Self::handle_lsp_command::<GetDeclaration>);
 810        client.add_model_request_handler(Self::handle_lsp_command::<GetTypeDefinition>);
 811        client.add_model_request_handler(Self::handle_lsp_command::<GetDocumentHighlights>);
 812        client.add_model_request_handler(Self::handle_lsp_command::<GetReferences>);
 813        client.add_model_request_handler(Self::handle_lsp_command::<PrepareRename>);
 814        client.add_model_request_handler(Self::handle_lsp_command::<PerformRename>);
 815        client.add_model_request_handler(Self::handle_lsp_command::<lsp_ext_command::ExpandMacro>);
 816        client.add_model_request_handler(Self::handle_lsp_command::<LinkedEditingRange>);
 817    }
 818
 819    pub fn as_remote(&self) -> Option<&RemoteLspStore> {
 820        match &self.mode {
 821            LspStoreMode::Remote(remote_lsp_store) => Some(remote_lsp_store),
 822            _ => None,
 823        }
 824    }
 825
 826    pub fn as_local(&self) -> Option<&LocalLspStore> {
 827        match &self.mode {
 828            LspStoreMode::Local(local_lsp_store) => Some(local_lsp_store),
 829            _ => None,
 830        }
 831    }
 832
 833    pub fn as_local_mut(&mut self) -> Option<&mut LocalLspStore> {
 834        match &mut self.mode {
 835            LspStoreMode::Local(local_lsp_store) => Some(local_lsp_store),
 836            _ => None,
 837        }
 838    }
 839
 840    pub fn upstream_client(&self) -> Option<(AnyProtoClient, u64)> {
 841        match &self.mode {
 842            LspStoreMode::Remote(RemoteLspStore {
 843                upstream_client: Some(upstream_client),
 844                upstream_project_id,
 845                ..
 846            }) => Some((upstream_client.clone(), *upstream_project_id)),
 847
 848            LspStoreMode::Remote(RemoteLspStore {
 849                upstream_client: None,
 850                ..
 851            }) => None,
 852            LspStoreMode::Local(_) => None,
 853        }
 854    }
 855
 856    pub fn swap_current_lsp_settings(
 857        &mut self,
 858        new_settings: HashMap<LanguageServerName, LspSettings>,
 859    ) -> Option<HashMap<LanguageServerName, LspSettings>> {
 860        match &mut self.mode {
 861            LspStoreMode::Local(LocalLspStore {
 862                current_lsp_settings,
 863                ..
 864            }) => {
 865                let ret = mem::take(current_lsp_settings);
 866                *current_lsp_settings = new_settings;
 867                Some(ret)
 868            }
 869            LspStoreMode::Remote(_) => None,
 870        }
 871    }
 872
 873    #[allow(clippy::too_many_arguments)]
 874    pub fn new_local(
 875        buffer_store: Model<BufferStore>,
 876        worktree_store: Model<WorktreeStore>,
 877        prettier_store: Model<PrettierStore>,
 878        toolchain_store: Model<ToolchainStore>,
 879        environment: Model<ProjectEnvironment>,
 880        languages: Arc<LanguageRegistry>,
 881        http_client: Arc<dyn HttpClient>,
 882        fs: Arc<dyn Fs>,
 883        cx: &mut ModelContext<Self>,
 884    ) -> Self {
 885        let yarn = YarnPathStore::new(fs.clone(), cx);
 886        cx.subscribe(&buffer_store, Self::on_buffer_store_event)
 887            .detach();
 888        cx.subscribe(&worktree_store, Self::on_worktree_store_event)
 889            .detach();
 890        cx.subscribe(&prettier_store, Self::on_prettier_store_event)
 891            .detach();
 892        cx.subscribe(&toolchain_store, Self::on_toolchain_store_event)
 893            .detach();
 894        cx.observe_global::<SettingsStore>(Self::on_settings_changed)
 895            .detach();
 896
 897        let _maintain_workspace_config = {
 898            let (sender, receiver) = watch::channel();
 899            (Self::maintain_workspace_config(receiver, cx), sender)
 900        };
 901        Self {
 902            mode: LspStoreMode::Local(LocalLspStore {
 903                supplementary_language_servers: Default::default(),
 904                language_servers: Default::default(),
 905                last_workspace_edits_by_language_server: Default::default(),
 906                language_server_watched_paths: Default::default(),
 907                language_server_watcher_registrations: Default::default(),
 908                current_lsp_settings: ProjectSettings::get_global(cx).lsp.clone(),
 909                buffers_being_formatted: Default::default(),
 910                prettier_store,
 911                environment,
 912                http_client,
 913                fs,
 914                yarn,
 915                _subscription: cx.on_app_quit(|this, cx| {
 916                    this.as_local_mut().unwrap().shutdown_language_servers(cx)
 917                }),
 918            }),
 919            last_formatting_failure: None,
 920            downstream_client: None,
 921            buffer_store,
 922            worktree_store,
 923            toolchain_store: Some(toolchain_store),
 924            languages: languages.clone(),
 925            language_server_ids: Default::default(),
 926            language_server_statuses: Default::default(),
 927            nonce: StdRng::from_entropy().gen(),
 928            buffer_snapshots: Default::default(),
 929            next_diagnostic_group_id: Default::default(),
 930            diagnostic_summaries: Default::default(),
 931            diagnostics: Default::default(),
 932            active_entry: None,
 933
 934            _maintain_workspace_config,
 935            _maintain_buffer_languages: Self::maintain_buffer_languages(languages.clone(), cx),
 936        }
 937    }
 938
 939    fn send_lsp_proto_request<R: LspCommand>(
 940        &self,
 941        buffer: Model<Buffer>,
 942        client: AnyProtoClient,
 943        upstream_project_id: u64,
 944        request: R,
 945        cx: &mut ModelContext<'_, LspStore>,
 946    ) -> Task<anyhow::Result<<R as LspCommand>::Response>> {
 947        let message = request.to_proto(upstream_project_id, buffer.read(cx));
 948        cx.spawn(move |this, cx| async move {
 949            let response = client.request(message).await?;
 950            let this = this.upgrade().context("project dropped")?;
 951            request
 952                .response_from_proto(response, this, buffer, cx)
 953                .await
 954        })
 955    }
 956
 957    pub(super) fn new_remote(
 958        buffer_store: Model<BufferStore>,
 959        worktree_store: Model<WorktreeStore>,
 960        toolchain_store: Option<Model<ToolchainStore>>,
 961        languages: Arc<LanguageRegistry>,
 962        upstream_client: AnyProtoClient,
 963        project_id: u64,
 964        cx: &mut ModelContext<Self>,
 965    ) -> Self {
 966        cx.subscribe(&buffer_store, Self::on_buffer_store_event)
 967            .detach();
 968        cx.subscribe(&worktree_store, Self::on_worktree_store_event)
 969            .detach();
 970        let _maintain_workspace_config = {
 971            let (sender, receiver) = watch::channel();
 972            (Self::maintain_workspace_config(receiver, cx), sender)
 973        };
 974        Self {
 975            mode: LspStoreMode::Remote(RemoteLspStore {
 976                upstream_client: Some(upstream_client),
 977                upstream_project_id: project_id,
 978            }),
 979            downstream_client: None,
 980            last_formatting_failure: None,
 981            buffer_store,
 982            worktree_store,
 983            languages: languages.clone(),
 984            language_server_ids: Default::default(),
 985            language_server_statuses: Default::default(),
 986            nonce: StdRng::from_entropy().gen(),
 987            buffer_snapshots: Default::default(),
 988            next_diagnostic_group_id: Default::default(),
 989            diagnostic_summaries: Default::default(),
 990            diagnostics: Default::default(),
 991            active_entry: None,
 992            toolchain_store,
 993            _maintain_workspace_config,
 994            _maintain_buffer_languages: Self::maintain_buffer_languages(languages.clone(), cx),
 995        }
 996    }
 997
 998    fn worktree_for_id(
 999        &self,
1000        worktree_id: WorktreeId,
1001        cx: &ModelContext<Self>,
1002    ) -> Result<Model<Worktree>> {
1003        self.worktree_store
1004            .read(cx)
1005            .worktree_for_id(worktree_id, cx)
1006            .ok_or_else(|| anyhow!("worktree not found"))
1007    }
1008
1009    fn on_buffer_store_event(
1010        &mut self,
1011        _: Model<BufferStore>,
1012        event: &BufferStoreEvent,
1013        cx: &mut ModelContext<Self>,
1014    ) {
1015        match event {
1016            BufferStoreEvent::BufferAdded(buffer) => {
1017                self.register_buffer(buffer, cx).log_err();
1018            }
1019            BufferStoreEvent::BufferChangedFilePath { buffer, old_file } => {
1020                if let Some(old_file) = File::from_dyn(old_file.as_ref()) {
1021                    self.unregister_buffer_from_language_servers(buffer, old_file, cx);
1022                }
1023
1024                self.register_buffer_with_language_servers(buffer, cx);
1025            }
1026            BufferStoreEvent::BufferDropped(_) => {}
1027        }
1028    }
1029
1030    fn on_worktree_store_event(
1031        &mut self,
1032        _: Model<WorktreeStore>,
1033        event: &WorktreeStoreEvent,
1034        cx: &mut ModelContext<Self>,
1035    ) {
1036        match event {
1037            WorktreeStoreEvent::WorktreeAdded(worktree) => {
1038                if !worktree.read(cx).is_local() {
1039                    return;
1040                }
1041                cx.subscribe(worktree, |this, worktree, event, cx| match event {
1042                    worktree::Event::UpdatedEntries(changes) => {
1043                        this.update_local_worktree_language_servers(&worktree, changes, cx);
1044                    }
1045                    worktree::Event::UpdatedGitRepositories(_)
1046                    | worktree::Event::DeletedEntry(_) => {}
1047                })
1048                .detach()
1049            }
1050            WorktreeStoreEvent::WorktreeReleased(..) => {}
1051            WorktreeStoreEvent::WorktreeRemoved(_, id) => self.remove_worktree(*id, cx),
1052            WorktreeStoreEvent::WorktreeOrderChanged => {}
1053            WorktreeStoreEvent::WorktreeUpdateSent(worktree) => {
1054                worktree.update(cx, |worktree, _cx| self.send_diagnostic_summaries(worktree));
1055            }
1056        }
1057    }
1058
1059    fn on_prettier_store_event(
1060        &mut self,
1061        _: Model<PrettierStore>,
1062        event: &PrettierStoreEvent,
1063        cx: &mut ModelContext<Self>,
1064    ) {
1065        match event {
1066            PrettierStoreEvent::LanguageServerRemoved(prettier_server_id) => {
1067                self.unregister_supplementary_language_server(*prettier_server_id, cx);
1068            }
1069            PrettierStoreEvent::LanguageServerAdded {
1070                new_server_id,
1071                name,
1072                prettier_server,
1073            } => {
1074                self.register_supplementary_language_server(
1075                    *new_server_id,
1076                    name.clone(),
1077                    prettier_server.clone(),
1078                    cx,
1079                );
1080            }
1081        }
1082    }
1083
1084    fn on_toolchain_store_event(
1085        &mut self,
1086        _: Model<ToolchainStore>,
1087        event: &ToolchainStoreEvent,
1088        _: &mut ModelContext<Self>,
1089    ) {
1090        match event {
1091            ToolchainStoreEvent::ToolchainActivated { .. } => {
1092                self.request_workspace_config_refresh()
1093            }
1094        }
1095    }
1096
1097    fn request_workspace_config_refresh(&mut self) {
1098        *self._maintain_workspace_config.1.borrow_mut() = ();
1099    }
1100    // todo!
1101    pub fn prettier_store(&self) -> Option<Model<PrettierStore>> {
1102        self.as_local().map(|local| local.prettier_store.clone())
1103    }
1104
1105    fn on_buffer_event(
1106        &mut self,
1107        buffer: Model<Buffer>,
1108        event: &language::BufferEvent,
1109        cx: &mut ModelContext<Self>,
1110    ) {
1111        match event {
1112            language::BufferEvent::Edited { .. } => {
1113                self.on_buffer_edited(buffer, cx);
1114            }
1115
1116            language::BufferEvent::Saved => {
1117                self.on_buffer_saved(buffer, cx);
1118            }
1119
1120            _ => {}
1121        }
1122    }
1123
1124    fn register_buffer(
1125        &mut self,
1126        buffer: &Model<Buffer>,
1127        cx: &mut ModelContext<Self>,
1128    ) -> Result<()> {
1129        buffer.update(cx, |buffer, _| {
1130            buffer.set_language_registry(self.languages.clone())
1131        });
1132
1133        cx.subscribe(buffer, |this, buffer, event, cx| {
1134            this.on_buffer_event(buffer, event, cx);
1135        })
1136        .detach();
1137
1138        self.register_buffer_with_language_servers(buffer, cx);
1139        cx.observe_release(buffer, |this, buffer, cx| {
1140            if let Some(file) = File::from_dyn(buffer.file()) {
1141                if file.is_local() {
1142                    let uri = lsp::Url::from_file_path(file.abs_path(cx)).unwrap();
1143                    for server in this.language_servers_for_buffer(buffer, cx) {
1144                        server
1145                            .1
1146                            .notify::<lsp::notification::DidCloseTextDocument>(
1147                                lsp::DidCloseTextDocumentParams {
1148                                    text_document: lsp::TextDocumentIdentifier::new(uri.clone()),
1149                                },
1150                            )
1151                            .log_err();
1152                    }
1153                }
1154            }
1155        })
1156        .detach();
1157
1158        Ok(())
1159    }
1160
1161    fn maintain_buffer_languages(
1162        languages: Arc<LanguageRegistry>,
1163        cx: &mut ModelContext<Self>,
1164    ) -> Task<()> {
1165        let mut subscription = languages.subscribe();
1166        let mut prev_reload_count = languages.reload_count();
1167        cx.spawn(move |this, mut cx| async move {
1168            while let Some(()) = subscription.next().await {
1169                if let Some(this) = this.upgrade() {
1170                    // If the language registry has been reloaded, then remove and
1171                    // re-assign the languages on all open buffers.
1172                    let reload_count = languages.reload_count();
1173                    if reload_count > prev_reload_count {
1174                        prev_reload_count = reload_count;
1175                        this.update(&mut cx, |this, cx| {
1176                            this.buffer_store.clone().update(cx, |buffer_store, cx| {
1177                                for buffer in buffer_store.buffers() {
1178                                    if let Some(f) = File::from_dyn(buffer.read(cx).file()).cloned()
1179                                    {
1180                                        this.unregister_buffer_from_language_servers(
1181                                            &buffer, &f, cx,
1182                                        );
1183                                        buffer
1184                                            .update(cx, |buffer, cx| buffer.set_language(None, cx));
1185                                    }
1186                                }
1187                            });
1188                        })
1189                        .ok();
1190                    }
1191
1192                    this.update(&mut cx, |this, cx| {
1193                        let mut plain_text_buffers = Vec::new();
1194                        let mut buffers_with_unknown_injections = Vec::new();
1195                        for handle in this.buffer_store.read(cx).buffers() {
1196                            let buffer = handle.read(cx);
1197                            if buffer.language().is_none()
1198                                || buffer.language() == Some(&*language::PLAIN_TEXT)
1199                            {
1200                                plain_text_buffers.push(handle);
1201                            } else if buffer.contains_unknown_injections() {
1202                                buffers_with_unknown_injections.push(handle);
1203                            }
1204                        }
1205                        for buffer in plain_text_buffers {
1206                            this.register_buffer_with_language_servers(&buffer, cx);
1207                        }
1208
1209                        for buffer in buffers_with_unknown_injections {
1210                            buffer.update(cx, |buffer, cx| buffer.reparse(cx));
1211                        }
1212                    })
1213                    .ok();
1214                }
1215            }
1216        })
1217    }
1218
1219    fn detect_language_for_buffer(
1220        &mut self,
1221        buffer_handle: &Model<Buffer>,
1222        cx: &mut ModelContext<Self>,
1223    ) -> Option<language::AvailableLanguage> {
1224        // If the buffer has a language, set it and start the language server if we haven't already.
1225        let buffer = buffer_handle.read(cx);
1226        let file = buffer.file()?;
1227
1228        let content = buffer.as_rope();
1229        let available_language = self.languages.language_for_file(file, Some(content), cx);
1230        if let Some(available_language) = &available_language {
1231            if let Some(Ok(Ok(new_language))) = self
1232                .languages
1233                .load_language(available_language)
1234                .now_or_never()
1235            {
1236                self.set_language_for_buffer(buffer_handle, new_language, cx);
1237            }
1238        } else {
1239            cx.emit(LspStoreEvent::LanguageDetected {
1240                buffer: buffer_handle.clone(),
1241                new_language: None,
1242            });
1243        }
1244
1245        available_language
1246    }
1247
1248    pub fn set_language_for_buffer(
1249        &mut self,
1250        buffer: &Model<Buffer>,
1251        new_language: Arc<Language>,
1252        cx: &mut ModelContext<Self>,
1253    ) {
1254        buffer.update(cx, |buffer, cx| {
1255            if buffer.language().map_or(true, |old_language| {
1256                !Arc::ptr_eq(old_language, &new_language)
1257            }) {
1258                buffer.set_language(Some(new_language.clone()), cx);
1259            }
1260        });
1261
1262        let buffer_file = buffer.read(cx).file().cloned();
1263        let settings =
1264            language_settings(Some(new_language.name()), buffer_file.as_ref(), cx).into_owned();
1265        let buffer_file = File::from_dyn(buffer_file.as_ref());
1266
1267        let worktree_id = if let Some(file) = buffer_file {
1268            let worktree = file.worktree.clone();
1269            self.start_language_servers(&worktree, new_language.name(), cx);
1270
1271            Some(worktree.read(cx).id())
1272        } else {
1273            None
1274        };
1275
1276        if settings.prettier.allowed {
1277            if let Some(prettier_plugins) = prettier_store::prettier_plugins_for_language(&settings)
1278            {
1279                let prettier_store = self.as_local().map(|s| s.prettier_store.clone());
1280                if let Some(prettier_store) = prettier_store {
1281                    prettier_store.update(cx, |prettier_store, cx| {
1282                        prettier_store.install_default_prettier(
1283                            worktree_id,
1284                            prettier_plugins.iter().map(|s| Arc::from(s.as_str())),
1285                            cx,
1286                        )
1287                    })
1288                }
1289            }
1290        }
1291
1292        cx.emit(LspStoreEvent::LanguageDetected {
1293            buffer: buffer.clone(),
1294            new_language: Some(new_language),
1295        })
1296    }
1297
1298    pub fn buffer_store(&self) -> Model<BufferStore> {
1299        self.buffer_store.clone()
1300    }
1301
1302    pub fn set_active_entry(&mut self, active_entry: Option<ProjectEntryId>) {
1303        self.active_entry = active_entry;
1304    }
1305
1306    pub(crate) fn send_diagnostic_summaries(&self, worktree: &mut Worktree) {
1307        if let Some((client, downstream_project_id)) = self.downstream_client.clone() {
1308            if let Some(summaries) = self.diagnostic_summaries.get(&worktree.id()) {
1309                for (path, summaries) in summaries {
1310                    for (&server_id, summary) in summaries {
1311                        client
1312                            .send(proto::UpdateDiagnosticSummary {
1313                                project_id: downstream_project_id,
1314                                worktree_id: worktree.id().to_proto(),
1315                                summary: Some(summary.to_proto(server_id, path)),
1316                            })
1317                            .log_err();
1318                    }
1319                }
1320            }
1321        }
1322    }
1323
1324    pub fn request_lsp<R: LspCommand>(
1325        &self,
1326        buffer_handle: Model<Buffer>,
1327        server: LanguageServerToQuery,
1328        request: R,
1329        cx: &mut ModelContext<Self>,
1330    ) -> Task<Result<R::Response>>
1331    where
1332        <R::LspRequest as lsp::request::Request>::Result: Send,
1333        <R::LspRequest as lsp::request::Request>::Params: Send,
1334    {
1335        let buffer = buffer_handle.read(cx);
1336
1337        if let Some((upstream_client, upstream_project_id)) = self.upstream_client() {
1338            return self.send_lsp_proto_request(
1339                buffer_handle,
1340                upstream_client,
1341                upstream_project_id,
1342                request,
1343                cx,
1344            );
1345        }
1346
1347        let language_server = match server {
1348            LanguageServerToQuery::Primary => {
1349                match self.primary_language_server_for_buffer(buffer, cx) {
1350                    Some((_, server)) => Some(Arc::clone(server)),
1351                    None => return Task::ready(Ok(Default::default())),
1352                }
1353            }
1354            LanguageServerToQuery::Other(id) => self
1355                .language_server_for_buffer(buffer, id, cx)
1356                .map(|(_, server)| Arc::clone(server)),
1357        };
1358        let file = File::from_dyn(buffer.file()).and_then(File::as_local);
1359        if let (Some(file), Some(language_server)) = (file, language_server) {
1360            let lsp_params = request.to_lsp(&file.abs_path(cx), buffer, &language_server, cx);
1361            let status = request.status();
1362            return cx.spawn(move |this, cx| async move {
1363                if !request.check_capabilities(language_server.adapter_server_capabilities()) {
1364                    return Ok(Default::default());
1365                }
1366
1367                let lsp_request = language_server.request::<R::LspRequest>(lsp_params);
1368
1369                let id = lsp_request.id();
1370                let _cleanup = if status.is_some() {
1371                    cx.update(|cx| {
1372                        this.update(cx, |this, cx| {
1373                            this.on_lsp_work_start(
1374                                language_server.server_id(),
1375                                id.to_string(),
1376                                LanguageServerProgress {
1377                                    is_disk_based_diagnostics_progress: false,
1378                                    is_cancellable: false,
1379                                    title: None,
1380                                    message: status.clone(),
1381                                    percentage: None,
1382                                    last_update_at: cx.background_executor().now(),
1383                                },
1384                                cx,
1385                            );
1386                        })
1387                    })
1388                    .log_err();
1389
1390                    Some(defer(|| {
1391                        cx.update(|cx| {
1392                            this.update(cx, |this, cx| {
1393                                this.on_lsp_work_end(
1394                                    language_server.server_id(),
1395                                    id.to_string(),
1396                                    cx,
1397                                );
1398                            })
1399                        })
1400                        .log_err();
1401                    }))
1402                } else {
1403                    None
1404                };
1405
1406                let result = lsp_request.await;
1407
1408                let response = result.map_err(|err| {
1409                    log::warn!(
1410                        "Generic lsp request to {} failed: {}",
1411                        language_server.name(),
1412                        err
1413                    );
1414                    err
1415                })?;
1416
1417                request
1418                    .response_from_lsp(
1419                        response,
1420                        this.upgrade().ok_or_else(|| anyhow!("no app context"))?,
1421                        buffer_handle,
1422                        language_server.server_id(),
1423                        cx.clone(),
1424                    )
1425                    .await
1426            });
1427        }
1428
1429        Task::ready(Ok(Default::default()))
1430    }
1431
1432    fn on_settings_changed(&mut self, cx: &mut ModelContext<Self>) {
1433        let mut language_servers_to_start = Vec::new();
1434        let mut language_formatters_to_check = Vec::new();
1435        for buffer in self.buffer_store.read(cx).buffers() {
1436            let buffer = buffer.read(cx);
1437            let buffer_file = File::from_dyn(buffer.file());
1438            let buffer_language = buffer.language();
1439            let settings = language_settings(buffer_language.map(|l| l.name()), buffer.file(), cx);
1440            if let Some(language) = buffer_language {
1441                if settings.enable_language_server {
1442                    if let Some(file) = buffer_file {
1443                        language_servers_to_start.push((file.worktree.clone(), language.name()));
1444                    }
1445                }
1446                language_formatters_to_check.push((
1447                    buffer_file.map(|f| f.worktree_id(cx)),
1448                    settings.into_owned(),
1449                ));
1450            }
1451        }
1452
1453        let mut language_servers_to_stop = Vec::new();
1454        let mut language_servers_to_restart = Vec::new();
1455        let languages = self.languages.to_vec();
1456
1457        let new_lsp_settings = ProjectSettings::get_global(cx).lsp.clone();
1458        let Some(current_lsp_settings) = self.swap_current_lsp_settings(new_lsp_settings.clone())
1459        else {
1460            return;
1461        };
1462        for (worktree_id, started_lsp_name) in self.started_language_servers() {
1463            let language = languages.iter().find_map(|l| {
1464                let adapter = self
1465                    .languages
1466                    .lsp_adapters(&l.name())
1467                    .iter()
1468                    .find(|adapter| adapter.name == started_lsp_name)?
1469                    .clone();
1470                Some((l, adapter))
1471            });
1472            if let Some((language, adapter)) = language {
1473                let worktree = self.worktree_for_id(worktree_id, cx).ok();
1474                let root_file = worktree.as_ref().and_then(|worktree| {
1475                    worktree
1476                        .update(cx, |tree, cx| tree.root_file(cx))
1477                        .map(|f| f as _)
1478                });
1479                let settings = language_settings(Some(language.name()), root_file.as_ref(), cx);
1480                if !settings.enable_language_server {
1481                    language_servers_to_stop.push((worktree_id, started_lsp_name.clone()));
1482                } else if let Some(worktree) = worktree {
1483                    let server_name = &adapter.name;
1484                    match (
1485                        current_lsp_settings.get(server_name),
1486                        new_lsp_settings.get(server_name),
1487                    ) {
1488                        (None, None) => {}
1489                        (Some(_), None) | (None, Some(_)) => {
1490                            language_servers_to_restart.push((worktree, language.name()));
1491                        }
1492                        (Some(current_lsp_settings), Some(new_lsp_settings)) => {
1493                            if current_lsp_settings != new_lsp_settings {
1494                                language_servers_to_restart.push((worktree, language.name()));
1495                            }
1496                        }
1497                    }
1498                }
1499            }
1500        }
1501
1502        for (worktree_id, adapter_name) in language_servers_to_stop {
1503            self.stop_local_language_server(worktree_id, adapter_name, cx)
1504                .detach();
1505        }
1506
1507        if let Some(prettier_store) = self.as_local().map(|s| s.prettier_store.clone()) {
1508            prettier_store.update(cx, |prettier_store, cx| {
1509                prettier_store.on_settings_changed(language_formatters_to_check, cx)
1510            })
1511        }
1512
1513        // Start all the newly-enabled language servers.
1514        for (worktree, language) in language_servers_to_start {
1515            self.start_language_servers(&worktree, language, cx);
1516        }
1517
1518        // Restart all language servers with changed initialization options.
1519        for (worktree, language) in language_servers_to_restart {
1520            self.restart_local_language_servers(worktree, language, cx);
1521        }
1522
1523        cx.notify();
1524    }
1525
1526    pub async fn execute_code_actions_on_servers(
1527        this: &WeakModel<LspStore>,
1528        adapters_and_servers: &[(Arc<CachedLspAdapter>, Arc<LanguageServer>)],
1529        code_actions: Vec<lsp::CodeActionKind>,
1530        buffer: &Model<Buffer>,
1531        push_to_history: bool,
1532        project_transaction: &mut ProjectTransaction,
1533        cx: &mut AsyncAppContext,
1534    ) -> Result<(), anyhow::Error> {
1535        for (lsp_adapter, language_server) in adapters_and_servers.iter() {
1536            let code_actions = code_actions.clone();
1537
1538            let actions = this
1539                .update(cx, move |this, cx| {
1540                    let request = GetCodeActions {
1541                        range: text::Anchor::MIN..text::Anchor::MAX,
1542                        kinds: Some(code_actions),
1543                    };
1544                    let server = LanguageServerToQuery::Other(language_server.server_id());
1545                    this.request_lsp(buffer.clone(), server, request, cx)
1546                })?
1547                .await?;
1548
1549            for mut action in actions {
1550                Self::try_resolve_code_action(language_server, &mut action)
1551                    .await
1552                    .context("resolving a formatting code action")?;
1553
1554                if let Some(edit) = action.lsp_action.edit {
1555                    if edit.changes.is_none() && edit.document_changes.is_none() {
1556                        continue;
1557                    }
1558
1559                    let new = Self::deserialize_workspace_edit(
1560                        this.upgrade().ok_or_else(|| anyhow!("project dropped"))?,
1561                        edit,
1562                        push_to_history,
1563                        lsp_adapter.clone(),
1564                        language_server.clone(),
1565                        cx,
1566                    )
1567                    .await?;
1568                    project_transaction.0.extend(new.0);
1569                }
1570
1571                if let Some(command) = action.lsp_action.command {
1572                    this.update(cx, |this, _| {
1573                        if let LspStoreMode::Local(mode) = &mut this.mode {
1574                            mode.last_workspace_edits_by_language_server
1575                                .remove(&language_server.server_id());
1576                        }
1577                    })?;
1578
1579                    language_server
1580                        .request::<lsp::request::ExecuteCommand>(lsp::ExecuteCommandParams {
1581                            command: command.command,
1582                            arguments: command.arguments.unwrap_or_default(),
1583                            ..Default::default()
1584                        })
1585                        .await?;
1586
1587                    this.update(cx, |this, _| {
1588                        if let LspStoreMode::Local(mode) = &mut this.mode {
1589                            project_transaction.0.extend(
1590                                mode.last_workspace_edits_by_language_server
1591                                    .remove(&language_server.server_id())
1592                                    .unwrap_or_default()
1593                                    .0,
1594                            )
1595                        }
1596                    })?;
1597                }
1598            }
1599        }
1600
1601        Ok(())
1602    }
1603
1604    async fn try_resolve_code_action(
1605        lang_server: &LanguageServer,
1606        action: &mut CodeAction,
1607    ) -> anyhow::Result<()> {
1608        if GetCodeActions::can_resolve_actions(&lang_server.capabilities())
1609            && action.lsp_action.data.is_some()
1610            && (action.lsp_action.command.is_none() || action.lsp_action.edit.is_none())
1611        {
1612            action.lsp_action = lang_server
1613                .request::<lsp::request::CodeActionResolveRequest>(action.lsp_action.clone())
1614                .await?;
1615        }
1616
1617        anyhow::Ok(())
1618    }
1619
1620    pub fn apply_code_action(
1621        &self,
1622        buffer_handle: Model<Buffer>,
1623        mut action: CodeAction,
1624        push_to_history: bool,
1625        cx: &mut ModelContext<Self>,
1626    ) -> Task<Result<ProjectTransaction>> {
1627        if let Some((upstream_client, project_id)) = self.upstream_client() {
1628            let request = proto::ApplyCodeAction {
1629                project_id,
1630                buffer_id: buffer_handle.read(cx).remote_id().into(),
1631                action: Some(Self::serialize_code_action(&action)),
1632            };
1633            let buffer_store = self.buffer_store();
1634            cx.spawn(move |_, mut cx| async move {
1635                let response = upstream_client
1636                    .request(request)
1637                    .await?
1638                    .transaction
1639                    .ok_or_else(|| anyhow!("missing transaction"))?;
1640
1641                buffer_store
1642                    .update(&mut cx, |buffer_store, cx| {
1643                        buffer_store.deserialize_project_transaction(response, push_to_history, cx)
1644                    })?
1645                    .await
1646            })
1647        } else {
1648            let buffer = buffer_handle.read(cx);
1649            let (lsp_adapter, lang_server) = if let Some((adapter, server)) =
1650                self.language_server_for_buffer(buffer, action.server_id, cx)
1651            {
1652                (adapter.clone(), server.clone())
1653            } else {
1654                return Task::ready(Ok(Default::default()));
1655            };
1656            cx.spawn(move |this, mut cx| async move {
1657                Self::try_resolve_code_action(&lang_server, &mut action)
1658                    .await
1659                    .context("resolving a code action")?;
1660                if let Some(edit) = action.lsp_action.edit {
1661                    if edit.changes.is_some() || edit.document_changes.is_some() {
1662                        return Self::deserialize_workspace_edit(
1663                            this.upgrade().ok_or_else(|| anyhow!("no app present"))?,
1664                            edit,
1665                            push_to_history,
1666                            lsp_adapter.clone(),
1667                            lang_server.clone(),
1668                            &mut cx,
1669                        )
1670                        .await;
1671                    }
1672                }
1673
1674                if let Some(command) = action.lsp_action.command {
1675                    this.update(&mut cx, |this, _| {
1676                        this.as_local_mut()
1677                            .unwrap()
1678                            .last_workspace_edits_by_language_server
1679                            .remove(&lang_server.server_id());
1680                    })?;
1681
1682                    let result = lang_server
1683                        .request::<lsp::request::ExecuteCommand>(lsp::ExecuteCommandParams {
1684                            command: command.command,
1685                            arguments: command.arguments.unwrap_or_default(),
1686                            ..Default::default()
1687                        })
1688                        .await;
1689
1690                    result?;
1691
1692                    return this.update(&mut cx, |this, _| {
1693                        this.as_local_mut()
1694                            .unwrap()
1695                            .last_workspace_edits_by_language_server
1696                            .remove(&lang_server.server_id())
1697                            .unwrap_or_default()
1698                    });
1699                }
1700
1701                Ok(ProjectTransaction::default())
1702            })
1703        }
1704    }
1705
1706    pub fn resolve_inlay_hint(
1707        &self,
1708        hint: InlayHint,
1709        buffer_handle: Model<Buffer>,
1710        server_id: LanguageServerId,
1711        cx: &mut ModelContext<Self>,
1712    ) -> Task<anyhow::Result<InlayHint>> {
1713        if let Some((upstream_client, project_id)) = self.upstream_client() {
1714            let request = proto::ResolveInlayHint {
1715                project_id,
1716                buffer_id: buffer_handle.read(cx).remote_id().into(),
1717                language_server_id: server_id.0 as u64,
1718                hint: Some(InlayHints::project_to_proto_hint(hint.clone())),
1719            };
1720            cx.spawn(move |_, _| async move {
1721                let response = upstream_client
1722                    .request(request)
1723                    .await
1724                    .context("inlay hints proto request")?;
1725                match response.hint {
1726                    Some(resolved_hint) => InlayHints::proto_to_project_hint(resolved_hint)
1727                        .context("inlay hints proto resolve response conversion"),
1728                    None => Ok(hint),
1729                }
1730            })
1731        } else {
1732            let buffer = buffer_handle.read(cx);
1733            let (_, lang_server) = if let Some((adapter, server)) =
1734                self.language_server_for_buffer(buffer, server_id, cx)
1735            {
1736                (adapter.clone(), server.clone())
1737            } else {
1738                return Task::ready(Ok(hint));
1739            };
1740            if !InlayHints::can_resolve_inlays(&lang_server.capabilities()) {
1741                return Task::ready(Ok(hint));
1742            }
1743
1744            let buffer_snapshot = buffer.snapshot();
1745            cx.spawn(move |_, mut cx| async move {
1746                let resolve_task = lang_server.request::<lsp::request::InlayHintResolveRequest>(
1747                    InlayHints::project_to_lsp_hint(hint, &buffer_snapshot),
1748                );
1749                let resolved_hint = resolve_task
1750                    .await
1751                    .context("inlay hint resolve LSP request")?;
1752                let resolved_hint = InlayHints::lsp_to_project_hint(
1753                    resolved_hint,
1754                    &buffer_handle,
1755                    server_id,
1756                    ResolveState::Resolved,
1757                    false,
1758                    &mut cx,
1759                )
1760                .await?;
1761                Ok(resolved_hint)
1762            })
1763        }
1764    }
1765
1766    pub(crate) fn linked_edit(
1767        &self,
1768        buffer: &Model<Buffer>,
1769        position: Anchor,
1770        cx: &mut ModelContext<Self>,
1771    ) -> Task<Result<Vec<Range<Anchor>>>> {
1772        let snapshot = buffer.read(cx).snapshot();
1773        let scope = snapshot.language_scope_at(position);
1774        let Some(server_id) = self
1775            .language_servers_for_buffer(buffer.read(cx), cx)
1776            .filter(|(_, server)| {
1777                server
1778                    .capabilities()
1779                    .linked_editing_range_provider
1780                    .is_some()
1781            })
1782            .filter(|(adapter, _)| {
1783                scope
1784                    .as_ref()
1785                    .map(|scope| scope.language_allowed(&adapter.name))
1786                    .unwrap_or(true)
1787            })
1788            .map(|(_, server)| LanguageServerToQuery::Other(server.server_id()))
1789            .next()
1790            .or_else(|| {
1791                self.upstream_client()
1792                    .is_some()
1793                    .then_some(LanguageServerToQuery::Primary)
1794            })
1795            .filter(|_| {
1796                maybe!({
1797                    let language = buffer.read(cx).language_at(position)?;
1798                    Some(
1799                        language_settings(Some(language.name()), buffer.read(cx).file(), cx)
1800                            .linked_edits,
1801                    )
1802                }) == Some(true)
1803            })
1804        else {
1805            return Task::ready(Ok(vec![]));
1806        };
1807
1808        self.request_lsp(
1809            buffer.clone(),
1810            server_id,
1811            LinkedEditingRange { position },
1812            cx,
1813        )
1814    }
1815
1816    fn apply_on_type_formatting(
1817        &mut self,
1818        buffer: Model<Buffer>,
1819        position: Anchor,
1820        trigger: String,
1821        cx: &mut ModelContext<Self>,
1822    ) -> Task<Result<Option<Transaction>>> {
1823        if let Some((client, project_id)) = self.upstream_client() {
1824            let request = proto::OnTypeFormatting {
1825                project_id,
1826                buffer_id: buffer.read(cx).remote_id().into(),
1827                position: Some(serialize_anchor(&position)),
1828                trigger,
1829                version: serialize_version(&buffer.read(cx).version()),
1830            };
1831            cx.spawn(move |_, _| async move {
1832                client
1833                    .request(request)
1834                    .await?
1835                    .transaction
1836                    .map(language::proto::deserialize_transaction)
1837                    .transpose()
1838            })
1839        } else if let Some(local) = self.as_local_mut() {
1840            let buffer_id = buffer.read(cx).remote_id();
1841            local.buffers_being_formatted.insert(buffer_id);
1842            cx.spawn(move |this, mut cx| async move {
1843                let _cleanup = defer({
1844                    let this = this.clone();
1845                    let mut cx = cx.clone();
1846                    move || {
1847                        this.update(&mut cx, |this, _| {
1848                            if let Some(local) = this.as_local_mut() {
1849                                local.buffers_being_formatted.remove(&buffer_id);
1850                            }
1851                        })
1852                        .ok();
1853                    }
1854                });
1855
1856                buffer
1857                    .update(&mut cx, |buffer, _| {
1858                        buffer.wait_for_edits(Some(position.timestamp))
1859                    })?
1860                    .await?;
1861                this.update(&mut cx, |this, cx| {
1862                    let position = position.to_point_utf16(buffer.read(cx));
1863                    this.on_type_format(buffer, position, trigger, false, cx)
1864                })?
1865                .await
1866            })
1867        } else {
1868            Task::ready(Err(anyhow!("No upstream client or local language server")))
1869        }
1870    }
1871
1872    pub fn on_type_format<T: ToPointUtf16>(
1873        &mut self,
1874        buffer: Model<Buffer>,
1875        position: T,
1876        trigger: String,
1877        push_to_history: bool,
1878        cx: &mut ModelContext<Self>,
1879    ) -> Task<Result<Option<Transaction>>> {
1880        let position = position.to_point_utf16(buffer.read(cx));
1881        self.on_type_format_impl(buffer, position, trigger, push_to_history, cx)
1882    }
1883
1884    fn on_type_format_impl(
1885        &mut self,
1886        buffer: Model<Buffer>,
1887        position: PointUtf16,
1888        trigger: String,
1889        push_to_history: bool,
1890        cx: &mut ModelContext<Self>,
1891    ) -> Task<Result<Option<Transaction>>> {
1892        let options = buffer.update(cx, |buffer, cx| {
1893            lsp_command::lsp_formatting_options(
1894                language_settings(
1895                    buffer.language_at(position).map(|l| l.name()),
1896                    buffer.file(),
1897                    cx,
1898                )
1899                .as_ref(),
1900            )
1901        });
1902        self.request_lsp(
1903            buffer.clone(),
1904            LanguageServerToQuery::Primary,
1905            OnTypeFormatting {
1906                position,
1907                trigger,
1908                options,
1909                push_to_history,
1910            },
1911            cx,
1912        )
1913    }
1914
1915    pub async fn format_via_lsp(
1916        this: &WeakModel<Self>,
1917        buffer: &Model<Buffer>,
1918        abs_path: &Path,
1919        language_server: &Arc<LanguageServer>,
1920        settings: &LanguageSettings,
1921        cx: &mut AsyncAppContext,
1922    ) -> Result<Vec<(Range<Anchor>, String)>> {
1923        let uri = lsp::Url::from_file_path(abs_path)
1924            .map_err(|_| anyhow!("failed to convert abs path to uri"))?;
1925        let text_document = lsp::TextDocumentIdentifier::new(uri);
1926        let capabilities = &language_server.capabilities();
1927
1928        let formatting_provider = capabilities.document_formatting_provider.as_ref();
1929        let range_formatting_provider = capabilities.document_range_formatting_provider.as_ref();
1930
1931        let lsp_edits = if matches!(formatting_provider, Some(p) if *p != OneOf::Left(false)) {
1932            language_server
1933                .request::<lsp::request::Formatting>(lsp::DocumentFormattingParams {
1934                    text_document,
1935                    options: lsp_command::lsp_formatting_options(settings),
1936                    work_done_progress_params: Default::default(),
1937                })
1938                .await?
1939        } else if matches!(range_formatting_provider, Some(p) if *p != OneOf::Left(false)) {
1940            let buffer_start = lsp::Position::new(0, 0);
1941            let buffer_end = buffer.update(cx, |b, _| point_to_lsp(b.max_point_utf16()))?;
1942            language_server
1943                .request::<lsp::request::RangeFormatting>(lsp::DocumentRangeFormattingParams {
1944                    text_document: text_document.clone(),
1945                    range: lsp::Range::new(buffer_start, buffer_end),
1946                    options: lsp_command::lsp_formatting_options(settings),
1947                    work_done_progress_params: Default::default(),
1948                })
1949                .await?
1950        } else {
1951            None
1952        };
1953
1954        if let Some(lsp_edits) = lsp_edits {
1955            this.update(cx, |this, cx| {
1956                this.edits_from_lsp(buffer, lsp_edits, language_server.server_id(), None, cx)
1957            })?
1958            .await
1959        } else {
1960            Ok(Vec::with_capacity(0))
1961        }
1962    }
1963    pub async fn format_range_via_lsp(
1964        this: &WeakModel<Self>,
1965        buffer: &Model<Buffer>,
1966        selections: &[Selection<Point>],
1967        abs_path: &Path,
1968        language_server: &Arc<LanguageServer>,
1969        settings: &LanguageSettings,
1970        cx: &mut AsyncAppContext,
1971    ) -> Result<Vec<(Range<Anchor>, String)>> {
1972        let capabilities = &language_server.capabilities();
1973        let range_formatting_provider = capabilities.document_range_formatting_provider.as_ref();
1974        if range_formatting_provider.map_or(false, |provider| provider == &OneOf::Left(false)) {
1975            return Err(anyhow!(
1976                "{} language server does not support range formatting",
1977                language_server.name()
1978            ));
1979        }
1980
1981        let uri = lsp::Url::from_file_path(abs_path)
1982            .map_err(|_| anyhow!("failed to convert abs path to uri"))?;
1983        let text_document = lsp::TextDocumentIdentifier::new(uri);
1984
1985        let lsp_edits = {
1986            let ranges = selections.into_iter().map(|s| {
1987                let start = lsp::Position::new(s.start.row, s.start.column);
1988                let end = lsp::Position::new(s.end.row, s.end.column);
1989                lsp::Range::new(start, end)
1990            });
1991
1992            let mut edits = None;
1993            for range in ranges {
1994                if let Some(mut edit) = language_server
1995                    .request::<lsp::request::RangeFormatting>(lsp::DocumentRangeFormattingParams {
1996                        text_document: text_document.clone(),
1997                        range,
1998                        options: lsp_command::lsp_formatting_options(settings),
1999                        work_done_progress_params: Default::default(),
2000                    })
2001                    .await?
2002                {
2003                    edits.get_or_insert_with(Vec::new).append(&mut edit);
2004                }
2005            }
2006            edits
2007        };
2008
2009        if let Some(lsp_edits) = lsp_edits {
2010            this.update(cx, |this, cx| {
2011                this.edits_from_lsp(buffer, lsp_edits, language_server.server_id(), None, cx)
2012            })?
2013            .await
2014        } else {
2015            Ok(Vec::with_capacity(0))
2016        }
2017    }
2018
2019    pub fn code_actions(
2020        &mut self,
2021        buffer_handle: &Model<Buffer>,
2022        range: Range<Anchor>,
2023        cx: &mut ModelContext<Self>,
2024    ) -> Task<Result<Vec<CodeAction>>> {
2025        if let Some((upstream_client, project_id)) = self.upstream_client() {
2026            let request_task = upstream_client.request(proto::MultiLspQuery {
2027                buffer_id: buffer_handle.read(cx).remote_id().into(),
2028                version: serialize_version(&buffer_handle.read(cx).version()),
2029                project_id,
2030                strategy: Some(proto::multi_lsp_query::Strategy::All(
2031                    proto::AllLanguageServers {},
2032                )),
2033                request: Some(proto::multi_lsp_query::Request::GetCodeActions(
2034                    GetCodeActions {
2035                        range: range.clone(),
2036                        kinds: None,
2037                    }
2038                    .to_proto(project_id, buffer_handle.read(cx)),
2039                )),
2040            });
2041            let buffer = buffer_handle.clone();
2042            cx.spawn(|weak_project, cx| async move {
2043                let Some(project) = weak_project.upgrade() else {
2044                    return Ok(Vec::new());
2045                };
2046                let responses = request_task.await?.responses;
2047                let actions = join_all(
2048                    responses
2049                        .into_iter()
2050                        .filter_map(|lsp_response| match lsp_response.response? {
2051                            proto::lsp_response::Response::GetCodeActionsResponse(response) => {
2052                                Some(response)
2053                            }
2054                            unexpected => {
2055                                debug_panic!("Unexpected response: {unexpected:?}");
2056                                None
2057                            }
2058                        })
2059                        .map(|code_actions_response| {
2060                            GetCodeActions {
2061                                range: range.clone(),
2062                                kinds: None,
2063                            }
2064                            .response_from_proto(
2065                                code_actions_response,
2066                                project.clone(),
2067                                buffer.clone(),
2068                                cx.clone(),
2069                            )
2070                        }),
2071                )
2072                .await;
2073
2074                Ok(actions
2075                    .into_iter()
2076                    .collect::<Result<Vec<Vec<_>>>>()?
2077                    .into_iter()
2078                    .flatten()
2079                    .collect())
2080            })
2081        } else {
2082            let all_actions_task = self.request_multiple_lsp_locally(
2083                buffer_handle,
2084                Some(range.start),
2085                GetCodeActions {
2086                    range: range.clone(),
2087                    kinds: None,
2088                },
2089                cx,
2090            );
2091            cx.spawn(
2092                |_, _| async move { Ok(all_actions_task.await.into_iter().flatten().collect()) },
2093            )
2094        }
2095    }
2096
2097    #[inline(never)]
2098    pub fn completions(
2099        &self,
2100        buffer: &Model<Buffer>,
2101        position: PointUtf16,
2102        context: CompletionContext,
2103        cx: &mut ModelContext<Self>,
2104    ) -> Task<Result<Vec<Completion>>> {
2105        let language_registry = self.languages.clone();
2106
2107        if let Some((upstream_client, project_id)) = self.upstream_client() {
2108            let task = self.send_lsp_proto_request(
2109                buffer.clone(),
2110                upstream_client,
2111                project_id,
2112                GetCompletions { position, context },
2113                cx,
2114            );
2115            let language = buffer.read(cx).language().cloned();
2116
2117            // In the future, we should provide project guests with the names of LSP adapters,
2118            // so that they can use the correct LSP adapter when computing labels. For now,
2119            // guests just use the first LSP adapter associated with the buffer's language.
2120            let lsp_adapter = language.as_ref().and_then(|language| {
2121                language_registry
2122                    .lsp_adapters(&language.name())
2123                    .first()
2124                    .cloned()
2125            });
2126
2127            cx.foreground_executor().spawn(async move {
2128                let completions = task.await?;
2129                let mut result = Vec::new();
2130                populate_labels_for_completions(
2131                    completions,
2132                    &language_registry,
2133                    language,
2134                    lsp_adapter,
2135                    &mut result,
2136                )
2137                .await;
2138                Ok(result)
2139            })
2140        } else {
2141            let snapshot = buffer.read(cx).snapshot();
2142            let offset = position.to_offset(&snapshot);
2143            let scope = snapshot.language_scope_at(offset);
2144            let language = snapshot.language().cloned();
2145
2146            let server_ids: Vec<_> = self
2147                .language_servers_for_buffer(buffer.read(cx), cx)
2148                .filter(|(_, server)| server.capabilities().completion_provider.is_some())
2149                .filter(|(adapter, _)| {
2150                    scope
2151                        .as_ref()
2152                        .map(|scope| scope.language_allowed(&adapter.name))
2153                        .unwrap_or(true)
2154                })
2155                .map(|(_, server)| server.server_id())
2156                .collect();
2157
2158            let buffer = buffer.clone();
2159            cx.spawn(move |this, mut cx| async move {
2160                let mut tasks = Vec::with_capacity(server_ids.len());
2161                this.update(&mut cx, |this, cx| {
2162                    for server_id in server_ids {
2163                        let lsp_adapter = this.language_server_adapter_for_id(server_id);
2164                        tasks.push((
2165                            lsp_adapter,
2166                            this.request_lsp(
2167                                buffer.clone(),
2168                                LanguageServerToQuery::Other(server_id),
2169                                GetCompletions {
2170                                    position,
2171                                    context: context.clone(),
2172                                },
2173                                cx,
2174                            ),
2175                        ));
2176                    }
2177                })?;
2178
2179                let mut completions = Vec::new();
2180                for (lsp_adapter, task) in tasks {
2181                    if let Ok(new_completions) = task.await {
2182                        populate_labels_for_completions(
2183                            new_completions,
2184                            &language_registry,
2185                            language.clone(),
2186                            lsp_adapter,
2187                            &mut completions,
2188                        )
2189                        .await;
2190                    }
2191                }
2192
2193                Ok(completions)
2194            })
2195        }
2196    }
2197
2198    pub fn resolve_completions(
2199        &self,
2200        buffer: Model<Buffer>,
2201        completion_indices: Vec<usize>,
2202        completions: Arc<RwLock<Box<[Completion]>>>,
2203        cx: &mut ModelContext<Self>,
2204    ) -> Task<Result<bool>> {
2205        let client = self.upstream_client();
2206        let language_registry = self.languages.clone();
2207
2208        let buffer_id = buffer.read(cx).remote_id();
2209        let buffer_snapshot = buffer.read(cx).snapshot();
2210
2211        cx.spawn(move |this, cx| async move {
2212            let mut did_resolve = false;
2213            if let Some((client, project_id)) = client {
2214                for completion_index in completion_indices {
2215                    let (server_id, completion) = {
2216                        let completions_guard = completions.read();
2217                        let completion = &completions_guard[completion_index];
2218                        did_resolve = true;
2219                        let server_id = completion.server_id;
2220                        let completion = completion.lsp_completion.clone();
2221
2222                        (server_id, completion)
2223                    };
2224
2225                    Self::resolve_completion_remote(
2226                        project_id,
2227                        server_id,
2228                        buffer_id,
2229                        completions.clone(),
2230                        completion_index,
2231                        completion,
2232                        client.clone(),
2233                        language_registry.clone(),
2234                    )
2235                    .await;
2236                }
2237            } else {
2238                for completion_index in completion_indices {
2239                    let (server_id, completion) = {
2240                        let completions_guard = completions.read();
2241                        let completion = &completions_guard[completion_index];
2242                        let server_id = completion.server_id;
2243                        let completion = completion.lsp_completion.clone();
2244
2245                        (server_id, completion)
2246                    };
2247
2248                    let server = this
2249                        .read_with(&cx, |this, _| this.language_server_for_id(server_id))
2250                        .ok()
2251                        .flatten();
2252                    let Some(server) = server else {
2253                        continue;
2254                    };
2255
2256                    did_resolve = true;
2257                    Self::resolve_completion_local(
2258                        server,
2259                        &buffer_snapshot,
2260                        completions.clone(),
2261                        completion_index,
2262                        completion,
2263                        language_registry.clone(),
2264                    )
2265                    .await;
2266                }
2267            }
2268
2269            Ok(did_resolve)
2270        })
2271    }
2272
2273    async fn resolve_completion_local(
2274        server: Arc<lsp::LanguageServer>,
2275        snapshot: &BufferSnapshot,
2276        completions: Arc<RwLock<Box<[Completion]>>>,
2277        completion_index: usize,
2278        completion: lsp::CompletionItem,
2279        language_registry: Arc<LanguageRegistry>,
2280    ) {
2281        let can_resolve = server
2282            .capabilities()
2283            .completion_provider
2284            .as_ref()
2285            .and_then(|options| options.resolve_provider)
2286            .unwrap_or(false);
2287        if !can_resolve {
2288            return;
2289        }
2290
2291        let request = server.request::<lsp::request::ResolveCompletionItem>(completion);
2292        let Some(completion_item) = request.await.log_err() else {
2293            return;
2294        };
2295
2296        if let Some(lsp_documentation) = completion_item.documentation.as_ref() {
2297            let documentation = language::prepare_completion_documentation(
2298                lsp_documentation,
2299                &language_registry,
2300                None, // TODO: Try to reasonably work out which language the completion is for
2301            )
2302            .await;
2303
2304            let mut completions = completions.write();
2305            let completion = &mut completions[completion_index];
2306            completion.documentation = Some(documentation);
2307        } else {
2308            let mut completions = completions.write();
2309            let completion = &mut completions[completion_index];
2310            completion.documentation = Some(Documentation::Undocumented);
2311        }
2312
2313        if let Some(text_edit) = completion_item.text_edit.as_ref() {
2314            // Technically we don't have to parse the whole `text_edit`, since the only
2315            // language server we currently use that does update `text_edit` in `completionItem/resolve`
2316            // is `typescript-language-server` and they only update `text_edit.new_text`.
2317            // But we should not rely on that.
2318            let edit = parse_completion_text_edit(text_edit, snapshot);
2319
2320            if let Some((old_range, mut new_text)) = edit {
2321                LineEnding::normalize(&mut new_text);
2322
2323                let mut completions = completions.write();
2324                let completion = &mut completions[completion_index];
2325
2326                completion.new_text = new_text;
2327                completion.old_range = old_range;
2328            }
2329        }
2330        if completion_item.insert_text_format == Some(InsertTextFormat::SNIPPET) {
2331            // vtsls might change the type of completion after resolution.
2332            let mut completions = completions.write();
2333            let completion = &mut completions[completion_index];
2334            if completion_item.insert_text_format != completion.lsp_completion.insert_text_format {
2335                completion.lsp_completion.insert_text_format = completion_item.insert_text_format;
2336            }
2337        }
2338
2339        let mut completions = completions.write();
2340        let completion = &mut completions[completion_index];
2341        completion.lsp_completion = completion_item;
2342    }
2343
2344    #[allow(clippy::too_many_arguments)]
2345    async fn resolve_completion_remote(
2346        project_id: u64,
2347        server_id: LanguageServerId,
2348        buffer_id: BufferId,
2349        completions: Arc<RwLock<Box<[Completion]>>>,
2350        completion_index: usize,
2351        completion: lsp::CompletionItem,
2352        client: AnyProtoClient,
2353        language_registry: Arc<LanguageRegistry>,
2354    ) {
2355        let request = proto::ResolveCompletionDocumentation {
2356            project_id,
2357            language_server_id: server_id.0 as u64,
2358            lsp_completion: serde_json::to_string(&completion).unwrap().into_bytes(),
2359            buffer_id: buffer_id.into(),
2360        };
2361
2362        let Some(response) = client
2363            .request(request)
2364            .await
2365            .context("completion documentation resolve proto request")
2366            .log_err()
2367        else {
2368            return;
2369        };
2370        let Some(lsp_completion) = serde_json::from_slice(&response.lsp_completion).log_err()
2371        else {
2372            return;
2373        };
2374
2375        let documentation = if response.documentation.is_empty() {
2376            Documentation::Undocumented
2377        } else if response.documentation_is_markdown {
2378            Documentation::MultiLineMarkdown(
2379                markdown::parse_markdown(&response.documentation, &language_registry, None).await,
2380            )
2381        } else if response.documentation.lines().count() <= 1 {
2382            Documentation::SingleLine(response.documentation)
2383        } else {
2384            Documentation::MultiLinePlainText(response.documentation)
2385        };
2386
2387        let mut completions = completions.write();
2388        let completion = &mut completions[completion_index];
2389        completion.documentation = Some(documentation);
2390        completion.lsp_completion = lsp_completion;
2391
2392        let old_range = response
2393            .old_start
2394            .and_then(deserialize_anchor)
2395            .zip(response.old_end.and_then(deserialize_anchor));
2396        if let Some((old_start, old_end)) = old_range {
2397            if !response.new_text.is_empty() {
2398                completion.new_text = response.new_text;
2399                completion.old_range = old_start..old_end;
2400            }
2401        }
2402    }
2403
2404    pub fn apply_additional_edits_for_completion(
2405        &self,
2406        buffer_handle: Model<Buffer>,
2407        completion: Completion,
2408        push_to_history: bool,
2409        cx: &mut ModelContext<Self>,
2410    ) -> Task<Result<Option<Transaction>>> {
2411        let buffer = buffer_handle.read(cx);
2412        let buffer_id = buffer.remote_id();
2413
2414        if let Some((client, project_id)) = self.upstream_client() {
2415            cx.spawn(move |_, mut cx| async move {
2416                let response = client
2417                    .request(proto::ApplyCompletionAdditionalEdits {
2418                        project_id,
2419                        buffer_id: buffer_id.into(),
2420                        completion: Some(Self::serialize_completion(&CoreCompletion {
2421                            old_range: completion.old_range,
2422                            new_text: completion.new_text,
2423                            server_id: completion.server_id,
2424                            lsp_completion: completion.lsp_completion,
2425                        })),
2426                    })
2427                    .await?;
2428
2429                if let Some(transaction) = response.transaction {
2430                    let transaction = language::proto::deserialize_transaction(transaction)?;
2431                    buffer_handle
2432                        .update(&mut cx, |buffer, _| {
2433                            buffer.wait_for_edits(transaction.edit_ids.iter().copied())
2434                        })?
2435                        .await?;
2436                    if push_to_history {
2437                        buffer_handle.update(&mut cx, |buffer, _| {
2438                            buffer.push_transaction(transaction.clone(), Instant::now());
2439                        })?;
2440                    }
2441                    Ok(Some(transaction))
2442                } else {
2443                    Ok(None)
2444                }
2445            })
2446        } else {
2447            let server_id = completion.server_id;
2448            let lang_server = match self.language_server_for_buffer(buffer, server_id, cx) {
2449                Some((_, server)) => server.clone(),
2450                _ => return Task::ready(Ok(Default::default())),
2451            };
2452
2453            cx.spawn(move |this, mut cx| async move {
2454                let can_resolve = lang_server
2455                    .capabilities()
2456                    .completion_provider
2457                    .as_ref()
2458                    .and_then(|options| options.resolve_provider)
2459                    .unwrap_or(false);
2460                let additional_text_edits = if can_resolve {
2461                    lang_server
2462                        .request::<lsp::request::ResolveCompletionItem>(completion.lsp_completion)
2463                        .await?
2464                        .additional_text_edits
2465                } else {
2466                    completion.lsp_completion.additional_text_edits
2467                };
2468                if let Some(edits) = additional_text_edits {
2469                    let edits = this
2470                        .update(&mut cx, |this, cx| {
2471                            this.edits_from_lsp(
2472                                &buffer_handle,
2473                                edits,
2474                                lang_server.server_id(),
2475                                None,
2476                                cx,
2477                            )
2478                        })?
2479                        .await?;
2480
2481                    buffer_handle.update(&mut cx, |buffer, cx| {
2482                        buffer.finalize_last_transaction();
2483                        buffer.start_transaction();
2484
2485                        for (range, text) in edits {
2486                            let primary = &completion.old_range;
2487                            let start_within = primary.start.cmp(&range.start, buffer).is_le()
2488                                && primary.end.cmp(&range.start, buffer).is_ge();
2489                            let end_within = range.start.cmp(&primary.end, buffer).is_le()
2490                                && range.end.cmp(&primary.end, buffer).is_ge();
2491
2492                            //Skip additional edits which overlap with the primary completion edit
2493                            //https://github.com/zed-industries/zed/pull/1871
2494                            if !start_within && !end_within {
2495                                buffer.edit([(range, text)], None, cx);
2496                            }
2497                        }
2498
2499                        let transaction = if buffer.end_transaction(cx).is_some() {
2500                            let transaction = buffer.finalize_last_transaction().unwrap().clone();
2501                            if !push_to_history {
2502                                buffer.forget_transaction(transaction.id);
2503                            }
2504                            Some(transaction)
2505                        } else {
2506                            None
2507                        };
2508                        Ok(transaction)
2509                    })?
2510                } else {
2511                    Ok(None)
2512                }
2513            })
2514        }
2515    }
2516
2517    pub fn inlay_hints(
2518        &mut self,
2519        buffer_handle: Model<Buffer>,
2520        range: Range<Anchor>,
2521        cx: &mut ModelContext<Self>,
2522    ) -> Task<anyhow::Result<Vec<InlayHint>>> {
2523        let buffer = buffer_handle.read(cx);
2524        let range_start = range.start;
2525        let range_end = range.end;
2526        let buffer_id = buffer.remote_id().into();
2527        let lsp_request = InlayHints { range };
2528
2529        if let Some((client, project_id)) = self.upstream_client() {
2530            let request = proto::InlayHints {
2531                project_id,
2532                buffer_id,
2533                start: Some(serialize_anchor(&range_start)),
2534                end: Some(serialize_anchor(&range_end)),
2535                version: serialize_version(&buffer_handle.read(cx).version()),
2536            };
2537            cx.spawn(move |project, cx| async move {
2538                let response = client
2539                    .request(request)
2540                    .await
2541                    .context("inlay hints proto request")?;
2542                LspCommand::response_from_proto(
2543                    lsp_request,
2544                    response,
2545                    project.upgrade().ok_or_else(|| anyhow!("No project"))?,
2546                    buffer_handle.clone(),
2547                    cx.clone(),
2548                )
2549                .await
2550                .context("inlay hints proto response conversion")
2551            })
2552        } else {
2553            let lsp_request_task = self.request_lsp(
2554                buffer_handle.clone(),
2555                LanguageServerToQuery::Primary,
2556                lsp_request,
2557                cx,
2558            );
2559            cx.spawn(move |_, mut cx| async move {
2560                buffer_handle
2561                    .update(&mut cx, |buffer, _| {
2562                        buffer.wait_for_edits(vec![range_start.timestamp, range_end.timestamp])
2563                    })?
2564                    .await
2565                    .context("waiting for inlay hint request range edits")?;
2566                lsp_request_task.await.context("inlay hints LSP request")
2567            })
2568        }
2569    }
2570
2571    pub fn signature_help<T: ToPointUtf16>(
2572        &self,
2573        buffer: &Model<Buffer>,
2574        position: T,
2575        cx: &mut ModelContext<Self>,
2576    ) -> Task<Vec<SignatureHelp>> {
2577        let position = position.to_point_utf16(buffer.read(cx));
2578
2579        if let Some((client, upstream_project_id)) = self.upstream_client() {
2580            let request_task = client.request(proto::MultiLspQuery {
2581                buffer_id: buffer.read(cx).remote_id().into(),
2582                version: serialize_version(&buffer.read(cx).version()),
2583                project_id: upstream_project_id,
2584                strategy: Some(proto::multi_lsp_query::Strategy::All(
2585                    proto::AllLanguageServers {},
2586                )),
2587                request: Some(proto::multi_lsp_query::Request::GetSignatureHelp(
2588                    GetSignatureHelp { position }.to_proto(upstream_project_id, buffer.read(cx)),
2589                )),
2590            });
2591            let buffer = buffer.clone();
2592            cx.spawn(|weak_project, cx| async move {
2593                let Some(project) = weak_project.upgrade() else {
2594                    return Vec::new();
2595                };
2596                join_all(
2597                    request_task
2598                        .await
2599                        .log_err()
2600                        .map(|response| response.responses)
2601                        .unwrap_or_default()
2602                        .into_iter()
2603                        .filter_map(|lsp_response| match lsp_response.response? {
2604                            proto::lsp_response::Response::GetSignatureHelpResponse(response) => {
2605                                Some(response)
2606                            }
2607                            unexpected => {
2608                                debug_panic!("Unexpected response: {unexpected:?}");
2609                                None
2610                            }
2611                        })
2612                        .map(|signature_response| {
2613                            let response = GetSignatureHelp { position }.response_from_proto(
2614                                signature_response,
2615                                project.clone(),
2616                                buffer.clone(),
2617                                cx.clone(),
2618                            );
2619                            async move { response.await.log_err().flatten() }
2620                        }),
2621                )
2622                .await
2623                .into_iter()
2624                .flatten()
2625                .collect()
2626            })
2627        } else {
2628            let all_actions_task = self.request_multiple_lsp_locally(
2629                buffer,
2630                Some(position),
2631                GetSignatureHelp { position },
2632                cx,
2633            );
2634            cx.spawn(|_, _| async move {
2635                all_actions_task
2636                    .await
2637                    .into_iter()
2638                    .flatten()
2639                    .filter(|help| !help.markdown.is_empty())
2640                    .collect::<Vec<_>>()
2641            })
2642        }
2643    }
2644
2645    pub fn hover(
2646        &self,
2647        buffer: &Model<Buffer>,
2648        position: PointUtf16,
2649        cx: &mut ModelContext<Self>,
2650    ) -> Task<Vec<Hover>> {
2651        if let Some((client, upstream_project_id)) = self.upstream_client() {
2652            let request_task = client.request(proto::MultiLspQuery {
2653                buffer_id: buffer.read(cx).remote_id().into(),
2654                version: serialize_version(&buffer.read(cx).version()),
2655                project_id: upstream_project_id,
2656                strategy: Some(proto::multi_lsp_query::Strategy::All(
2657                    proto::AllLanguageServers {},
2658                )),
2659                request: Some(proto::multi_lsp_query::Request::GetHover(
2660                    GetHover { position }.to_proto(upstream_project_id, buffer.read(cx)),
2661                )),
2662            });
2663            let buffer = buffer.clone();
2664            cx.spawn(|weak_project, cx| async move {
2665                let Some(project) = weak_project.upgrade() else {
2666                    return Vec::new();
2667                };
2668                join_all(
2669                    request_task
2670                        .await
2671                        .log_err()
2672                        .map(|response| response.responses)
2673                        .unwrap_or_default()
2674                        .into_iter()
2675                        .filter_map(|lsp_response| match lsp_response.response? {
2676                            proto::lsp_response::Response::GetHoverResponse(response) => {
2677                                Some(response)
2678                            }
2679                            unexpected => {
2680                                debug_panic!("Unexpected response: {unexpected:?}");
2681                                None
2682                            }
2683                        })
2684                        .map(|hover_response| {
2685                            let response = GetHover { position }.response_from_proto(
2686                                hover_response,
2687                                project.clone(),
2688                                buffer.clone(),
2689                                cx.clone(),
2690                            );
2691                            async move {
2692                                response
2693                                    .await
2694                                    .log_err()
2695                                    .flatten()
2696                                    .and_then(remove_empty_hover_blocks)
2697                            }
2698                        }),
2699                )
2700                .await
2701                .into_iter()
2702                .flatten()
2703                .collect()
2704            })
2705        } else {
2706            let all_actions_task = self.request_multiple_lsp_locally(
2707                buffer,
2708                Some(position),
2709                GetHover { position },
2710                cx,
2711            );
2712            cx.spawn(|_, _| async move {
2713                all_actions_task
2714                    .await
2715                    .into_iter()
2716                    .filter_map(|hover| remove_empty_hover_blocks(hover?))
2717                    .collect::<Vec<Hover>>()
2718            })
2719        }
2720    }
2721
2722    pub fn symbols(&self, query: &str, cx: &mut ModelContext<Self>) -> Task<Result<Vec<Symbol>>> {
2723        let language_registry = self.languages.clone();
2724
2725        if let Some((upstream_client, project_id)) = self.upstream_client().as_ref() {
2726            let request = upstream_client.request(proto::GetProjectSymbols {
2727                project_id: *project_id,
2728                query: query.to_string(),
2729            });
2730            cx.foreground_executor().spawn(async move {
2731                let response = request.await?;
2732                let mut symbols = Vec::new();
2733                let core_symbols = response
2734                    .symbols
2735                    .into_iter()
2736                    .filter_map(|symbol| Self::deserialize_symbol(symbol).log_err())
2737                    .collect::<Vec<_>>();
2738                populate_labels_for_symbols(
2739                    core_symbols,
2740                    &language_registry,
2741                    None,
2742                    None,
2743                    &mut symbols,
2744                )
2745                .await;
2746                Ok(symbols)
2747            })
2748        } else {
2749            struct WorkspaceSymbolsResult {
2750                lsp_adapter: Arc<CachedLspAdapter>,
2751                language: LanguageName,
2752                worktree: WeakModel<Worktree>,
2753                worktree_abs_path: Arc<Path>,
2754                lsp_symbols: Vec<(String, SymbolKind, lsp::Location)>,
2755            }
2756
2757            let mut requests = Vec::new();
2758            for ((worktree_id, _), server_id) in self.language_server_ids.iter() {
2759                let Some(worktree_handle) = self
2760                    .worktree_store
2761                    .read(cx)
2762                    .worktree_for_id(*worktree_id, cx)
2763                else {
2764                    continue;
2765                };
2766                let worktree = worktree_handle.read(cx);
2767                if !worktree.is_visible() {
2768                    continue;
2769                }
2770                let worktree_abs_path = worktree.abs_path().clone();
2771
2772                let (lsp_adapter, language, server) =
2773                    match self.as_local().unwrap().language_servers.get(server_id) {
2774                        Some(LanguageServerState::Running {
2775                            adapter,
2776                            language,
2777                            server,
2778                            ..
2779                        }) => (adapter.clone(), language.clone(), server),
2780
2781                        _ => continue,
2782                    };
2783
2784                requests.push(
2785                        server
2786                            .request::<lsp::request::WorkspaceSymbolRequest>(
2787                                lsp::WorkspaceSymbolParams {
2788                                    query: query.to_string(),
2789                                    ..Default::default()
2790                                },
2791                            )
2792                            .log_err()
2793                            .map(move |response| {
2794                                let lsp_symbols = response.flatten().map(|symbol_response| match symbol_response {
2795                                    lsp::WorkspaceSymbolResponse::Flat(flat_responses) => {
2796                                        flat_responses.into_iter().map(|lsp_symbol| {
2797                                            (lsp_symbol.name, lsp_symbol.kind, lsp_symbol.location)
2798                                        }).collect::<Vec<_>>()
2799                                    }
2800                                    lsp::WorkspaceSymbolResponse::Nested(nested_responses) => {
2801                                        nested_responses.into_iter().filter_map(|lsp_symbol| {
2802                                            let location = match lsp_symbol.location {
2803                                                OneOf::Left(location) => location,
2804                                                OneOf::Right(_) => {
2805                                                    log::error!("Unexpected: client capabilities forbid symbol resolutions in workspace.symbol.resolveSupport");
2806                                                    return None
2807                                                }
2808                                            };
2809                                            Some((lsp_symbol.name, lsp_symbol.kind, location))
2810                                        }).collect::<Vec<_>>()
2811                                    }
2812                                }).unwrap_or_default();
2813
2814                                WorkspaceSymbolsResult {
2815                                    lsp_adapter,
2816                                    language,
2817                                    worktree: worktree_handle.downgrade(),
2818                                    worktree_abs_path,
2819                                    lsp_symbols,
2820                                }
2821                            }),
2822                    );
2823            }
2824
2825            cx.spawn(move |this, mut cx| async move {
2826                let responses = futures::future::join_all(requests).await;
2827                let this = match this.upgrade() {
2828                    Some(this) => this,
2829                    None => return Ok(Vec::new()),
2830                };
2831
2832                let mut symbols = Vec::new();
2833                for result in responses {
2834                    let core_symbols = this.update(&mut cx, |this, cx| {
2835                        result
2836                            .lsp_symbols
2837                            .into_iter()
2838                            .filter_map(|(symbol_name, symbol_kind, symbol_location)| {
2839                                let abs_path = symbol_location.uri.to_file_path().ok()?;
2840                                let source_worktree = result.worktree.upgrade()?;
2841                                let source_worktree_id = source_worktree.read(cx).id();
2842
2843                                let path;
2844                                let worktree;
2845                                if let Some((tree, rel_path)) =
2846                                    this.worktree_store.read(cx).find_worktree(&abs_path, cx)
2847                                {
2848                                    worktree = tree;
2849                                    path = rel_path;
2850                                } else {
2851                                    worktree = source_worktree.clone();
2852                                    path = relativize_path(&result.worktree_abs_path, &abs_path);
2853                                }
2854
2855                                let worktree_id = worktree.read(cx).id();
2856                                let project_path = ProjectPath {
2857                                    worktree_id,
2858                                    path: path.into(),
2859                                };
2860                                let signature = this.symbol_signature(&project_path);
2861                                Some(CoreSymbol {
2862                                    language_server_name: result.lsp_adapter.name.clone(),
2863                                    source_worktree_id,
2864                                    path: project_path,
2865                                    kind: symbol_kind,
2866                                    name: symbol_name,
2867                                    range: range_from_lsp(symbol_location.range),
2868                                    signature,
2869                                })
2870                            })
2871                            .collect()
2872                    })?;
2873
2874                    populate_labels_for_symbols(
2875                        core_symbols,
2876                        &language_registry,
2877                        Some(result.language),
2878                        Some(result.lsp_adapter),
2879                        &mut symbols,
2880                    )
2881                    .await;
2882                }
2883
2884                Ok(symbols)
2885            })
2886        }
2887    }
2888
2889    pub fn diagnostic_summaries<'a>(
2890        &'a self,
2891        include_ignored: bool,
2892        cx: &'a AppContext,
2893    ) -> impl Iterator<Item = (ProjectPath, LanguageServerId, DiagnosticSummary)> + 'a {
2894        self.worktree_store
2895            .read(cx)
2896            .visible_worktrees(cx)
2897            .filter_map(|worktree| {
2898                let worktree = worktree.read(cx);
2899                Some((worktree, self.diagnostic_summaries.get(&worktree.id())?))
2900            })
2901            .flat_map(move |(worktree, summaries)| {
2902                let worktree_id = worktree.id();
2903                summaries
2904                    .iter()
2905                    .filter(move |(path, _)| {
2906                        include_ignored
2907                            || worktree
2908                                .entry_for_path(path.as_ref())
2909                                .map_or(false, |entry| !entry.is_ignored)
2910                    })
2911                    .flat_map(move |(path, summaries)| {
2912                        summaries.iter().map(move |(server_id, summary)| {
2913                            (
2914                                ProjectPath {
2915                                    worktree_id,
2916                                    path: path.clone(),
2917                                },
2918                                *server_id,
2919                                *summary,
2920                            )
2921                        })
2922                    })
2923            })
2924    }
2925
2926    pub fn started_language_servers(&self) -> Vec<(WorktreeId, LanguageServerName)> {
2927        self.language_server_ids.keys().cloned().collect()
2928    }
2929
2930    pub fn on_buffer_edited(
2931        &mut self,
2932        buffer: Model<Buffer>,
2933        cx: &mut ModelContext<Self>,
2934    ) -> Option<()> {
2935        let buffer = buffer.read(cx);
2936        let file = File::from_dyn(buffer.file())?;
2937        let abs_path = file.as_local()?.abs_path(cx);
2938        let uri = lsp::Url::from_file_path(abs_path).unwrap();
2939        let next_snapshot = buffer.text_snapshot();
2940
2941        let language_servers: Vec<_> = self
2942            .language_servers_for_buffer(buffer, cx)
2943            .map(|i| i.1.clone())
2944            .collect();
2945
2946        for language_server in language_servers {
2947            let language_server = language_server.clone();
2948
2949            let buffer_snapshots = self
2950                .buffer_snapshots
2951                .get_mut(&buffer.remote_id())
2952                .and_then(|m| m.get_mut(&language_server.server_id()))?;
2953            let previous_snapshot = buffer_snapshots.last()?;
2954
2955            let build_incremental_change = || {
2956                buffer
2957                    .edits_since::<(PointUtf16, usize)>(previous_snapshot.snapshot.version())
2958                    .map(|edit| {
2959                        let edit_start = edit.new.start.0;
2960                        let edit_end = edit_start + (edit.old.end.0 - edit.old.start.0);
2961                        let new_text = next_snapshot
2962                            .text_for_range(edit.new.start.1..edit.new.end.1)
2963                            .collect();
2964                        lsp::TextDocumentContentChangeEvent {
2965                            range: Some(lsp::Range::new(
2966                                point_to_lsp(edit_start),
2967                                point_to_lsp(edit_end),
2968                            )),
2969                            range_length: None,
2970                            text: new_text,
2971                        }
2972                    })
2973                    .collect()
2974            };
2975
2976            let document_sync_kind = language_server
2977                .capabilities()
2978                .text_document_sync
2979                .as_ref()
2980                .and_then(|sync| match sync {
2981                    lsp::TextDocumentSyncCapability::Kind(kind) => Some(*kind),
2982                    lsp::TextDocumentSyncCapability::Options(options) => options.change,
2983                });
2984
2985            let content_changes: Vec<_> = match document_sync_kind {
2986                Some(lsp::TextDocumentSyncKind::FULL) => {
2987                    vec![lsp::TextDocumentContentChangeEvent {
2988                        range: None,
2989                        range_length: None,
2990                        text: next_snapshot.text(),
2991                    }]
2992                }
2993                Some(lsp::TextDocumentSyncKind::INCREMENTAL) => build_incremental_change(),
2994                _ => {
2995                    #[cfg(any(test, feature = "test-support"))]
2996                    {
2997                        build_incremental_change()
2998                    }
2999
3000                    #[cfg(not(any(test, feature = "test-support")))]
3001                    {
3002                        continue;
3003                    }
3004                }
3005            };
3006
3007            let next_version = previous_snapshot.version + 1;
3008            buffer_snapshots.push(LspBufferSnapshot {
3009                version: next_version,
3010                snapshot: next_snapshot.clone(),
3011            });
3012
3013            language_server
3014                .notify::<lsp::notification::DidChangeTextDocument>(
3015                    lsp::DidChangeTextDocumentParams {
3016                        text_document: lsp::VersionedTextDocumentIdentifier::new(
3017                            uri.clone(),
3018                            next_version,
3019                        ),
3020                        content_changes,
3021                    },
3022                )
3023                .log_err();
3024        }
3025
3026        None
3027    }
3028
3029    pub fn on_buffer_saved(
3030        &mut self,
3031        buffer: Model<Buffer>,
3032        cx: &mut ModelContext<Self>,
3033    ) -> Option<()> {
3034        let file = File::from_dyn(buffer.read(cx).file())?;
3035        let worktree_id = file.worktree_id(cx);
3036        let abs_path = file.as_local()?.abs_path(cx);
3037        let text_document = lsp::TextDocumentIdentifier {
3038            uri: lsp::Url::from_file_path(abs_path).log_err()?,
3039        };
3040
3041        for server in self.language_servers_for_worktree(worktree_id) {
3042            if let Some(include_text) = include_text(server.as_ref()) {
3043                let text = if include_text {
3044                    Some(buffer.read(cx).text())
3045                } else {
3046                    None
3047                };
3048                server
3049                    .notify::<lsp::notification::DidSaveTextDocument>(
3050                        lsp::DidSaveTextDocumentParams {
3051                            text_document: text_document.clone(),
3052                            text,
3053                        },
3054                    )
3055                    .log_err();
3056            }
3057        }
3058
3059        for language_server_id in self.language_server_ids_for_buffer(buffer.read(cx), cx) {
3060            self.simulate_disk_based_diagnostics_events_if_needed(language_server_id, cx);
3061        }
3062
3063        None
3064    }
3065
3066    pub(crate) async fn refresh_workspace_configurations(
3067        this: &WeakModel<Self>,
3068        mut cx: AsyncAppContext,
3069    ) {
3070        maybe!(async move {
3071            let servers = this
3072                .update(&mut cx, |this, cx| {
3073                    this.language_server_ids
3074                        .iter()
3075                        .filter_map(|((worktree_id, _), server_id)| {
3076                            let worktree = this
3077                                .worktree_store
3078                                .read(cx)
3079                                .worktree_for_id(*worktree_id, cx)?;
3080                            let state = this.as_local()?.language_servers.get(server_id)?;
3081                            let delegate = LocalLspAdapterDelegate::for_local(this, &worktree, cx);
3082                            match state {
3083                                LanguageServerState::Starting(_) => None,
3084                                LanguageServerState::Running {
3085                                    adapter, server, ..
3086                                } => Some((
3087                                    adapter.adapter.clone(),
3088                                    server.clone(),
3089                                    delegate as Arc<dyn LspAdapterDelegate>,
3090                                )),
3091                            }
3092                        })
3093                        .collect::<Vec<_>>()
3094                })
3095                .ok()?;
3096
3097            let toolchain_store = this
3098                .update(&mut cx, |this, cx| this.toolchain_store(cx))
3099                .ok()?;
3100            for (adapter, server, delegate) in servers {
3101                let settings = adapter
3102                    .workspace_configuration(&delegate, toolchain_store.clone(), &mut cx)
3103                    .await
3104                    .ok()?;
3105
3106                server
3107                    .notify::<lsp::notification::DidChangeConfiguration>(
3108                        lsp::DidChangeConfigurationParams { settings },
3109                    )
3110                    .ok();
3111            }
3112            Some(())
3113        })
3114        .await;
3115    }
3116
3117    fn toolchain_store(&self, cx: &AppContext) -> Arc<dyn LanguageToolchainStore> {
3118        if let Some(toolchain_store) = self.toolchain_store.as_ref() {
3119            toolchain_store.read(cx).as_language_toolchain_store()
3120        } else {
3121            Arc::new(EmptyToolchainStore)
3122        }
3123    }
3124    fn maintain_workspace_config(
3125        external_refresh_requests: watch::Receiver<()>,
3126        cx: &mut ModelContext<Self>,
3127    ) -> Task<Result<()>> {
3128        let (mut settings_changed_tx, mut settings_changed_rx) = watch::channel();
3129        let _ = postage::stream::Stream::try_recv(&mut settings_changed_rx);
3130
3131        let settings_observation = cx.observe_global::<SettingsStore>(move |_, _| {
3132            *settings_changed_tx.borrow_mut() = ();
3133        });
3134
3135        let mut joint_future =
3136            futures::stream::select(settings_changed_rx, external_refresh_requests);
3137        cx.spawn(move |this, cx| async move {
3138            while let Some(()) = joint_future.next().await {
3139                Self::refresh_workspace_configurations(&this, cx.clone()).await;
3140            }
3141
3142            drop(settings_observation);
3143            anyhow::Ok(())
3144        })
3145    }
3146
3147    fn primary_language_server_for_buffer<'a>(
3148        &'a self,
3149        buffer: &'a Buffer,
3150        cx: &'a AppContext,
3151    ) -> Option<(&'a Arc<CachedLspAdapter>, &'a Arc<LanguageServer>)> {
3152        // The list of language servers is ordered based on the `language_servers` setting
3153        // for each language, thus we can consider the first one in the list to be the
3154        // primary one.
3155        self.language_servers_for_buffer(buffer, cx).next()
3156    }
3157
3158    pub fn language_server_for_buffer<'a>(
3159        &'a self,
3160        buffer: &'a Buffer,
3161        server_id: LanguageServerId,
3162        cx: &'a AppContext,
3163    ) -> Option<(&'a Arc<CachedLspAdapter>, &'a Arc<LanguageServer>)> {
3164        self.language_servers_for_buffer(buffer, cx)
3165            .find(|(_, s)| s.server_id() == server_id)
3166    }
3167
3168    fn language_servers_for_worktree(
3169        &self,
3170        worktree_id: WorktreeId,
3171    ) -> impl Iterator<Item = &Arc<LanguageServer>> {
3172        self.language_server_ids
3173            .iter()
3174            .filter_map(move |((language_server_worktree_id, _), id)| {
3175                if *language_server_worktree_id == worktree_id {
3176                    if let Some(LanguageServerState::Running { server, .. }) =
3177                        self.as_local()?.language_servers.get(id)
3178                    {
3179                        return Some(server);
3180                    }
3181                }
3182                None
3183            })
3184    }
3185
3186    fn remove_worktree(&mut self, id_to_remove: WorktreeId, cx: &mut ModelContext<Self>) {
3187        self.diagnostics.remove(&id_to_remove);
3188        self.diagnostic_summaries.remove(&id_to_remove);
3189
3190        let mut servers_to_remove = HashMap::default();
3191        let mut servers_to_preserve = HashSet::default();
3192        for ((worktree_id, server_name), &server_id) in &self.language_server_ids {
3193            if worktree_id == &id_to_remove {
3194                servers_to_remove.insert(server_id, server_name.clone());
3195            } else {
3196                servers_to_preserve.insert(server_id);
3197            }
3198        }
3199        servers_to_remove.retain(|server_id, _| !servers_to_preserve.contains(server_id));
3200        for (server_id_to_remove, server_name) in servers_to_remove {
3201            self.language_server_ids
3202                .remove(&(id_to_remove, server_name));
3203            self.language_server_statuses.remove(&server_id_to_remove);
3204            if let Some(local_lsp_store) = self.as_local_mut() {
3205                local_lsp_store
3206                    .language_server_watched_paths
3207                    .remove(&server_id_to_remove);
3208                local_lsp_store
3209                    .last_workspace_edits_by_language_server
3210                    .remove(&server_id_to_remove);
3211                local_lsp_store
3212                    .language_servers
3213                    .remove(&server_id_to_remove);
3214            }
3215            cx.emit(LspStoreEvent::LanguageServerRemoved(server_id_to_remove));
3216        }
3217
3218        if let Some(local) = self.as_local() {
3219            local.prettier_store.update(cx, |prettier_store, cx| {
3220                prettier_store.remove_worktree(id_to_remove, cx);
3221            })
3222        }
3223    }
3224
3225    pub fn shared(
3226        &mut self,
3227        project_id: u64,
3228        downstream_client: AnyProtoClient,
3229        _: &mut ModelContext<Self>,
3230    ) {
3231        self.downstream_client = Some((downstream_client.clone(), project_id));
3232
3233        for (server_id, status) in &self.language_server_statuses {
3234            downstream_client
3235                .send(proto::StartLanguageServer {
3236                    project_id,
3237                    server: Some(proto::LanguageServer {
3238                        id: server_id.0 as u64,
3239                        name: status.name.clone(),
3240                        worktree_id: None,
3241                    }),
3242                })
3243                .log_err();
3244        }
3245    }
3246
3247    pub fn disconnected_from_host(&mut self) {
3248        self.downstream_client.take();
3249    }
3250
3251    pub fn disconnected_from_ssh_remote(&mut self) {
3252        if let LspStoreMode::Remote(RemoteLspStore {
3253            upstream_client, ..
3254        }) = &mut self.mode
3255        {
3256            upstream_client.take();
3257        }
3258    }
3259
3260    pub(crate) fn set_language_server_statuses_from_proto(
3261        &mut self,
3262        language_servers: Vec<proto::LanguageServer>,
3263    ) {
3264        self.language_server_statuses = language_servers
3265            .into_iter()
3266            .map(|server| {
3267                (
3268                    LanguageServerId(server.id as usize),
3269                    LanguageServerStatus {
3270                        name: server.name,
3271                        pending_work: Default::default(),
3272                        has_pending_diagnostic_updates: false,
3273                        progress_tokens: Default::default(),
3274                    },
3275                )
3276            })
3277            .collect();
3278    }
3279
3280    pub(crate) fn register_language_server(
3281        &mut self,
3282        worktree_id: WorktreeId,
3283        language_server_name: LanguageServerName,
3284        language_server_id: LanguageServerId,
3285    ) {
3286        self.language_server_ids
3287            .insert((worktree_id, language_server_name), language_server_id);
3288    }
3289
3290    #[track_caller]
3291    pub(crate) fn register_buffer_with_language_servers(
3292        &mut self,
3293        buffer_handle: &Model<Buffer>,
3294        cx: &mut ModelContext<Self>,
3295    ) {
3296        let available_language = self.detect_language_for_buffer(buffer_handle, cx);
3297
3298        let buffer = buffer_handle.read(cx);
3299        let buffer_id = buffer.remote_id();
3300
3301        if let Some(file) = File::from_dyn(buffer.file()) {
3302            if !file.is_local() {
3303                return;
3304            }
3305
3306            let abs_path = file.abs_path(cx);
3307            let Some(uri) = lsp::Url::from_file_path(&abs_path).log_err() else {
3308                return;
3309            };
3310            let initial_snapshot = buffer.text_snapshot();
3311            let worktree_id = file.worktree_id(cx);
3312
3313            if let Some(diagnostics) = self.diagnostics.get(&worktree_id) {
3314                for (server_id, diagnostics) in
3315                    diagnostics.get(file.path()).cloned().unwrap_or_default()
3316                {
3317                    self.update_buffer_diagnostics(buffer_handle, server_id, None, diagnostics, cx)
3318                        .log_err();
3319                }
3320            }
3321
3322            if let Some(language) = available_language {
3323                for adapter in self.languages.lsp_adapters(&language.name()) {
3324                    let server = self
3325                        .language_server_ids
3326                        .get(&(worktree_id, adapter.name.clone()))
3327                        .and_then(|id| self.as_local()?.language_servers.get(id))
3328                        .and_then(|server_state| {
3329                            if let LanguageServerState::Running { server, .. } = server_state {
3330                                Some(server.clone())
3331                            } else {
3332                                None
3333                            }
3334                        });
3335                    let server = match server {
3336                        Some(server) => server,
3337                        None => continue,
3338                    };
3339
3340                    server
3341                        .notify::<lsp::notification::DidOpenTextDocument>(
3342                            lsp::DidOpenTextDocumentParams {
3343                                text_document: lsp::TextDocumentItem::new(
3344                                    uri.clone(),
3345                                    adapter.language_id(&language.name()),
3346                                    0,
3347                                    initial_snapshot.text(),
3348                                ),
3349                            },
3350                        )
3351                        .log_err();
3352
3353                    buffer_handle.update(cx, |buffer, cx| {
3354                        buffer.set_completion_triggers(
3355                            server.server_id(),
3356                            server
3357                                .capabilities()
3358                                .completion_provider
3359                                .as_ref()
3360                                .and_then(|provider| {
3361                                    provider
3362                                        .trigger_characters
3363                                        .as_ref()
3364                                        .map(|characters| characters.iter().cloned().collect())
3365                                })
3366                                .unwrap_or_default(),
3367                            cx,
3368                        );
3369                    });
3370
3371                    let snapshot = LspBufferSnapshot {
3372                        version: 0,
3373                        snapshot: initial_snapshot.clone(),
3374                    };
3375                    self.buffer_snapshots
3376                        .entry(buffer_id)
3377                        .or_default()
3378                        .insert(server.server_id(), vec![snapshot]);
3379                }
3380            }
3381        }
3382    }
3383
3384    pub(crate) fn unregister_buffer_from_language_servers(
3385        &mut self,
3386        buffer: &Model<Buffer>,
3387        old_file: &File,
3388        cx: &mut AppContext,
3389    ) {
3390        let old_path = match old_file.as_local() {
3391            Some(local) => local.abs_path(cx),
3392            None => return,
3393        };
3394
3395        buffer.update(cx, |buffer, cx| {
3396            let worktree_id = old_file.worktree_id(cx);
3397
3398            let ids = &self.language_server_ids;
3399
3400            if let Some(language) = buffer.language().cloned() {
3401                for adapter in self.languages.lsp_adapters(&language.name()) {
3402                    if let Some(server_id) = ids.get(&(worktree_id, adapter.name.clone())) {
3403                        buffer.update_diagnostics(*server_id, DiagnosticSet::new([], buffer), cx);
3404                        buffer.set_completion_triggers(*server_id, Default::default(), cx);
3405                    }
3406                }
3407            }
3408
3409            self.buffer_snapshots.remove(&buffer.remote_id());
3410            let file_url = lsp::Url::from_file_path(old_path).unwrap();
3411            for (_, language_server) in self.language_servers_for_buffer(buffer, cx) {
3412                language_server
3413                    .notify::<lsp::notification::DidCloseTextDocument>(
3414                        lsp::DidCloseTextDocumentParams {
3415                            text_document: lsp::TextDocumentIdentifier::new(file_url.clone()),
3416                        },
3417                    )
3418                    .log_err();
3419            }
3420        });
3421    }
3422
3423    pub fn update_diagnostic_entries(
3424        &mut self,
3425        server_id: LanguageServerId,
3426        abs_path: PathBuf,
3427        version: Option<i32>,
3428        diagnostics: Vec<DiagnosticEntry<Unclipped<PointUtf16>>>,
3429        cx: &mut ModelContext<Self>,
3430    ) -> Result<(), anyhow::Error> {
3431        let Some((worktree, relative_path)) =
3432            self.worktree_store.read(cx).find_worktree(&abs_path, cx)
3433        else {
3434            log::warn!("skipping diagnostics update, no worktree found for path {abs_path:?}");
3435            return Ok(());
3436        };
3437
3438        let project_path = ProjectPath {
3439            worktree_id: worktree.read(cx).id(),
3440            path: relative_path.into(),
3441        };
3442
3443        if let Some(buffer) = self.buffer_store.read(cx).get_by_path(&project_path, cx) {
3444            self.update_buffer_diagnostics(&buffer, server_id, version, diagnostics.clone(), cx)?;
3445        }
3446
3447        let updated = worktree.update(cx, |worktree, cx| {
3448            self.update_worktree_diagnostics(
3449                worktree.id(),
3450                server_id,
3451                project_path.path.clone(),
3452                diagnostics,
3453                cx,
3454            )
3455        })?;
3456        if updated {
3457            cx.emit(LspStoreEvent::DiagnosticsUpdated {
3458                language_server_id: server_id,
3459                path: project_path,
3460            })
3461        }
3462        Ok(())
3463    }
3464
3465    fn update_worktree_diagnostics(
3466        &mut self,
3467        worktree_id: WorktreeId,
3468        server_id: LanguageServerId,
3469        worktree_path: Arc<Path>,
3470        diagnostics: Vec<DiagnosticEntry<Unclipped<PointUtf16>>>,
3471        _: &mut ModelContext<Worktree>,
3472    ) -> Result<bool> {
3473        let summaries_for_tree = self.diagnostic_summaries.entry(worktree_id).or_default();
3474        let diagnostics_for_tree = self.diagnostics.entry(worktree_id).or_default();
3475        let summaries_by_server_id = summaries_for_tree.entry(worktree_path.clone()).or_default();
3476
3477        let old_summary = summaries_by_server_id
3478            .remove(&server_id)
3479            .unwrap_or_default();
3480
3481        let new_summary = DiagnosticSummary::new(&diagnostics);
3482        if new_summary.is_empty() {
3483            if let Some(diagnostics_by_server_id) = diagnostics_for_tree.get_mut(&worktree_path) {
3484                if let Ok(ix) = diagnostics_by_server_id.binary_search_by_key(&server_id, |e| e.0) {
3485                    diagnostics_by_server_id.remove(ix);
3486                }
3487                if diagnostics_by_server_id.is_empty() {
3488                    diagnostics_for_tree.remove(&worktree_path);
3489                }
3490            }
3491        } else {
3492            summaries_by_server_id.insert(server_id, new_summary);
3493            let diagnostics_by_server_id = diagnostics_for_tree
3494                .entry(worktree_path.clone())
3495                .or_default();
3496            match diagnostics_by_server_id.binary_search_by_key(&server_id, |e| e.0) {
3497                Ok(ix) => {
3498                    diagnostics_by_server_id[ix] = (server_id, diagnostics);
3499                }
3500                Err(ix) => {
3501                    diagnostics_by_server_id.insert(ix, (server_id, diagnostics));
3502                }
3503            }
3504        }
3505
3506        if !old_summary.is_empty() || !new_summary.is_empty() {
3507            if let Some((downstream_client, project_id)) = &self.downstream_client {
3508                downstream_client
3509                    .send(proto::UpdateDiagnosticSummary {
3510                        project_id: *project_id,
3511                        worktree_id: worktree_id.to_proto(),
3512                        summary: Some(proto::DiagnosticSummary {
3513                            path: worktree_path.to_string_lossy().to_string(),
3514                            language_server_id: server_id.0 as u64,
3515                            error_count: new_summary.error_count as u32,
3516                            warning_count: new_summary.warning_count as u32,
3517                        }),
3518                    })
3519                    .log_err();
3520            }
3521        }
3522
3523        Ok(!old_summary.is_empty() || !new_summary.is_empty())
3524    }
3525
3526    pub fn open_buffer_for_symbol(
3527        &mut self,
3528        symbol: &Symbol,
3529        cx: &mut ModelContext<Self>,
3530    ) -> Task<Result<Model<Buffer>>> {
3531        if let Some((client, project_id)) = self.upstream_client() {
3532            let request = client.request(proto::OpenBufferForSymbol {
3533                project_id,
3534                symbol: Some(Self::serialize_symbol(symbol)),
3535            });
3536            cx.spawn(move |this, mut cx| async move {
3537                let response = request.await?;
3538                let buffer_id = BufferId::new(response.buffer_id)?;
3539                this.update(&mut cx, |this, cx| {
3540                    this.wait_for_remote_buffer(buffer_id, cx)
3541                })?
3542                .await
3543            })
3544        } else {
3545            let Some(&language_server_id) = self.language_server_ids.get(&(
3546                symbol.source_worktree_id,
3547                symbol.language_server_name.clone(),
3548            )) else {
3549                return Task::ready(Err(anyhow!(
3550                    "language server for worktree and language not found"
3551                )));
3552            };
3553
3554            let worktree_abs_path = if let Some(worktree_abs_path) = self
3555                .worktree_store
3556                .read(cx)
3557                .worktree_for_id(symbol.path.worktree_id, cx)
3558                .map(|worktree| worktree.read(cx).abs_path())
3559            {
3560                worktree_abs_path
3561            } else {
3562                return Task::ready(Err(anyhow!("worktree not found for symbol")));
3563            };
3564
3565            let symbol_abs_path = resolve_path(&worktree_abs_path, &symbol.path.path);
3566            let symbol_uri = if let Ok(uri) = lsp::Url::from_file_path(symbol_abs_path) {
3567                uri
3568            } else {
3569                return Task::ready(Err(anyhow!("invalid symbol path")));
3570            };
3571
3572            self.open_local_buffer_via_lsp(
3573                symbol_uri,
3574                language_server_id,
3575                symbol.language_server_name.clone(),
3576                cx,
3577            )
3578        }
3579    }
3580
3581    pub fn open_local_buffer_via_lsp(
3582        &mut self,
3583        mut abs_path: lsp::Url,
3584        language_server_id: LanguageServerId,
3585        language_server_name: LanguageServerName,
3586        cx: &mut ModelContext<Self>,
3587    ) -> Task<Result<Model<Buffer>>> {
3588        cx.spawn(move |lsp_store, mut cx| async move {
3589            // Escape percent-encoded string.
3590            let current_scheme = abs_path.scheme().to_owned();
3591            let _ = abs_path.set_scheme("file");
3592
3593            let abs_path = abs_path
3594                .to_file_path()
3595                .map_err(|_| anyhow!("can't convert URI to path"))?;
3596            let p = abs_path.clone();
3597            let yarn_worktree = lsp_store
3598                .update(&mut cx, move |lsp_store, cx| match lsp_store.as_local() {
3599                    Some(local_lsp_store) => local_lsp_store.yarn.update(cx, |_, cx| {
3600                        cx.spawn(|this, mut cx| async move {
3601                            let t = this
3602                                .update(&mut cx, |this, cx| {
3603                                    this.process_path(&p, &current_scheme, cx)
3604                                })
3605                                .ok()?;
3606                            t.await
3607                        })
3608                    }),
3609                    None => Task::ready(None),
3610                })?
3611                .await;
3612            let (worktree_root_target, known_relative_path) =
3613                if let Some((zip_root, relative_path)) = yarn_worktree {
3614                    (zip_root, Some(relative_path))
3615                } else {
3616                    (Arc::<Path>::from(abs_path.as_path()), None)
3617                };
3618            let (worktree, relative_path) = if let Some(result) =
3619                lsp_store.update(&mut cx, |lsp_store, cx| {
3620                    lsp_store.worktree_store.update(cx, |worktree_store, cx| {
3621                        worktree_store.find_worktree(&worktree_root_target, cx)
3622                    })
3623                })? {
3624                let relative_path =
3625                    known_relative_path.unwrap_or_else(|| Arc::<Path>::from(result.1));
3626                (result.0, relative_path)
3627            } else {
3628                let worktree = lsp_store
3629                    .update(&mut cx, |lsp_store, cx| {
3630                        lsp_store.worktree_store.update(cx, |worktree_store, cx| {
3631                            worktree_store.create_worktree(&worktree_root_target, false, cx)
3632                        })
3633                    })?
3634                    .await?;
3635                if worktree.update(&mut cx, |worktree, _| worktree.is_local())? {
3636                    lsp_store
3637                        .update(&mut cx, |lsp_store, cx| {
3638                            lsp_store.register_language_server(
3639                                worktree.read(cx).id(),
3640                                language_server_name,
3641                                language_server_id,
3642                            )
3643                        })
3644                        .ok();
3645                }
3646                let worktree_root = worktree.update(&mut cx, |worktree, _| worktree.abs_path())?;
3647                let relative_path = if let Some(known_path) = known_relative_path {
3648                    known_path
3649                } else {
3650                    abs_path.strip_prefix(worktree_root)?.into()
3651                };
3652                (worktree, relative_path)
3653            };
3654            let project_path = ProjectPath {
3655                worktree_id: worktree.update(&mut cx, |worktree, _| worktree.id())?,
3656                path: relative_path,
3657            };
3658            lsp_store
3659                .update(&mut cx, |lsp_store, cx| {
3660                    lsp_store.buffer_store().update(cx, |buffer_store, cx| {
3661                        buffer_store.open_buffer(project_path, cx)
3662                    })
3663                })?
3664                .await
3665        })
3666    }
3667
3668    pub(crate) fn update_buffer_diagnostics(
3669        &mut self,
3670        buffer: &Model<Buffer>,
3671        server_id: LanguageServerId,
3672        version: Option<i32>,
3673        mut diagnostics: Vec<DiagnosticEntry<Unclipped<PointUtf16>>>,
3674        cx: &mut ModelContext<Self>,
3675    ) -> Result<()> {
3676        fn compare_diagnostics(a: &Diagnostic, b: &Diagnostic) -> Ordering {
3677            Ordering::Equal
3678                .then_with(|| b.is_primary.cmp(&a.is_primary))
3679                .then_with(|| a.is_disk_based.cmp(&b.is_disk_based))
3680                .then_with(|| a.severity.cmp(&b.severity))
3681                .then_with(|| a.message.cmp(&b.message))
3682        }
3683
3684        let snapshot = self.buffer_snapshot_for_lsp_version(buffer, server_id, version, cx)?;
3685
3686        diagnostics.sort_unstable_by(|a, b| {
3687            Ordering::Equal
3688                .then_with(|| a.range.start.cmp(&b.range.start))
3689                .then_with(|| b.range.end.cmp(&a.range.end))
3690                .then_with(|| compare_diagnostics(&a.diagnostic, &b.diagnostic))
3691        });
3692
3693        let mut sanitized_diagnostics = Vec::new();
3694        let edits_since_save = Patch::new(
3695            snapshot
3696                .edits_since::<Unclipped<PointUtf16>>(buffer.read(cx).saved_version())
3697                .collect(),
3698        );
3699        for entry in diagnostics {
3700            let start;
3701            let end;
3702            if entry.diagnostic.is_disk_based {
3703                // Some diagnostics are based on files on disk instead of buffers'
3704                // current contents. Adjust these diagnostics' ranges to reflect
3705                // any unsaved edits.
3706                start = edits_since_save.old_to_new(entry.range.start);
3707                end = edits_since_save.old_to_new(entry.range.end);
3708            } else {
3709                start = entry.range.start;
3710                end = entry.range.end;
3711            }
3712
3713            let mut range = snapshot.clip_point_utf16(start, Bias::Left)
3714                ..snapshot.clip_point_utf16(end, Bias::Right);
3715
3716            // Expand empty ranges by one codepoint
3717            if range.start == range.end {
3718                // This will be go to the next boundary when being clipped
3719                range.end.column += 1;
3720                range.end = snapshot.clip_point_utf16(Unclipped(range.end), Bias::Right);
3721                if range.start == range.end && range.end.column > 0 {
3722                    range.start.column -= 1;
3723                    range.start = snapshot.clip_point_utf16(Unclipped(range.start), Bias::Left);
3724                }
3725            }
3726
3727            sanitized_diagnostics.push(DiagnosticEntry {
3728                range,
3729                diagnostic: entry.diagnostic,
3730            });
3731        }
3732        drop(edits_since_save);
3733
3734        let set = DiagnosticSet::new(sanitized_diagnostics, &snapshot);
3735        buffer.update(cx, |buffer, cx| {
3736            buffer.update_diagnostics(server_id, set, cx)
3737        });
3738        Ok(())
3739    }
3740
3741    fn request_multiple_lsp_locally<P, R>(
3742        &self,
3743        buffer: &Model<Buffer>,
3744        position: Option<P>,
3745        request: R,
3746        cx: &mut ModelContext<'_, Self>,
3747    ) -> Task<Vec<R::Response>>
3748    where
3749        P: ToOffset,
3750        R: LspCommand + Clone,
3751        <R::LspRequest as lsp::request::Request>::Result: Send,
3752        <R::LspRequest as lsp::request::Request>::Params: Send,
3753    {
3754        debug_assert!(self.upstream_client().is_none());
3755
3756        let snapshot = buffer.read(cx).snapshot();
3757        let scope = position.and_then(|position| snapshot.language_scope_at(position));
3758        let server_ids = self
3759            .language_servers_for_buffer(buffer.read(cx), cx)
3760            .filter(|(adapter, _)| {
3761                scope
3762                    .as_ref()
3763                    .map(|scope| scope.language_allowed(&adapter.name))
3764                    .unwrap_or(true)
3765            })
3766            .map(|(_, server)| server.server_id())
3767            .collect::<Vec<_>>();
3768
3769        let mut response_results = server_ids
3770            .into_iter()
3771            .map(|server_id| {
3772                self.request_lsp(
3773                    buffer.clone(),
3774                    LanguageServerToQuery::Other(server_id),
3775                    request.clone(),
3776                    cx,
3777                )
3778            })
3779            .collect::<FuturesUnordered<_>>();
3780
3781        cx.spawn(|_, _| async move {
3782            let mut responses = Vec::with_capacity(response_results.len());
3783            while let Some(response_result) = response_results.next().await {
3784                if let Some(response) = response_result.log_err() {
3785                    responses.push(response);
3786                }
3787            }
3788            responses
3789        })
3790    }
3791
3792    async fn handle_lsp_command<T: LspCommand>(
3793        this: Model<Self>,
3794        envelope: TypedEnvelope<T::ProtoRequest>,
3795        mut cx: AsyncAppContext,
3796    ) -> Result<<T::ProtoRequest as proto::RequestMessage>::Response>
3797    where
3798        <T::LspRequest as lsp::request::Request>::Params: Send,
3799        <T::LspRequest as lsp::request::Request>::Result: Send,
3800    {
3801        let sender_id = envelope.original_sender_id().unwrap_or_default();
3802        let buffer_id = T::buffer_id_from_proto(&envelope.payload)?;
3803        let buffer_handle = this.update(&mut cx, |this, cx| {
3804            this.buffer_store.read(cx).get_existing(buffer_id)
3805        })??;
3806        let request = T::from_proto(
3807            envelope.payload,
3808            this.clone(),
3809            buffer_handle.clone(),
3810            cx.clone(),
3811        )
3812        .await?;
3813        let response = this
3814            .update(&mut cx, |this, cx| {
3815                this.request_lsp(
3816                    buffer_handle.clone(),
3817                    LanguageServerToQuery::Primary,
3818                    request,
3819                    cx,
3820                )
3821            })?
3822            .await?;
3823        this.update(&mut cx, |this, cx| {
3824            Ok(T::response_to_proto(
3825                response,
3826                this,
3827                sender_id,
3828                &buffer_handle.read(cx).version(),
3829                cx,
3830            ))
3831        })?
3832    }
3833
3834    async fn handle_multi_lsp_query(
3835        this: Model<Self>,
3836        envelope: TypedEnvelope<proto::MultiLspQuery>,
3837        mut cx: AsyncAppContext,
3838    ) -> Result<proto::MultiLspQueryResponse> {
3839        let response_from_ssh = this.update(&mut cx, |this, _| {
3840            let (upstream_client, project_id) = this.upstream_client()?;
3841            let mut payload = envelope.payload.clone();
3842            payload.project_id = project_id;
3843
3844            Some(upstream_client.request(payload))
3845        })?;
3846        if let Some(response_from_ssh) = response_from_ssh {
3847            return response_from_ssh.await;
3848        }
3849
3850        let sender_id = envelope.original_sender_id().unwrap_or_default();
3851        let buffer_id = BufferId::new(envelope.payload.buffer_id)?;
3852        let version = deserialize_version(&envelope.payload.version);
3853        let buffer = this.update(&mut cx, |this, cx| {
3854            this.buffer_store.read(cx).get_existing(buffer_id)
3855        })??;
3856        buffer
3857            .update(&mut cx, |buffer, _| {
3858                buffer.wait_for_version(version.clone())
3859            })?
3860            .await?;
3861        let buffer_version = buffer.update(&mut cx, |buffer, _| buffer.version())?;
3862        match envelope
3863            .payload
3864            .strategy
3865            .context("invalid request without the strategy")?
3866        {
3867            proto::multi_lsp_query::Strategy::All(_) => {
3868                // currently, there's only one multiple language servers query strategy,
3869                // so just ensure it's specified correctly
3870            }
3871        }
3872        match envelope.payload.request {
3873            Some(proto::multi_lsp_query::Request::GetHover(get_hover)) => {
3874                let get_hover =
3875                    GetHover::from_proto(get_hover, this.clone(), buffer.clone(), cx.clone())
3876                        .await?;
3877                let all_hovers = this
3878                    .update(&mut cx, |this, cx| {
3879                        this.request_multiple_lsp_locally(
3880                            &buffer,
3881                            Some(get_hover.position),
3882                            get_hover,
3883                            cx,
3884                        )
3885                    })?
3886                    .await
3887                    .into_iter()
3888                    .filter_map(|hover| remove_empty_hover_blocks(hover?));
3889                this.update(&mut cx, |project, cx| proto::MultiLspQueryResponse {
3890                    responses: all_hovers
3891                        .map(|hover| proto::LspResponse {
3892                            response: Some(proto::lsp_response::Response::GetHoverResponse(
3893                                GetHover::response_to_proto(
3894                                    Some(hover),
3895                                    project,
3896                                    sender_id,
3897                                    &buffer_version,
3898                                    cx,
3899                                ),
3900                            )),
3901                        })
3902                        .collect(),
3903                })
3904            }
3905            Some(proto::multi_lsp_query::Request::GetCodeActions(get_code_actions)) => {
3906                let get_code_actions = GetCodeActions::from_proto(
3907                    get_code_actions,
3908                    this.clone(),
3909                    buffer.clone(),
3910                    cx.clone(),
3911                )
3912                .await?;
3913
3914                let all_actions = this
3915                    .update(&mut cx, |project, cx| {
3916                        project.request_multiple_lsp_locally(
3917                            &buffer,
3918                            Some(get_code_actions.range.start),
3919                            get_code_actions,
3920                            cx,
3921                        )
3922                    })?
3923                    .await
3924                    .into_iter();
3925
3926                this.update(&mut cx, |project, cx| proto::MultiLspQueryResponse {
3927                    responses: all_actions
3928                        .map(|code_actions| proto::LspResponse {
3929                            response: Some(proto::lsp_response::Response::GetCodeActionsResponse(
3930                                GetCodeActions::response_to_proto(
3931                                    code_actions,
3932                                    project,
3933                                    sender_id,
3934                                    &buffer_version,
3935                                    cx,
3936                                ),
3937                            )),
3938                        })
3939                        .collect(),
3940                })
3941            }
3942            Some(proto::multi_lsp_query::Request::GetSignatureHelp(get_signature_help)) => {
3943                let get_signature_help = GetSignatureHelp::from_proto(
3944                    get_signature_help,
3945                    this.clone(),
3946                    buffer.clone(),
3947                    cx.clone(),
3948                )
3949                .await?;
3950
3951                let all_signatures = this
3952                    .update(&mut cx, |project, cx| {
3953                        project.request_multiple_lsp_locally(
3954                            &buffer,
3955                            Some(get_signature_help.position),
3956                            get_signature_help,
3957                            cx,
3958                        )
3959                    })?
3960                    .await
3961                    .into_iter();
3962
3963                this.update(&mut cx, |project, cx| proto::MultiLspQueryResponse {
3964                    responses: all_signatures
3965                        .map(|signature_help| proto::LspResponse {
3966                            response: Some(
3967                                proto::lsp_response::Response::GetSignatureHelpResponse(
3968                                    GetSignatureHelp::response_to_proto(
3969                                        signature_help,
3970                                        project,
3971                                        sender_id,
3972                                        &buffer_version,
3973                                        cx,
3974                                    ),
3975                                ),
3976                            ),
3977                        })
3978                        .collect(),
3979                })
3980            }
3981            None => anyhow::bail!("empty multi lsp query request"),
3982        }
3983    }
3984
3985    async fn handle_apply_code_action(
3986        this: Model<Self>,
3987        envelope: TypedEnvelope<proto::ApplyCodeAction>,
3988        mut cx: AsyncAppContext,
3989    ) -> Result<proto::ApplyCodeActionResponse> {
3990        let sender_id = envelope.original_sender_id().unwrap_or_default();
3991        let action = Self::deserialize_code_action(
3992            envelope
3993                .payload
3994                .action
3995                .ok_or_else(|| anyhow!("invalid action"))?,
3996        )?;
3997        let apply_code_action = this.update(&mut cx, |this, cx| {
3998            let buffer_id = BufferId::new(envelope.payload.buffer_id)?;
3999            let buffer = this.buffer_store.read(cx).get_existing(buffer_id)?;
4000            anyhow::Ok(this.apply_code_action(buffer, action, false, cx))
4001        })??;
4002
4003        let project_transaction = apply_code_action.await?;
4004        let project_transaction = this.update(&mut cx, |this, cx| {
4005            this.buffer_store.update(cx, |buffer_store, cx| {
4006                buffer_store.serialize_project_transaction_for_peer(
4007                    project_transaction,
4008                    sender_id,
4009                    cx,
4010                )
4011            })
4012        })?;
4013        Ok(proto::ApplyCodeActionResponse {
4014            transaction: Some(project_transaction),
4015        })
4016    }
4017
4018    async fn handle_update_diagnostic_summary(
4019        this: Model<Self>,
4020        envelope: TypedEnvelope<proto::UpdateDiagnosticSummary>,
4021        mut cx: AsyncAppContext,
4022    ) -> Result<()> {
4023        this.update(&mut cx, |this, cx| {
4024            let worktree_id = WorktreeId::from_proto(envelope.payload.worktree_id);
4025            if let Some(message) = envelope.payload.summary {
4026                let project_path = ProjectPath {
4027                    worktree_id,
4028                    path: Path::new(&message.path).into(),
4029                };
4030                let path = project_path.path.clone();
4031                let server_id = LanguageServerId(message.language_server_id as usize);
4032                let summary = DiagnosticSummary {
4033                    error_count: message.error_count as usize,
4034                    warning_count: message.warning_count as usize,
4035                };
4036
4037                if summary.is_empty() {
4038                    if let Some(worktree_summaries) =
4039                        this.diagnostic_summaries.get_mut(&worktree_id)
4040                    {
4041                        if let Some(summaries) = worktree_summaries.get_mut(&path) {
4042                            summaries.remove(&server_id);
4043                            if summaries.is_empty() {
4044                                worktree_summaries.remove(&path);
4045                            }
4046                        }
4047                    }
4048                } else {
4049                    this.diagnostic_summaries
4050                        .entry(worktree_id)
4051                        .or_default()
4052                        .entry(path)
4053                        .or_default()
4054                        .insert(server_id, summary);
4055                }
4056                if let Some((downstream_client, project_id)) = &this.downstream_client {
4057                    downstream_client
4058                        .send(proto::UpdateDiagnosticSummary {
4059                            project_id: *project_id,
4060                            worktree_id: worktree_id.to_proto(),
4061                            summary: Some(proto::DiagnosticSummary {
4062                                path: project_path.path.to_string_lossy().to_string(),
4063                                language_server_id: server_id.0 as u64,
4064                                error_count: summary.error_count as u32,
4065                                warning_count: summary.warning_count as u32,
4066                            }),
4067                        })
4068                        .log_err();
4069                }
4070                cx.emit(LspStoreEvent::DiagnosticsUpdated {
4071                    language_server_id: LanguageServerId(message.language_server_id as usize),
4072                    path: project_path,
4073                });
4074            }
4075            Ok(())
4076        })?
4077    }
4078
4079    async fn handle_start_language_server(
4080        this: Model<Self>,
4081        envelope: TypedEnvelope<proto::StartLanguageServer>,
4082        mut cx: AsyncAppContext,
4083    ) -> Result<()> {
4084        let server = envelope
4085            .payload
4086            .server
4087            .ok_or_else(|| anyhow!("invalid server"))?;
4088
4089        this.update(&mut cx, |this, cx| {
4090            let server_id = LanguageServerId(server.id as usize);
4091            this.language_server_statuses.insert(
4092                server_id,
4093                LanguageServerStatus {
4094                    name: server.name.clone(),
4095                    pending_work: Default::default(),
4096                    has_pending_diagnostic_updates: false,
4097                    progress_tokens: Default::default(),
4098                },
4099            );
4100            cx.emit(LspStoreEvent::LanguageServerAdded(
4101                server_id,
4102                LanguageServerName(server.name.into()),
4103                server.worktree_id.map(WorktreeId::from_proto),
4104            ));
4105            cx.notify();
4106        })?;
4107        Ok(())
4108    }
4109
4110    async fn handle_update_language_server(
4111        this: Model<Self>,
4112        envelope: TypedEnvelope<proto::UpdateLanguageServer>,
4113        mut cx: AsyncAppContext,
4114    ) -> Result<()> {
4115        this.update(&mut cx, |this, cx| {
4116            let language_server_id = LanguageServerId(envelope.payload.language_server_id as usize);
4117
4118            match envelope
4119                .payload
4120                .variant
4121                .ok_or_else(|| anyhow!("invalid variant"))?
4122            {
4123                proto::update_language_server::Variant::WorkStart(payload) => {
4124                    this.on_lsp_work_start(
4125                        language_server_id,
4126                        payload.token,
4127                        LanguageServerProgress {
4128                            title: payload.title,
4129                            is_disk_based_diagnostics_progress: false,
4130                            is_cancellable: payload.is_cancellable.unwrap_or(false),
4131                            message: payload.message,
4132                            percentage: payload.percentage.map(|p| p as usize),
4133                            last_update_at: cx.background_executor().now(),
4134                        },
4135                        cx,
4136                    );
4137                }
4138
4139                proto::update_language_server::Variant::WorkProgress(payload) => {
4140                    this.on_lsp_work_progress(
4141                        language_server_id,
4142                        payload.token,
4143                        LanguageServerProgress {
4144                            title: None,
4145                            is_disk_based_diagnostics_progress: false,
4146                            is_cancellable: payload.is_cancellable.unwrap_or(false),
4147                            message: payload.message,
4148                            percentage: payload.percentage.map(|p| p as usize),
4149                            last_update_at: cx.background_executor().now(),
4150                        },
4151                        cx,
4152                    );
4153                }
4154
4155                proto::update_language_server::Variant::WorkEnd(payload) => {
4156                    this.on_lsp_work_end(language_server_id, payload.token, cx);
4157                }
4158
4159                proto::update_language_server::Variant::DiskBasedDiagnosticsUpdating(_) => {
4160                    this.disk_based_diagnostics_started(language_server_id, cx);
4161                }
4162
4163                proto::update_language_server::Variant::DiskBasedDiagnosticsUpdated(_) => {
4164                    this.disk_based_diagnostics_finished(language_server_id, cx)
4165                }
4166            }
4167
4168            Ok(())
4169        })?
4170    }
4171
4172    async fn handle_language_server_log(
4173        this: Model<Self>,
4174        envelope: TypedEnvelope<proto::LanguageServerLog>,
4175        mut cx: AsyncAppContext,
4176    ) -> Result<()> {
4177        let language_server_id = LanguageServerId(envelope.payload.language_server_id as usize);
4178        let log_type = envelope
4179            .payload
4180            .log_type
4181            .map(LanguageServerLogType::from_proto)
4182            .context("invalid language server log type")?;
4183
4184        let message = envelope.payload.message;
4185
4186        this.update(&mut cx, |_, cx| {
4187            cx.emit(LspStoreEvent::LanguageServerLog(
4188                language_server_id,
4189                log_type,
4190                message,
4191            ));
4192        })
4193    }
4194
4195    pub fn disk_based_diagnostics_started(
4196        &mut self,
4197        language_server_id: LanguageServerId,
4198        cx: &mut ModelContext<Self>,
4199    ) {
4200        if let Some(language_server_status) =
4201            self.language_server_statuses.get_mut(&language_server_id)
4202        {
4203            language_server_status.has_pending_diagnostic_updates = true;
4204        }
4205
4206        cx.emit(LspStoreEvent::DiskBasedDiagnosticsStarted { language_server_id });
4207        cx.emit(LspStoreEvent::LanguageServerUpdate {
4208            language_server_id,
4209            message: proto::update_language_server::Variant::DiskBasedDiagnosticsUpdating(
4210                Default::default(),
4211            ),
4212        })
4213    }
4214
4215    pub fn disk_based_diagnostics_finished(
4216        &mut self,
4217        language_server_id: LanguageServerId,
4218        cx: &mut ModelContext<Self>,
4219    ) {
4220        if let Some(language_server_status) =
4221            self.language_server_statuses.get_mut(&language_server_id)
4222        {
4223            language_server_status.has_pending_diagnostic_updates = false;
4224        }
4225
4226        cx.emit(LspStoreEvent::DiskBasedDiagnosticsFinished { language_server_id });
4227        cx.emit(LspStoreEvent::LanguageServerUpdate {
4228            language_server_id,
4229            message: proto::update_language_server::Variant::DiskBasedDiagnosticsUpdated(
4230                Default::default(),
4231            ),
4232        })
4233    }
4234
4235    // After saving a buffer using a language server that doesn't provide a disk-based progress token,
4236    // kick off a timer that will reset every time the buffer is saved. If the timer eventually fires,
4237    // simulate disk-based diagnostics being finished so that other pieces of UI (e.g., project
4238    // diagnostics view, diagnostic status bar) can update. We don't emit an event right away because
4239    // the language server might take some time to publish diagnostics.
4240    fn simulate_disk_based_diagnostics_events_if_needed(
4241        &mut self,
4242        language_server_id: LanguageServerId,
4243        cx: &mut ModelContext<Self>,
4244    ) {
4245        const DISK_BASED_DIAGNOSTICS_DEBOUNCE: Duration = Duration::from_secs(1);
4246
4247        let Some(LanguageServerState::Running {
4248            simulate_disk_based_diagnostics_completion,
4249            adapter,
4250            ..
4251        }) = self
4252            .as_local_mut()
4253            .and_then(|local_store| local_store.language_servers.get_mut(&language_server_id))
4254        else {
4255            return;
4256        };
4257
4258        if adapter.disk_based_diagnostics_progress_token.is_some() {
4259            return;
4260        }
4261
4262        let prev_task = simulate_disk_based_diagnostics_completion.replace(cx.spawn(
4263            move |this, mut cx| async move {
4264                cx.background_executor()
4265                    .timer(DISK_BASED_DIAGNOSTICS_DEBOUNCE)
4266                    .await;
4267
4268                this.update(&mut cx, |this, cx| {
4269                    this.disk_based_diagnostics_finished(language_server_id, cx);
4270
4271                    if let Some(LanguageServerState::Running {
4272                        simulate_disk_based_diagnostics_completion,
4273                        ..
4274                    }) = this.as_local_mut().and_then(|local_store| {
4275                        local_store.language_servers.get_mut(&language_server_id)
4276                    }) {
4277                        *simulate_disk_based_diagnostics_completion = None;
4278                    }
4279                })
4280                .ok();
4281            },
4282        ));
4283
4284        if prev_task.is_none() {
4285            self.disk_based_diagnostics_started(language_server_id, cx);
4286        }
4287    }
4288
4289    pub fn language_server_statuses(
4290        &self,
4291    ) -> impl DoubleEndedIterator<Item = (LanguageServerId, &LanguageServerStatus)> {
4292        self.language_server_statuses
4293            .iter()
4294            .map(|(key, value)| (*key, value))
4295    }
4296
4297    fn lsp_notify_abs_paths_changed(
4298        &mut self,
4299        server_id: LanguageServerId,
4300        changes: Vec<PathEvent>,
4301    ) {
4302        maybe!({
4303            let server = self.language_server_for_id(server_id)?;
4304            let changes = changes
4305                .into_iter()
4306                .filter_map(|event| {
4307                    let typ = match event.kind? {
4308                        PathEventKind::Created => lsp::FileChangeType::CREATED,
4309                        PathEventKind::Removed => lsp::FileChangeType::DELETED,
4310                        PathEventKind::Changed => lsp::FileChangeType::CHANGED,
4311                    };
4312                    Some(lsp::FileEvent {
4313                        uri: lsp::Url::from_file_path(&event.path).ok()?,
4314                        typ,
4315                    })
4316                })
4317                .collect::<Vec<_>>();
4318            if !changes.is_empty() {
4319                server
4320                    .notify::<lsp::notification::DidChangeWatchedFiles>(
4321                        lsp::DidChangeWatchedFilesParams { changes },
4322                    )
4323                    .log_err();
4324            }
4325            Some(())
4326        });
4327    }
4328
4329    fn rebuild_watched_paths(
4330        &mut self,
4331        language_server_id: LanguageServerId,
4332        cx: &mut ModelContext<Self>,
4333    ) {
4334        let worktrees = self
4335            .worktree_store
4336            .read(cx)
4337            .worktrees()
4338            .filter_map(|worktree| {
4339                self.language_servers_for_worktree(worktree.read(cx).id())
4340                    .find(|server| server.server_id() == language_server_id)
4341                    .map(|_| worktree)
4342            })
4343            .collect::<Vec<_>>();
4344
4345        let local_lsp_store = self.as_local_mut().unwrap();
4346
4347        let Some(watchers) = local_lsp_store
4348            .language_server_watcher_registrations
4349            .get(&language_server_id)
4350        else {
4351            return;
4352        };
4353
4354        let mut worktree_globs = HashMap::default();
4355        let mut abs_globs = HashMap::default();
4356        log::trace!(
4357            "Processing new watcher paths for language server with id {}",
4358            language_server_id
4359        );
4360
4361        enum PathToWatch {
4362            Worktree {
4363                literal_prefix: Arc<Path>,
4364                pattern: String,
4365            },
4366            Absolute {
4367                path: Arc<Path>,
4368                pattern: String,
4369            },
4370        }
4371        for watcher in watchers.values().flatten() {
4372            let mut found_host = false;
4373            for worktree in &worktrees {
4374                let glob_is_inside_worktree = worktree.update(cx, |tree, _| {
4375                    if let Some(worktree_root_path) = tree.abs_path().to_str() {
4376                        let path_to_watch = match &watcher.glob_pattern {
4377                            lsp::GlobPattern::String(s) => {
4378                                match s.strip_prefix(worktree_root_path) {
4379                                    Some(relative) => {
4380                                        let pattern = relative
4381                                            .strip_prefix(std::path::MAIN_SEPARATOR)
4382                                            .unwrap_or(relative)
4383                                            .to_owned();
4384                                        let literal_prefix = glob_literal_prefix(&pattern);
4385
4386                                        let literal_prefix = Arc::from(PathBuf::from(
4387                                            literal_prefix
4388                                                .strip_prefix(std::path::MAIN_SEPARATOR)
4389                                                .unwrap_or(literal_prefix),
4390                                        ));
4391                                        PathToWatch::Worktree {
4392                                            literal_prefix,
4393                                            pattern,
4394                                        }
4395                                    }
4396                                    None => {
4397                                        let path = glob_literal_prefix(s);
4398                                        let glob = &s[path.len()..];
4399                                        let pattern = glob
4400                                            .strip_prefix(std::path::MAIN_SEPARATOR)
4401                                            .unwrap_or(glob)
4402                                            .to_owned();
4403                                        let path = if Path::new(path).components().next().is_none()
4404                                        {
4405                                            Arc::from(Path::new(worktree_root_path))
4406                                        } else {
4407                                            PathBuf::from(path).into()
4408                                        };
4409
4410                                        PathToWatch::Absolute { path, pattern }
4411                                    }
4412                                }
4413                            }
4414                            lsp::GlobPattern::Relative(rp) => {
4415                                let Ok(mut base_uri) = match &rp.base_uri {
4416                                    lsp::OneOf::Left(workspace_folder) => &workspace_folder.uri,
4417                                    lsp::OneOf::Right(base_uri) => base_uri,
4418                                }
4419                                .to_file_path() else {
4420                                    return false;
4421                                };
4422
4423                                match base_uri.strip_prefix(worktree_root_path) {
4424                                    Ok(relative) => {
4425                                        let mut literal_prefix = relative.to_owned();
4426                                        literal_prefix.push(glob_literal_prefix(&rp.pattern));
4427
4428                                        PathToWatch::Worktree {
4429                                            literal_prefix: literal_prefix.into(),
4430                                            pattern: rp.pattern.clone(),
4431                                        }
4432                                    }
4433                                    Err(_) => {
4434                                        let path = glob_literal_prefix(&rp.pattern);
4435                                        let glob = &rp.pattern[path.len()..];
4436                                        let pattern = glob
4437                                            .strip_prefix(std::path::MAIN_SEPARATOR)
4438                                            .unwrap_or(glob)
4439                                            .to_owned();
4440                                        base_uri.push(path);
4441
4442                                        let path = if base_uri.components().next().is_none() {
4443                                            Arc::from(Path::new("/"))
4444                                        } else {
4445                                            base_uri.into()
4446                                        };
4447                                        PathToWatch::Absolute { path, pattern }
4448                                    }
4449                                }
4450                            }
4451                        };
4452                        match path_to_watch {
4453                            PathToWatch::Worktree {
4454                                literal_prefix,
4455                                pattern,
4456                            } => {
4457                                if let Some((tree, glob)) =
4458                                    tree.as_local_mut().zip(Glob::new(&pattern).log_err())
4459                                {
4460                                    tree.add_path_prefix_to_scan(literal_prefix);
4461                                    worktree_globs
4462                                        .entry(tree.id())
4463                                        .or_insert_with(GlobSetBuilder::new)
4464                                        .add(glob);
4465                                } else {
4466                                    return false;
4467                                }
4468                            }
4469                            PathToWatch::Absolute { path, pattern } => {
4470                                if let Some(glob) = Glob::new(&pattern).log_err() {
4471                                    abs_globs
4472                                        .entry(path)
4473                                        .or_insert_with(GlobSetBuilder::new)
4474                                        .add(glob);
4475                                }
4476                            }
4477                        }
4478                        return true;
4479                    }
4480                    false
4481                });
4482                if glob_is_inside_worktree {
4483                    log::trace!(
4484                        "Watcher pattern `{}` has been attached to the worktree at `{}`",
4485                        serde_json::to_string(&watcher.glob_pattern).unwrap(),
4486                        worktree.read(cx).abs_path().display()
4487                    );
4488                    found_host = true;
4489                }
4490            }
4491            if !found_host {
4492                log::error!(
4493                    "Watcher pattern `{}` has not been attached to any worktree or absolute path",
4494                    serde_json::to_string(&watcher.glob_pattern).unwrap()
4495                )
4496            }
4497        }
4498
4499        let mut watch_builder = LanguageServerWatchedPathsBuilder::default();
4500        for (worktree_id, builder) in worktree_globs {
4501            if let Ok(globset) = builder.build() {
4502                watch_builder.watch_worktree(worktree_id, globset);
4503            }
4504        }
4505        for (abs_path, builder) in abs_globs {
4506            if let Ok(globset) = builder.build() {
4507                watch_builder.watch_abs_path(abs_path, globset);
4508            }
4509        }
4510        let watcher = watch_builder.build(local_lsp_store.fs.clone(), language_server_id, cx);
4511        local_lsp_store
4512            .language_server_watched_paths
4513            .insert(language_server_id, watcher);
4514
4515        cx.notify();
4516    }
4517
4518    pub fn language_server_for_id(&self, id: LanguageServerId) -> Option<Arc<LanguageServer>> {
4519        if let Some(local_lsp_store) = self.as_local() {
4520            if let Some(LanguageServerState::Running { server, .. }) =
4521                local_lsp_store.language_servers.get(&id)
4522            {
4523                Some(server.clone())
4524            } else if let Some((_, server)) =
4525                local_lsp_store.supplementary_language_servers.get(&id)
4526            {
4527                Some(Arc::clone(server))
4528            } else {
4529                None
4530            }
4531        } else {
4532            None
4533        }
4534    }
4535
4536    async fn on_lsp_workspace_edit(
4537        this: WeakModel<Self>,
4538        params: lsp::ApplyWorkspaceEditParams,
4539        server_id: LanguageServerId,
4540        adapter: Arc<CachedLspAdapter>,
4541        mut cx: AsyncAppContext,
4542    ) -> Result<lsp::ApplyWorkspaceEditResponse> {
4543        let this = this
4544            .upgrade()
4545            .ok_or_else(|| anyhow!("project project closed"))?;
4546        let language_server = this
4547            .update(&mut cx, |this, _| this.language_server_for_id(server_id))?
4548            .ok_or_else(|| anyhow!("language server not found"))?;
4549        let transaction = Self::deserialize_workspace_edit(
4550            this.clone(),
4551            params.edit,
4552            true,
4553            adapter.clone(),
4554            language_server.clone(),
4555            &mut cx,
4556        )
4557        .await
4558        .log_err();
4559        this.update(&mut cx, |this, _| {
4560            if let Some(transaction) = transaction {
4561                this.as_local_mut()
4562                    .unwrap()
4563                    .last_workspace_edits_by_language_server
4564                    .insert(server_id, transaction);
4565            }
4566        })?;
4567        Ok(lsp::ApplyWorkspaceEditResponse {
4568            applied: true,
4569            failed_change: None,
4570            failure_reason: None,
4571        })
4572    }
4573
4574    fn on_lsp_progress(
4575        &mut self,
4576        progress: lsp::ProgressParams,
4577        language_server_id: LanguageServerId,
4578        disk_based_diagnostics_progress_token: Option<String>,
4579        cx: &mut ModelContext<Self>,
4580    ) {
4581        let token = match progress.token {
4582            lsp::NumberOrString::String(token) => token,
4583            lsp::NumberOrString::Number(token) => {
4584                log::info!("skipping numeric progress token {}", token);
4585                return;
4586            }
4587        };
4588
4589        let lsp::ProgressParamsValue::WorkDone(progress) = progress.value;
4590        let language_server_status =
4591            if let Some(status) = self.language_server_statuses.get_mut(&language_server_id) {
4592                status
4593            } else {
4594                return;
4595            };
4596
4597        if !language_server_status.progress_tokens.contains(&token) {
4598            return;
4599        }
4600
4601        let is_disk_based_diagnostics_progress = disk_based_diagnostics_progress_token
4602            .as_ref()
4603            .map_or(false, |disk_based_token| {
4604                token.starts_with(disk_based_token)
4605            });
4606
4607        match progress {
4608            lsp::WorkDoneProgress::Begin(report) => {
4609                if is_disk_based_diagnostics_progress {
4610                    self.disk_based_diagnostics_started(language_server_id, cx);
4611                }
4612                self.on_lsp_work_start(
4613                    language_server_id,
4614                    token.clone(),
4615                    LanguageServerProgress {
4616                        title: Some(report.title),
4617                        is_disk_based_diagnostics_progress,
4618                        is_cancellable: report.cancellable.unwrap_or(false),
4619                        message: report.message.clone(),
4620                        percentage: report.percentage.map(|p| p as usize),
4621                        last_update_at: cx.background_executor().now(),
4622                    },
4623                    cx,
4624                );
4625            }
4626            lsp::WorkDoneProgress::Report(report) => {
4627                if self.on_lsp_work_progress(
4628                    language_server_id,
4629                    token.clone(),
4630                    LanguageServerProgress {
4631                        title: None,
4632                        is_disk_based_diagnostics_progress,
4633                        is_cancellable: report.cancellable.unwrap_or(false),
4634                        message: report.message.clone(),
4635                        percentage: report.percentage.map(|p| p as usize),
4636                        last_update_at: cx.background_executor().now(),
4637                    },
4638                    cx,
4639                ) {
4640                    cx.emit(LspStoreEvent::LanguageServerUpdate {
4641                        language_server_id,
4642                        message: proto::update_language_server::Variant::WorkProgress(
4643                            proto::LspWorkProgress {
4644                                token,
4645                                message: report.message,
4646                                percentage: report.percentage,
4647                                is_cancellable: report.cancellable,
4648                            },
4649                        ),
4650                    })
4651                }
4652            }
4653            lsp::WorkDoneProgress::End(_) => {
4654                language_server_status.progress_tokens.remove(&token);
4655                self.on_lsp_work_end(language_server_id, token.clone(), cx);
4656                if is_disk_based_diagnostics_progress {
4657                    self.disk_based_diagnostics_finished(language_server_id, cx);
4658                }
4659            }
4660        }
4661    }
4662
4663    fn on_lsp_work_start(
4664        &mut self,
4665        language_server_id: LanguageServerId,
4666        token: String,
4667        progress: LanguageServerProgress,
4668        cx: &mut ModelContext<Self>,
4669    ) {
4670        if let Some(status) = self.language_server_statuses.get_mut(&language_server_id) {
4671            status.pending_work.insert(token.clone(), progress.clone());
4672            cx.notify();
4673        }
4674        cx.emit(LspStoreEvent::LanguageServerUpdate {
4675            language_server_id,
4676            message: proto::update_language_server::Variant::WorkStart(proto::LspWorkStart {
4677                token,
4678                title: progress.title,
4679                message: progress.message,
4680                percentage: progress.percentage.map(|p| p as u32),
4681                is_cancellable: Some(progress.is_cancellable),
4682            }),
4683        })
4684    }
4685
4686    fn on_lsp_work_progress(
4687        &mut self,
4688        language_server_id: LanguageServerId,
4689        token: String,
4690        progress: LanguageServerProgress,
4691        cx: &mut ModelContext<Self>,
4692    ) -> bool {
4693        if let Some(status) = self.language_server_statuses.get_mut(&language_server_id) {
4694            match status.pending_work.entry(token) {
4695                btree_map::Entry::Vacant(entry) => {
4696                    entry.insert(progress);
4697                    cx.notify();
4698                    return true;
4699                }
4700                btree_map::Entry::Occupied(mut entry) => {
4701                    let entry = entry.get_mut();
4702                    if (progress.last_update_at - entry.last_update_at)
4703                        >= SERVER_PROGRESS_THROTTLE_TIMEOUT
4704                    {
4705                        entry.last_update_at = progress.last_update_at;
4706                        if progress.message.is_some() {
4707                            entry.message = progress.message;
4708                        }
4709                        if progress.percentage.is_some() {
4710                            entry.percentage = progress.percentage;
4711                        }
4712                        if progress.is_cancellable != entry.is_cancellable {
4713                            entry.is_cancellable = progress.is_cancellable;
4714                        }
4715                        cx.notify();
4716                        return true;
4717                    }
4718                }
4719            }
4720        }
4721
4722        false
4723    }
4724
4725    fn on_lsp_work_end(
4726        &mut self,
4727        language_server_id: LanguageServerId,
4728        token: String,
4729        cx: &mut ModelContext<Self>,
4730    ) {
4731        if let Some(status) = self.language_server_statuses.get_mut(&language_server_id) {
4732            if let Some(work) = status.pending_work.remove(&token) {
4733                if !work.is_disk_based_diagnostics_progress {
4734                    cx.emit(LspStoreEvent::RefreshInlayHints);
4735                }
4736            }
4737            cx.notify();
4738        }
4739
4740        cx.emit(LspStoreEvent::LanguageServerUpdate {
4741            language_server_id,
4742            message: proto::update_language_server::Variant::WorkEnd(proto::LspWorkEnd { token }),
4743        })
4744    }
4745
4746    fn on_lsp_did_change_watched_files(
4747        &mut self,
4748        language_server_id: LanguageServerId,
4749        registration_id: &str,
4750        params: DidChangeWatchedFilesRegistrationOptions,
4751        cx: &mut ModelContext<Self>,
4752    ) {
4753        if let Some(local) = self.as_local_mut() {
4754            let registrations = local
4755                .language_server_watcher_registrations
4756                .entry(language_server_id)
4757                .or_default();
4758
4759            registrations.insert(registration_id.to_string(), params.watchers);
4760
4761            self.rebuild_watched_paths(language_server_id, cx);
4762        }
4763    }
4764
4765    fn on_lsp_unregister_did_change_watched_files(
4766        &mut self,
4767        language_server_id: LanguageServerId,
4768        registration_id: &str,
4769        cx: &mut ModelContext<Self>,
4770    ) {
4771        if let Some(local) = self.as_local_mut() {
4772            let registrations = local
4773                .language_server_watcher_registrations
4774                .entry(language_server_id)
4775                .or_default();
4776
4777            if registrations.remove(registration_id).is_some() {
4778                log::info!(
4779                    "language server {}: unregistered workspace/DidChangeWatchedFiles capability with id {}",
4780                    language_server_id,
4781                    registration_id
4782                );
4783            } else {
4784                log::warn!(
4785                    "language server {}: failed to unregister workspace/DidChangeWatchedFiles capability with id {}. not registered.",
4786                    language_server_id,
4787                    registration_id
4788                );
4789            }
4790
4791            self.rebuild_watched_paths(language_server_id, cx);
4792        }
4793    }
4794
4795    #[allow(clippy::type_complexity)]
4796    pub(crate) fn edits_from_lsp(
4797        &mut self,
4798        buffer: &Model<Buffer>,
4799        lsp_edits: impl 'static + Send + IntoIterator<Item = lsp::TextEdit>,
4800        server_id: LanguageServerId,
4801        version: Option<i32>,
4802        cx: &mut ModelContext<Self>,
4803    ) -> Task<Result<Vec<(Range<Anchor>, String)>>> {
4804        let snapshot = self.buffer_snapshot_for_lsp_version(buffer, server_id, version, cx);
4805        cx.background_executor().spawn(async move {
4806            let snapshot = snapshot?;
4807            let mut lsp_edits = lsp_edits
4808                .into_iter()
4809                .map(|edit| (range_from_lsp(edit.range), edit.new_text))
4810                .collect::<Vec<_>>();
4811            lsp_edits.sort_by_key(|(range, _)| range.start);
4812
4813            let mut lsp_edits = lsp_edits.into_iter().peekable();
4814            let mut edits = Vec::new();
4815            while let Some((range, mut new_text)) = lsp_edits.next() {
4816                // Clip invalid ranges provided by the language server.
4817                let mut range = snapshot.clip_point_utf16(range.start, Bias::Left)
4818                    ..snapshot.clip_point_utf16(range.end, Bias::Left);
4819
4820                // Combine any LSP edits that are adjacent.
4821                //
4822                // Also, combine LSP edits that are separated from each other by only
4823                // a newline. This is important because for some code actions,
4824                // Rust-analyzer rewrites the entire buffer via a series of edits that
4825                // are separated by unchanged newline characters.
4826                //
4827                // In order for the diffing logic below to work properly, any edits that
4828                // cancel each other out must be combined into one.
4829                while let Some((next_range, next_text)) = lsp_edits.peek() {
4830                    if next_range.start.0 > range.end {
4831                        if next_range.start.0.row > range.end.row + 1
4832                            || next_range.start.0.column > 0
4833                            || snapshot.clip_point_utf16(
4834                                Unclipped(PointUtf16::new(range.end.row, u32::MAX)),
4835                                Bias::Left,
4836                            ) > range.end
4837                        {
4838                            break;
4839                        }
4840                        new_text.push('\n');
4841                    }
4842                    range.end = snapshot.clip_point_utf16(next_range.end, Bias::Left);
4843                    new_text.push_str(next_text);
4844                    lsp_edits.next();
4845                }
4846
4847                // For multiline edits, perform a diff of the old and new text so that
4848                // we can identify the changes more precisely, preserving the locations
4849                // of any anchors positioned in the unchanged regions.
4850                if range.end.row > range.start.row {
4851                    let mut offset = range.start.to_offset(&snapshot);
4852                    let old_text = snapshot.text_for_range(range).collect::<String>();
4853
4854                    let diff = TextDiff::from_lines(old_text.as_str(), &new_text);
4855                    let mut moved_since_edit = true;
4856                    for change in diff.iter_all_changes() {
4857                        let tag = change.tag();
4858                        let value = change.value();
4859                        match tag {
4860                            ChangeTag::Equal => {
4861                                offset += value.len();
4862                                moved_since_edit = true;
4863                            }
4864                            ChangeTag::Delete => {
4865                                let start = snapshot.anchor_after(offset);
4866                                let end = snapshot.anchor_before(offset + value.len());
4867                                if moved_since_edit {
4868                                    edits.push((start..end, String::new()));
4869                                } else {
4870                                    edits.last_mut().unwrap().0.end = end;
4871                                }
4872                                offset += value.len();
4873                                moved_since_edit = false;
4874                            }
4875                            ChangeTag::Insert => {
4876                                if moved_since_edit {
4877                                    let anchor = snapshot.anchor_after(offset);
4878                                    edits.push((anchor..anchor, value.to_string()));
4879                                } else {
4880                                    edits.last_mut().unwrap().1.push_str(value);
4881                                }
4882                                moved_since_edit = false;
4883                            }
4884                        }
4885                    }
4886                } else if range.end == range.start {
4887                    let anchor = snapshot.anchor_after(range.start);
4888                    edits.push((anchor..anchor, new_text));
4889                } else {
4890                    let edit_start = snapshot.anchor_after(range.start);
4891                    let edit_end = snapshot.anchor_before(range.end);
4892                    edits.push((edit_start..edit_end, new_text));
4893                }
4894            }
4895
4896            Ok(edits)
4897        })
4898    }
4899
4900    pub async fn handle_resolve_completion_documentation(
4901        this: Model<Self>,
4902        envelope: TypedEnvelope<proto::ResolveCompletionDocumentation>,
4903        mut cx: AsyncAppContext,
4904    ) -> Result<proto::ResolveCompletionDocumentationResponse> {
4905        let lsp_completion = serde_json::from_slice(&envelope.payload.lsp_completion)?;
4906
4907        let completion = this
4908            .read_with(&cx, |this, cx| {
4909                let id = LanguageServerId(envelope.payload.language_server_id as usize);
4910                let Some(server) = this.language_server_for_id(id) else {
4911                    return Err(anyhow!("No language server {id}"));
4912                };
4913
4914                Ok(cx.background_executor().spawn(async move {
4915                    let can_resolve = server
4916                        .capabilities()
4917                        .completion_provider
4918                        .as_ref()
4919                        .and_then(|options| options.resolve_provider)
4920                        .unwrap_or(false);
4921                    if can_resolve {
4922                        server
4923                            .request::<lsp::request::ResolveCompletionItem>(lsp_completion)
4924                            .await
4925                    } else {
4926                        anyhow::Ok(lsp_completion)
4927                    }
4928                }))
4929            })??
4930            .await?;
4931
4932        let mut documentation_is_markdown = false;
4933        let lsp_completion = serde_json::to_string(&completion)?.into_bytes();
4934        let documentation = match completion.documentation {
4935            Some(lsp::Documentation::String(text)) => text,
4936
4937            Some(lsp::Documentation::MarkupContent(lsp::MarkupContent { kind, value })) => {
4938                documentation_is_markdown = kind == lsp::MarkupKind::Markdown;
4939                value
4940            }
4941
4942            _ => String::new(),
4943        };
4944
4945        // If we have a new buffer_id, that means we're talking to a new client
4946        // and want to check for new text_edits in the completion too.
4947        let mut old_start = None;
4948        let mut old_end = None;
4949        let mut new_text = String::default();
4950        if let Ok(buffer_id) = BufferId::new(envelope.payload.buffer_id) {
4951            let buffer_snapshot = this.update(&mut cx, |this, cx| {
4952                let buffer = this.buffer_store.read(cx).get_existing(buffer_id)?;
4953                anyhow::Ok(buffer.read(cx).snapshot())
4954            })??;
4955
4956            if let Some(text_edit) = completion.text_edit.as_ref() {
4957                let edit = parse_completion_text_edit(text_edit, &buffer_snapshot);
4958
4959                if let Some((old_range, mut text_edit_new_text)) = edit {
4960                    LineEnding::normalize(&mut text_edit_new_text);
4961
4962                    new_text = text_edit_new_text;
4963                    old_start = Some(serialize_anchor(&old_range.start));
4964                    old_end = Some(serialize_anchor(&old_range.end));
4965                }
4966            }
4967        }
4968
4969        Ok(proto::ResolveCompletionDocumentationResponse {
4970            documentation,
4971            documentation_is_markdown,
4972            old_start,
4973            old_end,
4974            new_text,
4975            lsp_completion,
4976        })
4977    }
4978
4979    async fn handle_on_type_formatting(
4980        this: Model<Self>,
4981        envelope: TypedEnvelope<proto::OnTypeFormatting>,
4982        mut cx: AsyncAppContext,
4983    ) -> Result<proto::OnTypeFormattingResponse> {
4984        let on_type_formatting = this.update(&mut cx, |this, cx| {
4985            let buffer_id = BufferId::new(envelope.payload.buffer_id)?;
4986            let buffer = this.buffer_store.read(cx).get_existing(buffer_id)?;
4987            let position = envelope
4988                .payload
4989                .position
4990                .and_then(deserialize_anchor)
4991                .ok_or_else(|| anyhow!("invalid position"))?;
4992            Ok::<_, anyhow::Error>(this.apply_on_type_formatting(
4993                buffer,
4994                position,
4995                envelope.payload.trigger.clone(),
4996                cx,
4997            ))
4998        })??;
4999
5000        let transaction = on_type_formatting
5001            .await?
5002            .as_ref()
5003            .map(language::proto::serialize_transaction);
5004        Ok(proto::OnTypeFormattingResponse { transaction })
5005    }
5006
5007    async fn handle_refresh_inlay_hints(
5008        this: Model<Self>,
5009        _: TypedEnvelope<proto::RefreshInlayHints>,
5010        mut cx: AsyncAppContext,
5011    ) -> Result<proto::Ack> {
5012        this.update(&mut cx, |_, cx| {
5013            cx.emit(LspStoreEvent::RefreshInlayHints);
5014        })?;
5015        Ok(proto::Ack {})
5016    }
5017
5018    async fn handle_inlay_hints(
5019        this: Model<Self>,
5020        envelope: TypedEnvelope<proto::InlayHints>,
5021        mut cx: AsyncAppContext,
5022    ) -> Result<proto::InlayHintsResponse> {
5023        let sender_id = envelope.original_sender_id().unwrap_or_default();
5024        let buffer_id = BufferId::new(envelope.payload.buffer_id)?;
5025        let buffer = this.update(&mut cx, |this, cx| {
5026            this.buffer_store.read(cx).get_existing(buffer_id)
5027        })??;
5028        buffer
5029            .update(&mut cx, |buffer, _| {
5030                buffer.wait_for_version(deserialize_version(&envelope.payload.version))
5031            })?
5032            .await
5033            .with_context(|| format!("waiting for version for buffer {}", buffer.entity_id()))?;
5034
5035        let start = envelope
5036            .payload
5037            .start
5038            .and_then(deserialize_anchor)
5039            .context("missing range start")?;
5040        let end = envelope
5041            .payload
5042            .end
5043            .and_then(deserialize_anchor)
5044            .context("missing range end")?;
5045        let buffer_hints = this
5046            .update(&mut cx, |lsp_store, cx| {
5047                lsp_store.inlay_hints(buffer.clone(), start..end, cx)
5048            })?
5049            .await
5050            .context("inlay hints fetch")?;
5051
5052        this.update(&mut cx, |project, cx| {
5053            InlayHints::response_to_proto(
5054                buffer_hints,
5055                project,
5056                sender_id,
5057                &buffer.read(cx).version(),
5058                cx,
5059            )
5060        })
5061    }
5062
5063    async fn handle_resolve_inlay_hint(
5064        this: Model<Self>,
5065        envelope: TypedEnvelope<proto::ResolveInlayHint>,
5066        mut cx: AsyncAppContext,
5067    ) -> Result<proto::ResolveInlayHintResponse> {
5068        let proto_hint = envelope
5069            .payload
5070            .hint
5071            .expect("incorrect protobuf resolve inlay hint message: missing the inlay hint");
5072        let hint = InlayHints::proto_to_project_hint(proto_hint)
5073            .context("resolved proto inlay hint conversion")?;
5074        let buffer = this.update(&mut cx, |this, cx| {
5075            let buffer_id = BufferId::new(envelope.payload.buffer_id)?;
5076            this.buffer_store.read(cx).get_existing(buffer_id)
5077        })??;
5078        let response_hint = this
5079            .update(&mut cx, |this, cx| {
5080                this.resolve_inlay_hint(
5081                    hint,
5082                    buffer,
5083                    LanguageServerId(envelope.payload.language_server_id as usize),
5084                    cx,
5085                )
5086            })?
5087            .await
5088            .context("inlay hints fetch")?;
5089        Ok(proto::ResolveInlayHintResponse {
5090            hint: Some(InlayHints::project_to_proto_hint(response_hint)),
5091        })
5092    }
5093
5094    async fn handle_open_buffer_for_symbol(
5095        this: Model<Self>,
5096        envelope: TypedEnvelope<proto::OpenBufferForSymbol>,
5097        mut cx: AsyncAppContext,
5098    ) -> Result<proto::OpenBufferForSymbolResponse> {
5099        let peer_id = envelope.original_sender_id().unwrap_or_default();
5100        let symbol = envelope
5101            .payload
5102            .symbol
5103            .ok_or_else(|| anyhow!("invalid symbol"))?;
5104        let symbol = Self::deserialize_symbol(symbol)?;
5105        let symbol = this.update(&mut cx, |this, _| {
5106            let signature = this.symbol_signature(&symbol.path);
5107            if signature == symbol.signature {
5108                Ok(symbol)
5109            } else {
5110                Err(anyhow!("invalid symbol signature"))
5111            }
5112        })??;
5113        let buffer = this
5114            .update(&mut cx, |this, cx| {
5115                this.open_buffer_for_symbol(
5116                    &Symbol {
5117                        language_server_name: symbol.language_server_name,
5118                        source_worktree_id: symbol.source_worktree_id,
5119                        path: symbol.path,
5120                        name: symbol.name,
5121                        kind: symbol.kind,
5122                        range: symbol.range,
5123                        signature: symbol.signature,
5124                        label: CodeLabel {
5125                            text: Default::default(),
5126                            runs: Default::default(),
5127                            filter_range: Default::default(),
5128                        },
5129                    },
5130                    cx,
5131                )
5132            })?
5133            .await?;
5134
5135        this.update(&mut cx, |this, cx| {
5136            let is_private = buffer
5137                .read(cx)
5138                .file()
5139                .map(|f| f.is_private())
5140                .unwrap_or_default();
5141            if is_private {
5142                Err(anyhow!(rpc::ErrorCode::UnsharedItem))
5143            } else {
5144                this.buffer_store
5145                    .update(cx, |buffer_store, cx| {
5146                        buffer_store.create_buffer_for_peer(&buffer, peer_id, cx)
5147                    })
5148                    .detach_and_log_err(cx);
5149                let buffer_id = buffer.read(cx).remote_id().to_proto();
5150                Ok(proto::OpenBufferForSymbolResponse { buffer_id })
5151            }
5152        })?
5153    }
5154
5155    fn symbol_signature(&self, project_path: &ProjectPath) -> [u8; 32] {
5156        let mut hasher = Sha256::new();
5157        hasher.update(project_path.worktree_id.to_proto().to_be_bytes());
5158        hasher.update(project_path.path.to_string_lossy().as_bytes());
5159        hasher.update(self.nonce.to_be_bytes());
5160        hasher.finalize().as_slice().try_into().unwrap()
5161    }
5162
5163    pub async fn handle_get_project_symbols(
5164        this: Model<Self>,
5165        envelope: TypedEnvelope<proto::GetProjectSymbols>,
5166        mut cx: AsyncAppContext,
5167    ) -> Result<proto::GetProjectSymbolsResponse> {
5168        let symbols = this
5169            .update(&mut cx, |this, cx| {
5170                this.symbols(&envelope.payload.query, cx)
5171            })?
5172            .await?;
5173
5174        Ok(proto::GetProjectSymbolsResponse {
5175            symbols: symbols.iter().map(Self::serialize_symbol).collect(),
5176        })
5177    }
5178
5179    pub async fn handle_restart_language_servers(
5180        this: Model<Self>,
5181        envelope: TypedEnvelope<proto::RestartLanguageServers>,
5182        mut cx: AsyncAppContext,
5183    ) -> Result<proto::Ack> {
5184        this.update(&mut cx, |this, cx| {
5185            let buffers = this.buffer_ids_to_buffers(envelope.payload.buffer_ids.into_iter(), cx);
5186            this.restart_language_servers_for_buffers(buffers, cx);
5187        })?;
5188
5189        Ok(proto::Ack {})
5190    }
5191
5192    pub async fn handle_cancel_language_server_work(
5193        this: Model<Self>,
5194        envelope: TypedEnvelope<proto::CancelLanguageServerWork>,
5195        mut cx: AsyncAppContext,
5196    ) -> Result<proto::Ack> {
5197        this.update(&mut cx, |this, cx| {
5198            if let Some(work) = envelope.payload.work {
5199                match work {
5200                    proto::cancel_language_server_work::Work::Buffers(buffers) => {
5201                        let buffers =
5202                            this.buffer_ids_to_buffers(buffers.buffer_ids.into_iter(), cx);
5203                        this.cancel_language_server_work_for_buffers(buffers, cx);
5204                    }
5205                    proto::cancel_language_server_work::Work::LanguageServerWork(work) => {
5206                        let server_id = LanguageServerId::from_proto(work.language_server_id);
5207                        this.cancel_language_server_work(server_id, work.token, cx);
5208                    }
5209                }
5210            }
5211        })?;
5212
5213        Ok(proto::Ack {})
5214    }
5215
5216    fn buffer_ids_to_buffers(
5217        &mut self,
5218        buffer_ids: impl Iterator<Item = u64>,
5219        cx: &mut ModelContext<Self>,
5220    ) -> Vec<Model<Buffer>> {
5221        buffer_ids
5222            .into_iter()
5223            .flat_map(|buffer_id| {
5224                self.buffer_store
5225                    .read(cx)
5226                    .get(BufferId::new(buffer_id).log_err()?)
5227            })
5228            .collect::<Vec<_>>()
5229    }
5230
5231    async fn handle_apply_additional_edits_for_completion(
5232        this: Model<Self>,
5233        envelope: TypedEnvelope<proto::ApplyCompletionAdditionalEdits>,
5234        mut cx: AsyncAppContext,
5235    ) -> Result<proto::ApplyCompletionAdditionalEditsResponse> {
5236        let (buffer, completion) = this.update(&mut cx, |this, cx| {
5237            let buffer_id = BufferId::new(envelope.payload.buffer_id)?;
5238            let buffer = this.buffer_store.read(cx).get_existing(buffer_id)?;
5239            let completion = Self::deserialize_completion(
5240                envelope
5241                    .payload
5242                    .completion
5243                    .ok_or_else(|| anyhow!("invalid completion"))?,
5244            )?;
5245            anyhow::Ok((buffer, completion))
5246        })??;
5247
5248        let apply_additional_edits = this.update(&mut cx, |this, cx| {
5249            this.apply_additional_edits_for_completion(
5250                buffer,
5251                Completion {
5252                    old_range: completion.old_range,
5253                    new_text: completion.new_text,
5254                    lsp_completion: completion.lsp_completion,
5255                    server_id: completion.server_id,
5256                    documentation: None,
5257                    label: CodeLabel {
5258                        text: Default::default(),
5259                        runs: Default::default(),
5260                        filter_range: Default::default(),
5261                    },
5262                    confirm: None,
5263                },
5264                false,
5265                cx,
5266            )
5267        })?;
5268
5269        Ok(proto::ApplyCompletionAdditionalEditsResponse {
5270            transaction: apply_additional_edits
5271                .await?
5272                .as_ref()
5273                .map(language::proto::serialize_transaction),
5274        })
5275    }
5276
5277    pub fn last_formatting_failure(&self) -> Option<&str> {
5278        self.last_formatting_failure.as_deref()
5279    }
5280
5281    pub fn reset_last_formatting_failure(&mut self) {
5282        self.last_formatting_failure = None;
5283    }
5284
5285    pub fn environment_for_buffer(
5286        &self,
5287        buffer: &Model<Buffer>,
5288        cx: &mut ModelContext<Self>,
5289    ) -> Shared<Task<Option<HashMap<String, String>>>> {
5290        let worktree_id = buffer.read(cx).file().map(|file| file.worktree_id(cx));
5291        let worktree_abs_path = worktree_id.and_then(|worktree_id| {
5292            self.worktree_store
5293                .read(cx)
5294                .worktree_for_id(worktree_id, cx)
5295                .map(|entry| entry.read(cx).abs_path().clone())
5296        });
5297
5298        if let Some(environment) = &self.as_local().map(|local| local.environment.clone()) {
5299            environment.update(cx, |env, cx| {
5300                env.get_environment(worktree_id, worktree_abs_path, cx)
5301            })
5302        } else {
5303            Task::ready(None).shared()
5304        }
5305    }
5306
5307    pub fn format(
5308        &mut self,
5309        buffers: HashSet<Model<Buffer>>,
5310        push_to_history: bool,
5311        trigger: FormatTrigger,
5312        target: FormatTarget,
5313        cx: &mut ModelContext<Self>,
5314    ) -> Task<anyhow::Result<ProjectTransaction>> {
5315        if let Some(_) = self.as_local() {
5316            let buffers_with_paths = buffers
5317                .into_iter()
5318                .map(|buffer_handle| {
5319                    let buffer = buffer_handle.read(cx);
5320                    let buffer_abs_path = File::from_dyn(buffer.file())
5321                        .and_then(|file| file.as_local().map(|f| f.abs_path(cx)));
5322
5323                    (buffer_handle, buffer_abs_path)
5324                })
5325                .collect::<Vec<_>>();
5326
5327            cx.spawn(move |lsp_store, mut cx| async move {
5328                let mut formattable_buffers = Vec::with_capacity(buffers_with_paths.len());
5329
5330                for (handle, abs_path) in buffers_with_paths {
5331                    let env = lsp_store
5332                        .update(&mut cx, |lsp_store, cx| {
5333                            lsp_store.environment_for_buffer(&handle, cx)
5334                        })?
5335                        .await;
5336
5337                    formattable_buffers.push(FormattableBuffer {
5338                        handle,
5339                        abs_path,
5340                        env,
5341                    });
5342                }
5343
5344                let result = LocalLspStore::format_locally(
5345                    lsp_store.clone(),
5346                    formattable_buffers,
5347                    push_to_history,
5348                    trigger,
5349                    target,
5350                    cx.clone(),
5351                )
5352                .await;
5353                lsp_store.update(&mut cx, |lsp_store, _| {
5354                    lsp_store.update_last_formatting_failure(&result);
5355                })?;
5356
5357                result
5358            })
5359        } else if let Some((client, project_id)) = self.upstream_client() {
5360            let buffer_store = self.buffer_store();
5361            cx.spawn(move |lsp_store, mut cx| async move {
5362                let result = client
5363                    .request(proto::FormatBuffers {
5364                        project_id,
5365                        trigger: trigger as i32,
5366                        buffer_ids: buffers
5367                            .iter()
5368                            .map(|buffer| {
5369                                buffer.update(&mut cx, |buffer, _| buffer.remote_id().into())
5370                            })
5371                            .collect::<Result<_>>()?,
5372                    })
5373                    .await
5374                    .and_then(|result| result.transaction.context("missing transaction"));
5375
5376                lsp_store.update(&mut cx, |lsp_store, _| {
5377                    lsp_store.update_last_formatting_failure(&result);
5378                })?;
5379
5380                let transaction_response = result?;
5381                buffer_store
5382                    .update(&mut cx, |buffer_store, cx| {
5383                        buffer_store.deserialize_project_transaction(
5384                            transaction_response,
5385                            push_to_history,
5386                            cx,
5387                        )
5388                    })?
5389                    .await
5390            })
5391        } else {
5392            Task::ready(Ok(ProjectTransaction::default()))
5393        }
5394    }
5395
5396    async fn handle_format_buffers(
5397        this: Model<Self>,
5398        envelope: TypedEnvelope<proto::FormatBuffers>,
5399        mut cx: AsyncAppContext,
5400    ) -> Result<proto::FormatBuffersResponse> {
5401        let sender_id = envelope.original_sender_id().unwrap_or_default();
5402        let format = this.update(&mut cx, |this, cx| {
5403            let mut buffers = HashSet::default();
5404            for buffer_id in &envelope.payload.buffer_ids {
5405                let buffer_id = BufferId::new(*buffer_id)?;
5406                buffers.insert(this.buffer_store.read(cx).get_existing(buffer_id)?);
5407            }
5408            let trigger = FormatTrigger::from_proto(envelope.payload.trigger);
5409            anyhow::Ok(this.format(buffers, false, trigger, FormatTarget::Buffer, cx))
5410        })??;
5411
5412        let project_transaction = format.await?;
5413        let project_transaction = this.update(&mut cx, |this, cx| {
5414            this.buffer_store.update(cx, |buffer_store, cx| {
5415                buffer_store.serialize_project_transaction_for_peer(
5416                    project_transaction,
5417                    sender_id,
5418                    cx,
5419                )
5420            })
5421        })?;
5422        Ok(proto::FormatBuffersResponse {
5423            transaction: Some(project_transaction),
5424        })
5425    }
5426
5427    pub fn start_language_servers(
5428        &mut self,
5429        worktree: &Model<Worktree>,
5430        language: LanguageName,
5431        cx: &mut ModelContext<Self>,
5432    ) {
5433        let root_file = worktree
5434            .update(cx, |tree, cx| tree.root_file(cx))
5435            .map(|f| f as _);
5436        let settings = language_settings(Some(language.clone()), root_file.as_ref(), cx);
5437        if !settings.enable_language_server || self.mode.is_remote() {
5438            return;
5439        }
5440
5441        let available_lsp_adapters = self.languages.clone().lsp_adapters(&language);
5442        let available_language_servers = available_lsp_adapters
5443            .iter()
5444            .map(|lsp_adapter| lsp_adapter.name.clone())
5445            .collect::<Vec<_>>();
5446
5447        let desired_language_servers =
5448            settings.customized_language_servers(&available_language_servers);
5449
5450        let mut enabled_lsp_adapters: Vec<Arc<CachedLspAdapter>> = Vec::new();
5451        for desired_language_server in desired_language_servers {
5452            if let Some(adapter) = available_lsp_adapters
5453                .iter()
5454                .find(|adapter| adapter.name == desired_language_server)
5455            {
5456                enabled_lsp_adapters.push(adapter.clone());
5457                continue;
5458            }
5459
5460            if let Some(adapter) = self
5461                .languages
5462                .load_available_lsp_adapter(&desired_language_server)
5463            {
5464                self.languages
5465                    .register_lsp_adapter(language.clone(), adapter.adapter.clone());
5466                enabled_lsp_adapters.push(adapter);
5467                continue;
5468            }
5469
5470            log::warn!(
5471                "no language server found matching '{}'",
5472                desired_language_server.0
5473            );
5474        }
5475
5476        for adapter in &enabled_lsp_adapters {
5477            self.start_language_server(worktree, adapter.clone(), language.clone(), cx);
5478        }
5479
5480        // After starting all the language servers, reorder them to reflect the desired order
5481        // based on the settings.
5482        //
5483        // This is done, in part, to ensure that language servers loaded at different points
5484        // (e.g., native vs extension) still end up in the right order at the end, rather than
5485        // it being based on which language server happened to be loaded in first.
5486        self.languages
5487            .reorder_language_servers(&language, enabled_lsp_adapters);
5488    }
5489
5490    fn get_language_server_binary(
5491        &self,
5492        adapter: Arc<CachedLspAdapter>,
5493        delegate: Arc<dyn LspAdapterDelegate>,
5494        allow_binary_download: bool,
5495        cx: &mut ModelContext<Self>,
5496    ) -> Task<Result<LanguageServerBinary>> {
5497        let settings = ProjectSettings::get(
5498            Some(SettingsLocation {
5499                worktree_id: delegate.worktree_id(),
5500                path: Path::new(""),
5501            }),
5502            cx,
5503        )
5504        .lsp
5505        .get(&adapter.name)
5506        .and_then(|s| s.binary.clone());
5507
5508        if settings.as_ref().is_some_and(|b| b.path.is_some()) {
5509            let settings = settings.unwrap();
5510            return cx.spawn(|_, _| async move {
5511                Ok(LanguageServerBinary {
5512                    path: PathBuf::from(&settings.path.unwrap()),
5513                    env: Some(delegate.shell_env().await),
5514                    arguments: settings
5515                        .arguments
5516                        .unwrap_or_default()
5517                        .iter()
5518                        .map(Into::into)
5519                        .collect(),
5520                })
5521            });
5522        }
5523        let lsp_binary_options = LanguageServerBinaryOptions {
5524            allow_path_lookup: !settings
5525                .as_ref()
5526                .and_then(|b| b.ignore_system_version)
5527                .unwrap_or_default(),
5528            allow_binary_download,
5529        };
5530        cx.spawn(|_, mut cx| async move {
5531            let binary_result = adapter
5532                .clone()
5533                .get_language_server_command(delegate.clone(), lsp_binary_options, &mut cx)
5534                .await;
5535
5536            delegate.update_status(adapter.name.clone(), LanguageServerBinaryStatus::None);
5537
5538            let mut binary = binary_result?;
5539            if let Some(arguments) = settings.and_then(|b| b.arguments) {
5540                binary.arguments = arguments.into_iter().map(Into::into).collect();
5541            }
5542
5543            let mut shell_env = delegate.shell_env().await;
5544            shell_env.extend(binary.env.unwrap_or_default());
5545            binary.env = Some(shell_env);
5546            Ok(binary)
5547        })
5548    }
5549
5550    fn start_language_server(
5551        &mut self,
5552        worktree_handle: &Model<Worktree>,
5553        adapter: Arc<CachedLspAdapter>,
5554        language: LanguageName,
5555        cx: &mut ModelContext<Self>,
5556    ) {
5557        if self.mode.is_remote() {
5558            return;
5559        }
5560
5561        let worktree = worktree_handle.read(cx);
5562        let worktree_id = worktree.id();
5563        let worktree_path = worktree.abs_path();
5564        let key = (worktree_id, adapter.name.clone());
5565
5566        if self.language_server_ids.contains_key(&key) {
5567            return;
5568        }
5569
5570        let project_settings = ProjectSettings::get(
5571            Some(SettingsLocation {
5572                worktree_id,
5573                path: Path::new(""),
5574            }),
5575            cx,
5576        );
5577        let lsp = project_settings.lsp.get(&adapter.name);
5578        let override_options = lsp.and_then(|s| s.initialization_options.clone());
5579
5580        let stderr_capture = Arc::new(Mutex::new(Some(String::new())));
5581        let delegate = LocalLspAdapterDelegate::for_local(self, worktree_handle, cx)
5582            as Arc<dyn LspAdapterDelegate>;
5583
5584        let server_id = self.languages.next_language_server_id();
5585        let root_path = worktree_path.clone();
5586        log::info!(
5587            "attempting to start language server {:?}, path: {root_path:?}, id: {server_id}",
5588            adapter.name.0
5589        );
5590
5591        let binary = self.get_language_server_binary(adapter.clone(), delegate.clone(), true, cx);
5592
5593        let pending_server = cx.spawn({
5594            let adapter = adapter.clone();
5595            let server_name = adapter.name.clone();
5596            let stderr_capture = stderr_capture.clone();
5597
5598            move |_lsp_store, cx| async move {
5599                let binary = binary.await?;
5600
5601                #[cfg(any(test, feature = "test-support"))]
5602                if let Some(server) = _lsp_store
5603                    .update(&mut cx.clone(), |this, cx| {
5604                        this.languages.create_fake_language_server(
5605                            server_id,
5606                            &server_name,
5607                            binary.clone(),
5608                            cx.to_async(),
5609                        )
5610                    })
5611                    .ok()
5612                    .flatten()
5613                {
5614                    return Ok(server);
5615                }
5616
5617                lsp::LanguageServer::new(
5618                    stderr_capture,
5619                    server_id,
5620                    server_name,
5621                    binary,
5622                    &root_path,
5623                    adapter.code_action_kinds(),
5624                    cx,
5625                )
5626            }
5627        });
5628
5629        let state = LanguageServerState::Starting({
5630            let server_name = adapter.name.0.clone();
5631            let delegate = delegate as Arc<dyn LspAdapterDelegate>;
5632            let language = language.clone();
5633            let key = key.clone();
5634            let adapter = adapter.clone();
5635
5636            cx.spawn(move |this, mut cx| async move {
5637                let result = {
5638                    let delegate = delegate.clone();
5639                    let adapter = adapter.clone();
5640                    let this = this.clone();
5641                    let toolchains = this
5642                        .update(&mut cx, |this, cx| this.toolchain_store(cx))
5643                        .ok()?;
5644                    let mut cx = cx.clone();
5645                    async move {
5646                        let language_server = pending_server.await?;
5647
5648                        let workspace_config = adapter
5649                            .adapter
5650                            .clone()
5651                            .workspace_configuration(&delegate, toolchains.clone(), &mut cx)
5652                            .await?;
5653
5654                        let mut initialization_options = adapter
5655                            .adapter
5656                            .clone()
5657                            .initialization_options(&(delegate))
5658                            .await?;
5659
5660                        Self::setup_lsp_messages(this.clone(), &language_server, delegate, adapter);
5661
5662                        match (&mut initialization_options, override_options) {
5663                            (Some(initialization_options), Some(override_options)) => {
5664                                merge_json_value_into(override_options, initialization_options);
5665                            }
5666                            (None, override_options) => initialization_options = override_options,
5667                            _ => {}
5668                        }
5669
5670                        let language_server = cx
5671                            .update(|cx| language_server.initialize(initialization_options, cx))?
5672                            .await
5673                            .inspect_err(|_| {
5674                                if let Some(this) = this.upgrade() {
5675                                    this.update(&mut cx, |_, cx| {
5676                                        cx.emit(LspStoreEvent::LanguageServerRemoved(server_id))
5677                                    })
5678                                    .ok();
5679                                }
5680                            })?;
5681
5682                        language_server
5683                            .notify::<lsp::notification::DidChangeConfiguration>(
5684                                lsp::DidChangeConfigurationParams {
5685                                    settings: workspace_config,
5686                                },
5687                            )
5688                            .ok();
5689
5690                        anyhow::Ok(language_server)
5691                    }
5692                }
5693                .await;
5694
5695                match result {
5696                    Ok(server) => {
5697                        this.update(&mut cx, |this, mut cx| {
5698                            this.insert_newly_running_language_server(
5699                                language,
5700                                adapter,
5701                                server.clone(),
5702                                server_id,
5703                                key,
5704                                &mut cx,
5705                            );
5706                        })
5707                        .ok();
5708                        stderr_capture.lock().take();
5709                        Some(server)
5710                    }
5711
5712                    Err(err) => {
5713                        let log = stderr_capture.lock().take().unwrap_or_default();
5714                        delegate.update_status(
5715                            adapter.name(),
5716                            LanguageServerBinaryStatus::Failed {
5717                                error: format!("{err}\n-- stderr--\n{}", log),
5718                            },
5719                        );
5720                        log::error!("Failed to start language server {server_name:?}: {err}");
5721                        log::error!("server stderr: {:?}", log);
5722                        None
5723                    }
5724                }
5725            })
5726        });
5727
5728        self.as_local_mut()
5729            .unwrap()
5730            .language_servers
5731            .insert(server_id, state);
5732        self.language_server_ids.insert(key, server_id);
5733    }
5734
5735    async fn shutdown_language_server(
5736        server_state: Option<LanguageServerState>,
5737        name: LanguageServerName,
5738        cx: AsyncAppContext,
5739    ) {
5740        let server = match server_state {
5741            Some(LanguageServerState::Starting(task)) => {
5742                let mut timer = cx
5743                    .background_executor()
5744                    .timer(SERVER_LAUNCHING_BEFORE_SHUTDOWN_TIMEOUT)
5745                    .fuse();
5746
5747                select! {
5748                    server = task.fuse() => server,
5749                    _ = timer => {
5750                        log::info!(
5751                            "timeout waiting for language server {} to finish launching before stopping",
5752                            name
5753                        );
5754                        None
5755                    },
5756                }
5757            }
5758
5759            Some(LanguageServerState::Running { server, .. }) => Some(server),
5760
5761            None => None,
5762        };
5763
5764        if let Some(server) = server {
5765            if let Some(shutdown) = server.shutdown() {
5766                shutdown.await;
5767            }
5768        }
5769    }
5770
5771    // Returns a list of all of the worktrees which no longer have a language server and the root path
5772    // for the stopped server
5773    fn stop_local_language_server(
5774        &mut self,
5775        worktree_id: WorktreeId,
5776        adapter_name: LanguageServerName,
5777        cx: &mut ModelContext<Self>,
5778    ) -> Task<Vec<WorktreeId>> {
5779        let key = (worktree_id, adapter_name);
5780        if self.mode.is_local() {
5781            if let Some(server_id) = self.language_server_ids.remove(&key) {
5782                let name = key.1;
5783                log::info!("stopping language server {name}");
5784
5785                // Remove other entries for this language server as well
5786                let mut orphaned_worktrees = vec![worktree_id];
5787                let other_keys = self.language_server_ids.keys().cloned().collect::<Vec<_>>();
5788                for other_key in other_keys {
5789                    if self.language_server_ids.get(&other_key) == Some(&server_id) {
5790                        self.language_server_ids.remove(&other_key);
5791                        orphaned_worktrees.push(other_key.0);
5792                    }
5793                }
5794
5795                self.buffer_store.update(cx, |buffer_store, cx| {
5796                    for buffer in buffer_store.buffers() {
5797                        buffer.update(cx, |buffer, cx| {
5798                            buffer.update_diagnostics(
5799                                server_id,
5800                                DiagnosticSet::new([], buffer),
5801                                cx,
5802                            );
5803                            buffer.set_completion_triggers(server_id, Default::default(), cx);
5804                        });
5805                    }
5806                });
5807
5808                for (worktree_id, summaries) in self.diagnostic_summaries.iter_mut() {
5809                    summaries.retain(|path, summaries_by_server_id| {
5810                        if summaries_by_server_id.remove(&server_id).is_some() {
5811                            if let Some((client, project_id)) = self.downstream_client.clone() {
5812                                client
5813                                    .send(proto::UpdateDiagnosticSummary {
5814                                        project_id,
5815                                        worktree_id: worktree_id.to_proto(),
5816                                        summary: Some(proto::DiagnosticSummary {
5817                                            path: path.to_string_lossy().to_string(),
5818                                            language_server_id: server_id.0 as u64,
5819                                            error_count: 0,
5820                                            warning_count: 0,
5821                                        }),
5822                                    })
5823                                    .log_err();
5824                            }
5825                            !summaries_by_server_id.is_empty()
5826                        } else {
5827                            true
5828                        }
5829                    });
5830                }
5831
5832                for diagnostics in self.diagnostics.values_mut() {
5833                    diagnostics.retain(|_, diagnostics_by_server_id| {
5834                        if let Ok(ix) =
5835                            diagnostics_by_server_id.binary_search_by_key(&server_id, |e| e.0)
5836                        {
5837                            diagnostics_by_server_id.remove(ix);
5838                            !diagnostics_by_server_id.is_empty()
5839                        } else {
5840                            true
5841                        }
5842                    });
5843                }
5844
5845                self.as_local_mut()
5846                    .unwrap()
5847                    .language_server_watched_paths
5848                    .remove(&server_id);
5849                self.language_server_statuses.remove(&server_id);
5850                cx.notify();
5851
5852                let server_state = self
5853                    .as_local_mut()
5854                    .unwrap()
5855                    .language_servers
5856                    .remove(&server_id);
5857                cx.emit(LspStoreEvent::LanguageServerRemoved(server_id));
5858                cx.spawn(move |_, cx| async move {
5859                    Self::shutdown_language_server(server_state, name, cx).await;
5860                    orphaned_worktrees
5861                })
5862            } else {
5863                Task::ready(Vec::new())
5864            }
5865        } else {
5866            Task::ready(Vec::new())
5867        }
5868    }
5869
5870    pub fn restart_language_servers_for_buffers(
5871        &mut self,
5872        buffers: impl IntoIterator<Item = Model<Buffer>>,
5873        cx: &mut ModelContext<Self>,
5874    ) {
5875        if let Some((client, project_id)) = self.upstream_client() {
5876            let request = client.request(proto::RestartLanguageServers {
5877                project_id,
5878                buffer_ids: buffers
5879                    .into_iter()
5880                    .map(|b| b.read(cx).remote_id().to_proto())
5881                    .collect(),
5882            });
5883            cx.background_executor()
5884                .spawn(request)
5885                .detach_and_log_err(cx);
5886        } else {
5887            let language_server_lookup_info: HashSet<(Model<Worktree>, LanguageName)> = buffers
5888                .into_iter()
5889                .filter_map(|buffer| {
5890                    let buffer = buffer.read(cx);
5891                    let file = buffer.file()?;
5892                    let worktree = File::from_dyn(Some(file))?.worktree.clone();
5893                    let language =
5894                        self.languages
5895                            .language_for_file(file, Some(buffer.as_rope()), cx)?;
5896
5897                    Some((worktree, language.name()))
5898                })
5899                .collect();
5900
5901            for (worktree, language) in language_server_lookup_info {
5902                self.restart_local_language_servers(worktree, language, cx);
5903            }
5904        }
5905    }
5906
5907    fn restart_local_language_servers(
5908        &mut self,
5909        worktree: Model<Worktree>,
5910        language: LanguageName,
5911        cx: &mut ModelContext<Self>,
5912    ) {
5913        let worktree_id = worktree.read(cx).id();
5914
5915        let stop_tasks = self
5916            .languages
5917            .clone()
5918            .lsp_adapters(&language)
5919            .iter()
5920            .map(|adapter| {
5921                let stop_task =
5922                    self.stop_local_language_server(worktree_id, adapter.name.clone(), cx);
5923                (stop_task, adapter.name.clone())
5924            })
5925            .collect::<Vec<_>>();
5926        if stop_tasks.is_empty() {
5927            return;
5928        }
5929
5930        cx.spawn(move |this, mut cx| async move {
5931            // For each stopped language server, record all of the worktrees with which
5932            // it was associated.
5933            let mut affected_worktrees = Vec::new();
5934            for (stop_task, language_server_name) in stop_tasks {
5935                for affected_worktree_id in stop_task.await {
5936                    affected_worktrees.push((affected_worktree_id, language_server_name.clone()));
5937                }
5938            }
5939
5940            this.update(&mut cx, |this, cx| {
5941                // Restart the language server for the given worktree.
5942                this.start_language_servers(&worktree, language.clone(), cx);
5943
5944                // Lookup new server ids and set them for each of the orphaned worktrees
5945                for (affected_worktree_id, language_server_name) in affected_worktrees {
5946                    if let Some(new_server_id) = this
5947                        .language_server_ids
5948                        .get(&(worktree_id, language_server_name.clone()))
5949                        .cloned()
5950                    {
5951                        this.language_server_ids
5952                            .insert((affected_worktree_id, language_server_name), new_server_id);
5953                    }
5954                }
5955            })
5956            .ok();
5957        })
5958        .detach();
5959    }
5960
5961    fn setup_lsp_messages(
5962        this: WeakModel<Self>,
5963        language_server: &LanguageServer,
5964        delegate: Arc<dyn LspAdapterDelegate>,
5965        adapter: Arc<CachedLspAdapter>,
5966    ) {
5967        let name = language_server.name();
5968        let server_id = language_server.server_id();
5969        language_server
5970            .on_notification::<lsp::notification::PublishDiagnostics, _>({
5971                let adapter = adapter.clone();
5972                let this = this.clone();
5973                move |mut params, mut cx| {
5974                    let adapter = adapter.clone();
5975                    if let Some(this) = this.upgrade() {
5976                        adapter.process_diagnostics(&mut params);
5977                        this.update(&mut cx, |this, cx| {
5978                            this.update_diagnostics(
5979                                server_id,
5980                                params,
5981                                &adapter.disk_based_diagnostic_sources,
5982                                cx,
5983                            )
5984                            .log_err();
5985                        })
5986                        .ok();
5987                    }
5988                }
5989            })
5990            .detach();
5991        language_server
5992            .on_request::<lsp::request::WorkspaceConfiguration, _, _>({
5993                let adapter = adapter.adapter.clone();
5994                let delegate = delegate.clone();
5995                let this = this.clone();
5996                move |params, mut cx| {
5997                    let adapter = adapter.clone();
5998                    let delegate = delegate.clone();
5999                    let this = this.clone();
6000                    async move {
6001                        let toolchains =
6002                            this.update(&mut cx, |this, cx| this.toolchain_store(cx))?;
6003                        let workspace_config = adapter
6004                            .workspace_configuration(&delegate, toolchains, &mut cx)
6005                            .await?;
6006                        Ok(params
6007                            .items
6008                            .into_iter()
6009                            .map(|item| {
6010                                if let Some(section) = &item.section {
6011                                    workspace_config
6012                                        .get(section)
6013                                        .cloned()
6014                                        .unwrap_or(serde_json::Value::Null)
6015                                } else {
6016                                    workspace_config.clone()
6017                                }
6018                            })
6019                            .collect())
6020                    }
6021                }
6022            })
6023            .detach();
6024
6025        language_server
6026            .on_request::<lsp::request::WorkspaceFoldersRequest, _, _>({
6027                let this = this.clone();
6028                move |_, mut cx| {
6029                    let this = this.clone();
6030                    async move {
6031                        let Some(server) =
6032                            this.update(&mut cx, |this, _| this.language_server_for_id(server_id))?
6033                        else {
6034                            return Ok(None);
6035                        };
6036                        let root = server.root_path();
6037                        let Ok(uri) = Url::from_file_path(&root) else {
6038                            return Ok(None);
6039                        };
6040                        Ok(Some(vec![WorkspaceFolder {
6041                            uri,
6042                            name: Default::default(),
6043                        }]))
6044                    }
6045                }
6046            })
6047            .detach();
6048        // Even though we don't have handling for these requests, respond to them to
6049        // avoid stalling any language server like `gopls` which waits for a response
6050        // to these requests when initializing.
6051        language_server
6052            .on_request::<lsp::request::WorkDoneProgressCreate, _, _>({
6053                let this = this.clone();
6054                move |params, mut cx| {
6055                    let this = this.clone();
6056                    async move {
6057                        this.update(&mut cx, |this, _| {
6058                            if let Some(status) = this.language_server_statuses.get_mut(&server_id)
6059                            {
6060                                if let lsp::NumberOrString::String(token) = params.token {
6061                                    status.progress_tokens.insert(token);
6062                                }
6063                            }
6064                        })?;
6065
6066                        Ok(())
6067                    }
6068                }
6069            })
6070            .detach();
6071
6072        language_server
6073            .on_request::<lsp::request::RegisterCapability, _, _>({
6074                let this = this.clone();
6075                move |params, mut cx| {
6076                    let this = this.clone();
6077                    async move {
6078                        for reg in params.registrations {
6079                            match reg.method.as_str() {
6080                                "workspace/didChangeWatchedFiles" => {
6081                                    if let Some(options) = reg.register_options {
6082                                        let options = serde_json::from_value(options)?;
6083                                        this.update(&mut cx, |this, cx| {
6084                                            this.on_lsp_did_change_watched_files(
6085                                                server_id, &reg.id, options, cx,
6086                                            );
6087                                        })?;
6088                                    }
6089                                }
6090                                "textDocument/rangeFormatting" => {
6091                                    this.update(&mut cx, |this, _| {
6092                                        if let Some(server) = this.language_server_for_id(server_id)
6093                                        {
6094                                            let options = reg
6095                                                .register_options
6096                                                .map(|options| {
6097                                                    serde_json::from_value::<
6098                                                        lsp::DocumentRangeFormattingOptions,
6099                                                    >(
6100                                                        options
6101                                                    )
6102                                                })
6103                                                .transpose()?;
6104                                            let provider = match options {
6105                                                None => OneOf::Left(true),
6106                                                Some(options) => OneOf::Right(options),
6107                                            };
6108                                            server.update_capabilities(|capabilities| {
6109                                                capabilities.document_range_formatting_provider =
6110                                                    Some(provider);
6111                                            })
6112                                        }
6113                                        anyhow::Ok(())
6114                                    })??;
6115                                }
6116                                "textDocument/onTypeFormatting" => {
6117                                    this.update(&mut cx, |this, _| {
6118                                        if let Some(server) = this.language_server_for_id(server_id)
6119                                        {
6120                                            let options = reg
6121                                                .register_options
6122                                                .map(|options| {
6123                                                    serde_json::from_value::<
6124                                                        lsp::DocumentOnTypeFormattingOptions,
6125                                                    >(
6126                                                        options
6127                                                    )
6128                                                })
6129                                                .transpose()?;
6130                                            if let Some(options) = options {
6131                                                server.update_capabilities(|capabilities| {
6132                                                    capabilities
6133                                                        .document_on_type_formatting_provider =
6134                                                        Some(options);
6135                                                })
6136                                            }
6137                                        }
6138                                        anyhow::Ok(())
6139                                    })??;
6140                                }
6141                                "textDocument/formatting" => {
6142                                    this.update(&mut cx, |this, _| {
6143                                        if let Some(server) = this.language_server_for_id(server_id)
6144                                        {
6145                                            let options = reg
6146                                                .register_options
6147                                                .map(|options| {
6148                                                    serde_json::from_value::<
6149                                                        lsp::DocumentFormattingOptions,
6150                                                    >(
6151                                                        options
6152                                                    )
6153                                                })
6154                                                .transpose()?;
6155                                            let provider = match options {
6156                                                None => OneOf::Left(true),
6157                                                Some(options) => OneOf::Right(options),
6158                                            };
6159                                            server.update_capabilities(|capabilities| {
6160                                                capabilities.document_formatting_provider =
6161                                                    Some(provider);
6162                                            })
6163                                        }
6164                                        anyhow::Ok(())
6165                                    })??;
6166                                }
6167                                _ => log::warn!("unhandled capability registration: {reg:?}"),
6168                            }
6169                        }
6170                        Ok(())
6171                    }
6172                }
6173            })
6174            .detach();
6175
6176        language_server
6177            .on_request::<lsp::request::UnregisterCapability, _, _>({
6178                let this = this.clone();
6179                move |params, mut cx| {
6180                    let this = this.clone();
6181                    async move {
6182                        for unreg in params.unregisterations.iter() {
6183                            match unreg.method.as_str() {
6184                                "workspace/didChangeWatchedFiles" => {
6185                                    this.update(&mut cx, |this, cx| {
6186                                        this.on_lsp_unregister_did_change_watched_files(
6187                                            server_id, &unreg.id, cx,
6188                                        );
6189                                    })?;
6190                                }
6191                                "textDocument/rename" => {
6192                                    this.update(&mut cx, |this, _| {
6193                                        if let Some(server) = this.language_server_for_id(server_id)
6194                                        {
6195                                            server.update_capabilities(|capabilities| {
6196                                                capabilities.rename_provider = None
6197                                            })
6198                                        }
6199                                    })?;
6200                                }
6201                                "textDocument/rangeFormatting" => {
6202                                    this.update(&mut cx, |this, _| {
6203                                        if let Some(server) = this.language_server_for_id(server_id)
6204                                        {
6205                                            server.update_capabilities(|capabilities| {
6206                                                capabilities.document_range_formatting_provider =
6207                                                    None
6208                                            })
6209                                        }
6210                                    })?;
6211                                }
6212                                "textDocument/onTypeFormatting" => {
6213                                    this.update(&mut cx, |this, _| {
6214                                        if let Some(server) = this.language_server_for_id(server_id)
6215                                        {
6216                                            server.update_capabilities(|capabilities| {
6217                                                capabilities.document_on_type_formatting_provider =
6218                                                    None;
6219                                            })
6220                                        }
6221                                    })?;
6222                                }
6223                                "textDocument/formatting" => {
6224                                    this.update(&mut cx, |this, _| {
6225                                        if let Some(server) = this.language_server_for_id(server_id)
6226                                        {
6227                                            server.update_capabilities(|capabilities| {
6228                                                capabilities.document_formatting_provider = None;
6229                                            })
6230                                        }
6231                                    })?;
6232                                }
6233                                _ => log::warn!("unhandled capability unregistration: {unreg:?}"),
6234                            }
6235                        }
6236                        Ok(())
6237                    }
6238                }
6239            })
6240            .detach();
6241
6242        language_server
6243            .on_request::<lsp::request::ApplyWorkspaceEdit, _, _>({
6244                let adapter = adapter.clone();
6245                let this = this.clone();
6246                move |params, cx| {
6247                    Self::on_lsp_workspace_edit(
6248                        this.clone(),
6249                        params,
6250                        server_id,
6251                        adapter.clone(),
6252                        cx,
6253                    )
6254                }
6255            })
6256            .detach();
6257
6258        language_server
6259            .on_request::<lsp::request::InlayHintRefreshRequest, _, _>({
6260                let this = this.clone();
6261                move |(), mut cx| {
6262                    let this = this.clone();
6263                    async move {
6264                        this.update(&mut cx, |this, cx| {
6265                            cx.emit(LspStoreEvent::RefreshInlayHints);
6266                            this.downstream_client.as_ref().map(|(client, project_id)| {
6267                                client.send(proto::RefreshInlayHints {
6268                                    project_id: *project_id,
6269                                })
6270                            })
6271                        })?
6272                        .transpose()?;
6273                        Ok(())
6274                    }
6275                }
6276            })
6277            .detach();
6278
6279        language_server
6280            .on_request::<lsp::request::ShowMessageRequest, _, _>({
6281                let this = this.clone();
6282                let name = name.to_string();
6283                move |params, mut cx| {
6284                    let this = this.clone();
6285                    let name = name.to_string();
6286                    async move {
6287                        let actions = params.actions.unwrap_or_default();
6288                        let (tx, mut rx) = smol::channel::bounded(1);
6289                        let request = LanguageServerPromptRequest {
6290                            level: match params.typ {
6291                                lsp::MessageType::ERROR => PromptLevel::Critical,
6292                                lsp::MessageType::WARNING => PromptLevel::Warning,
6293                                _ => PromptLevel::Info,
6294                            },
6295                            message: params.message,
6296                            actions,
6297                            response_channel: tx,
6298                            lsp_name: name.clone(),
6299                        };
6300
6301                        let did_update = this
6302                            .update(&mut cx, |_, cx| {
6303                                cx.emit(LspStoreEvent::LanguageServerPrompt(request));
6304                            })
6305                            .is_ok();
6306                        if did_update {
6307                            let response = rx.next().await;
6308
6309                            Ok(response)
6310                        } else {
6311                            Ok(None)
6312                        }
6313                    }
6314                }
6315            })
6316            .detach();
6317
6318        language_server
6319            .on_notification::<ServerStatus, _>({
6320                let this = this.clone();
6321                let name = name.to_string();
6322                move |params, mut cx| {
6323                    let this = this.clone();
6324                    let name = name.to_string();
6325                    if let Some(ref message) = params.message {
6326                        let message = message.trim();
6327                        if !message.is_empty() {
6328                            let formatted_message = format!(
6329                                "Language server {name} (id {server_id}) status update: {message}"
6330                            );
6331                            match params.health {
6332                                ServerHealthStatus::Ok => log::info!("{}", formatted_message),
6333                                ServerHealthStatus::Warning => log::warn!("{}", formatted_message),
6334                                ServerHealthStatus::Error => {
6335                                    log::error!("{}", formatted_message);
6336                                    let (tx, _rx) = smol::channel::bounded(1);
6337                                    let request = LanguageServerPromptRequest {
6338                                        level: PromptLevel::Critical,
6339                                        message: params.message.unwrap_or_default(),
6340                                        actions: Vec::new(),
6341                                        response_channel: tx,
6342                                        lsp_name: name.clone(),
6343                                    };
6344                                    let _ = this
6345                                        .update(&mut cx, |_, cx| {
6346                                            cx.emit(LspStoreEvent::LanguageServerPrompt(request));
6347                                        })
6348                                        .ok();
6349                                }
6350                                ServerHealthStatus::Other(status) => {
6351                                    log::info!(
6352                                        "Unknown server health: {status}\n{formatted_message}"
6353                                    )
6354                                }
6355                            }
6356                        }
6357                    }
6358                }
6359            })
6360            .detach();
6361        language_server
6362            .on_notification::<lsp::notification::ShowMessage, _>({
6363                let this = this.clone();
6364                let name = name.to_string();
6365                move |params, mut cx| {
6366                    let this = this.clone();
6367                    let name = name.to_string();
6368
6369                    let (tx, _) = smol::channel::bounded(1);
6370                    let request = LanguageServerPromptRequest {
6371                        level: match params.typ {
6372                            lsp::MessageType::ERROR => PromptLevel::Critical,
6373                            lsp::MessageType::WARNING => PromptLevel::Warning,
6374                            _ => PromptLevel::Info,
6375                        },
6376                        message: params.message,
6377                        actions: vec![],
6378                        response_channel: tx,
6379                        lsp_name: name.clone(),
6380                    };
6381
6382                    let _ = this.update(&mut cx, |_, cx| {
6383                        cx.emit(LspStoreEvent::LanguageServerPrompt(request));
6384                    });
6385                }
6386            })
6387            .detach();
6388
6389        let disk_based_diagnostics_progress_token =
6390            adapter.disk_based_diagnostics_progress_token.clone();
6391
6392        language_server
6393            .on_notification::<lsp::notification::Progress, _>({
6394                let this = this.clone();
6395                move |params, mut cx| {
6396                    if let Some(this) = this.upgrade() {
6397                        this.update(&mut cx, |this, cx| {
6398                            this.on_lsp_progress(
6399                                params,
6400                                server_id,
6401                                disk_based_diagnostics_progress_token.clone(),
6402                                cx,
6403                            );
6404                        })
6405                        .ok();
6406                    }
6407                }
6408            })
6409            .detach();
6410
6411        language_server
6412            .on_notification::<lsp::notification::LogMessage, _>({
6413                let this = this.clone();
6414                move |params, mut cx| {
6415                    if let Some(this) = this.upgrade() {
6416                        this.update(&mut cx, |_, cx| {
6417                            cx.emit(LspStoreEvent::LanguageServerLog(
6418                                server_id,
6419                                LanguageServerLogType::Log(params.typ),
6420                                params.message,
6421                            ));
6422                        })
6423                        .ok();
6424                    }
6425                }
6426            })
6427            .detach();
6428
6429        language_server
6430            .on_notification::<lsp::notification::LogTrace, _>({
6431                let this = this.clone();
6432                move |params, mut cx| {
6433                    if let Some(this) = this.upgrade() {
6434                        this.update(&mut cx, |_, cx| {
6435                            cx.emit(LspStoreEvent::LanguageServerLog(
6436                                server_id,
6437                                LanguageServerLogType::Trace(params.verbose),
6438                                params.message,
6439                            ));
6440                        })
6441                        .ok();
6442                    }
6443                }
6444            })
6445            .detach();
6446    }
6447
6448    pub fn update_diagnostics(
6449        &mut self,
6450        language_server_id: LanguageServerId,
6451        mut params: lsp::PublishDiagnosticsParams,
6452        disk_based_sources: &[String],
6453        cx: &mut ModelContext<Self>,
6454    ) -> Result<()> {
6455        let abs_path = params
6456            .uri
6457            .to_file_path()
6458            .map_err(|_| anyhow!("URI is not a file"))?;
6459        let mut diagnostics = Vec::default();
6460        let mut primary_diagnostic_group_ids = HashMap::default();
6461        let mut sources_by_group_id = HashMap::default();
6462        let mut supporting_diagnostics = HashMap::default();
6463
6464        // Ensure that primary diagnostics are always the most severe
6465        params.diagnostics.sort_by_key(|item| item.severity);
6466
6467        for diagnostic in &params.diagnostics {
6468            let source = diagnostic.source.as_ref();
6469            let code = diagnostic.code.as_ref().map(|code| match code {
6470                lsp::NumberOrString::Number(code) => code.to_string(),
6471                lsp::NumberOrString::String(code) => code.clone(),
6472            });
6473            let range = range_from_lsp(diagnostic.range);
6474            let is_supporting = diagnostic
6475                .related_information
6476                .as_ref()
6477                .map_or(false, |infos| {
6478                    infos.iter().any(|info| {
6479                        primary_diagnostic_group_ids.contains_key(&(
6480                            source,
6481                            code.clone(),
6482                            range_from_lsp(info.location.range),
6483                        ))
6484                    })
6485                });
6486
6487            let is_unnecessary = diagnostic.tags.as_ref().map_or(false, |tags| {
6488                tags.iter().any(|tag| *tag == DiagnosticTag::UNNECESSARY)
6489            });
6490
6491            if is_supporting {
6492                supporting_diagnostics.insert(
6493                    (source, code.clone(), range),
6494                    (diagnostic.severity, is_unnecessary),
6495                );
6496            } else {
6497                let group_id = post_inc(&mut self.next_diagnostic_group_id);
6498                let is_disk_based =
6499                    source.map_or(false, |source| disk_based_sources.contains(source));
6500
6501                sources_by_group_id.insert(group_id, source);
6502                primary_diagnostic_group_ids
6503                    .insert((source, code.clone(), range.clone()), group_id);
6504
6505                diagnostics.push(DiagnosticEntry {
6506                    range,
6507                    diagnostic: Diagnostic {
6508                        source: diagnostic.source.clone(),
6509                        code: code.clone(),
6510                        severity: diagnostic.severity.unwrap_or(DiagnosticSeverity::ERROR),
6511                        message: diagnostic.message.trim().to_string(),
6512                        group_id,
6513                        is_primary: true,
6514                        is_disk_based,
6515                        is_unnecessary,
6516                        data: diagnostic.data.clone(),
6517                    },
6518                });
6519                if let Some(infos) = &diagnostic.related_information {
6520                    for info in infos {
6521                        if info.location.uri == params.uri && !info.message.is_empty() {
6522                            let range = range_from_lsp(info.location.range);
6523                            diagnostics.push(DiagnosticEntry {
6524                                range,
6525                                diagnostic: Diagnostic {
6526                                    source: diagnostic.source.clone(),
6527                                    code: code.clone(),
6528                                    severity: DiagnosticSeverity::INFORMATION,
6529                                    message: info.message.trim().to_string(),
6530                                    group_id,
6531                                    is_primary: false,
6532                                    is_disk_based,
6533                                    is_unnecessary: false,
6534                                    data: diagnostic.data.clone(),
6535                                },
6536                            });
6537                        }
6538                    }
6539                }
6540            }
6541        }
6542
6543        for entry in &mut diagnostics {
6544            let diagnostic = &mut entry.diagnostic;
6545            if !diagnostic.is_primary {
6546                let source = *sources_by_group_id.get(&diagnostic.group_id).unwrap();
6547                if let Some(&(severity, is_unnecessary)) = supporting_diagnostics.get(&(
6548                    source,
6549                    diagnostic.code.clone(),
6550                    entry.range.clone(),
6551                )) {
6552                    if let Some(severity) = severity {
6553                        diagnostic.severity = severity;
6554                    }
6555                    diagnostic.is_unnecessary = is_unnecessary;
6556                }
6557            }
6558        }
6559
6560        self.update_diagnostic_entries(
6561            language_server_id,
6562            abs_path,
6563            params.version,
6564            diagnostics,
6565            cx,
6566        )?;
6567        Ok(())
6568    }
6569
6570    fn insert_newly_running_language_server(
6571        &mut self,
6572        language: LanguageName,
6573        adapter: Arc<CachedLspAdapter>,
6574        language_server: Arc<LanguageServer>,
6575        server_id: LanguageServerId,
6576        key: (WorktreeId, LanguageServerName),
6577        cx: &mut ModelContext<Self>,
6578    ) {
6579        // If the language server for this key doesn't match the server id, don't store the
6580        // server. Which will cause it to be dropped, killing the process
6581        if self
6582            .language_server_ids
6583            .get(&key)
6584            .map(|id| id != &server_id)
6585            .unwrap_or(false)
6586        {
6587            return;
6588        }
6589
6590        // Update language_servers collection with Running variant of LanguageServerState
6591        // indicating that the server is up and running and ready
6592        if let Some(local) = self.as_local_mut() {
6593            local.language_servers.insert(
6594                server_id,
6595                LanguageServerState::Running {
6596                    adapter: adapter.clone(),
6597                    language: language.clone(),
6598                    server: language_server.clone(),
6599                    simulate_disk_based_diagnostics_completion: None,
6600                },
6601            );
6602        }
6603
6604        self.language_server_statuses.insert(
6605            server_id,
6606            LanguageServerStatus {
6607                name: language_server.name().to_string(),
6608                pending_work: Default::default(),
6609                has_pending_diagnostic_updates: false,
6610                progress_tokens: Default::default(),
6611            },
6612        );
6613
6614        cx.emit(LspStoreEvent::LanguageServerAdded(
6615            server_id,
6616            language_server.name(),
6617            Some(key.0),
6618        ));
6619
6620        if let Some((downstream_client, project_id)) = self.downstream_client.as_ref() {
6621            downstream_client
6622                .send(proto::StartLanguageServer {
6623                    project_id: *project_id,
6624                    server: Some(proto::LanguageServer {
6625                        id: server_id.0 as u64,
6626                        name: language_server.name().to_string(),
6627                        worktree_id: Some(key.0.to_proto()),
6628                    }),
6629                })
6630                .log_err();
6631        }
6632
6633        // Tell the language server about every open buffer in the worktree that matches the language.
6634        self.buffer_store.update(cx, |buffer_store, cx| {
6635            for buffer_handle in buffer_store.buffers() {
6636                let buffer = buffer_handle.read(cx);
6637                let file = match File::from_dyn(buffer.file()) {
6638                    Some(file) => file,
6639                    None => continue,
6640                };
6641                let language = match buffer.language() {
6642                    Some(language) => language,
6643                    None => continue,
6644                };
6645
6646                if file.worktree.read(cx).id() != key.0
6647                    || !self
6648                        .languages
6649                        .lsp_adapters(&language.name())
6650                        .iter()
6651                        .any(|a| a.name == key.1)
6652                {
6653                    continue;
6654                }
6655
6656                let file = match file.as_local() {
6657                    Some(file) => file,
6658                    None => continue,
6659                };
6660
6661                let versions = self
6662                    .buffer_snapshots
6663                    .entry(buffer.remote_id())
6664                    .or_default()
6665                    .entry(server_id)
6666                    .or_insert_with(|| {
6667                        vec![LspBufferSnapshot {
6668                            version: 0,
6669                            snapshot: buffer.text_snapshot(),
6670                        }]
6671                    });
6672
6673                let snapshot = versions.last().unwrap();
6674                let version = snapshot.version;
6675                let initial_snapshot = &snapshot.snapshot;
6676                let uri = lsp::Url::from_file_path(file.abs_path(cx)).unwrap();
6677                language_server
6678                    .notify::<lsp::notification::DidOpenTextDocument>(
6679                        lsp::DidOpenTextDocumentParams {
6680                            text_document: lsp::TextDocumentItem::new(
6681                                uri,
6682                                adapter.language_id(&language.name()),
6683                                version,
6684                                initial_snapshot.text(),
6685                            ),
6686                        },
6687                    )
6688                    .log_err();
6689
6690                buffer_handle.update(cx, |buffer, cx| {
6691                    buffer.set_completion_triggers(
6692                        server_id,
6693                        language_server
6694                            .capabilities()
6695                            .completion_provider
6696                            .as_ref()
6697                            .and_then(|provider| {
6698                                provider
6699                                    .trigger_characters
6700                                    .as_ref()
6701                                    .map(|characters| characters.iter().cloned().collect())
6702                            })
6703                            .unwrap_or_default(),
6704                        cx,
6705                    )
6706                });
6707            }
6708        });
6709
6710        cx.notify();
6711    }
6712
6713    fn buffer_snapshot_for_lsp_version(
6714        &mut self,
6715        buffer: &Model<Buffer>,
6716        server_id: LanguageServerId,
6717        version: Option<i32>,
6718        cx: &AppContext,
6719    ) -> Result<TextBufferSnapshot> {
6720        const OLD_VERSIONS_TO_RETAIN: i32 = 10;
6721
6722        if let Some(version) = version {
6723            let buffer_id = buffer.read(cx).remote_id();
6724            let snapshots = self
6725                .buffer_snapshots
6726                .get_mut(&buffer_id)
6727                .and_then(|m| m.get_mut(&server_id))
6728                .ok_or_else(|| {
6729                    anyhow!("no snapshots found for buffer {buffer_id} and server {server_id}")
6730                })?;
6731
6732            let found_snapshot = snapshots
6733                    .binary_search_by_key(&version, |e| e.version)
6734                    .map(|ix| snapshots[ix].snapshot.clone())
6735                    .map_err(|_| {
6736                        anyhow!("snapshot not found for buffer {buffer_id} server {server_id} at version {version}")
6737                    })?;
6738
6739            snapshots.retain(|snapshot| snapshot.version + OLD_VERSIONS_TO_RETAIN >= version);
6740            Ok(found_snapshot)
6741        } else {
6742            Ok((buffer.read(cx)).text_snapshot())
6743        }
6744    }
6745
6746    pub fn language_servers_running_disk_based_diagnostics(
6747        &self,
6748    ) -> impl Iterator<Item = LanguageServerId> + '_ {
6749        self.language_server_statuses
6750            .iter()
6751            .filter_map(|(id, status)| {
6752                if status.has_pending_diagnostic_updates {
6753                    Some(*id)
6754                } else {
6755                    None
6756                }
6757            })
6758    }
6759
6760    pub(crate) fn language_servers_for_buffer<'a>(
6761        &'a self,
6762        buffer: &'a Buffer,
6763        cx: &'a AppContext,
6764    ) -> impl Iterator<Item = (&'a Arc<CachedLspAdapter>, &'a Arc<LanguageServer>)> {
6765        self.language_server_ids_for_buffer(buffer, cx)
6766            .into_iter()
6767            .filter_map(
6768                |server_id| match self.as_local()?.language_servers.get(&server_id)? {
6769                    LanguageServerState::Running {
6770                        adapter, server, ..
6771                    } => Some((adapter, server)),
6772                    _ => None,
6773                },
6774            )
6775    }
6776
6777    pub(crate) fn cancel_language_server_work_for_buffers(
6778        &mut self,
6779        buffers: impl IntoIterator<Item = Model<Buffer>>,
6780        cx: &mut ModelContext<Self>,
6781    ) {
6782        if let Some((client, project_id)) = self.upstream_client() {
6783            let request = client.request(proto::CancelLanguageServerWork {
6784                project_id,
6785                work: Some(proto::cancel_language_server_work::Work::Buffers(
6786                    proto::cancel_language_server_work::Buffers {
6787                        buffer_ids: buffers
6788                            .into_iter()
6789                            .map(|b| b.read(cx).remote_id().to_proto())
6790                            .collect(),
6791                    },
6792                )),
6793            });
6794            cx.background_executor()
6795                .spawn(request)
6796                .detach_and_log_err(cx);
6797        } else {
6798            let servers = buffers
6799                .into_iter()
6800                .flat_map(|buffer| {
6801                    self.language_server_ids_for_buffer(buffer.read(cx), cx)
6802                        .into_iter()
6803                })
6804                .collect::<HashSet<_>>();
6805
6806            for server_id in servers {
6807                self.cancel_language_server_work(server_id, None, cx);
6808            }
6809        }
6810    }
6811
6812    pub(crate) fn cancel_language_server_work(
6813        &mut self,
6814        server_id: LanguageServerId,
6815        token_to_cancel: Option<String>,
6816        cx: &mut ModelContext<Self>,
6817    ) {
6818        if let Some(local) = self.as_local() {
6819            let status = self.language_server_statuses.get(&server_id);
6820            let server = local.language_servers.get(&server_id);
6821            if let Some((LanguageServerState::Running { server, .. }, status)) = server.zip(status)
6822            {
6823                for (token, progress) in &status.pending_work {
6824                    if let Some(token_to_cancel) = token_to_cancel.as_ref() {
6825                        if token != token_to_cancel {
6826                            continue;
6827                        }
6828                    }
6829                    if progress.is_cancellable {
6830                        server
6831                            .notify::<lsp::notification::WorkDoneProgressCancel>(
6832                                WorkDoneProgressCancelParams {
6833                                    token: lsp::NumberOrString::String(token.clone()),
6834                                },
6835                            )
6836                            .ok();
6837                    }
6838
6839                    if progress.is_cancellable {
6840                        server
6841                            .notify::<lsp::notification::WorkDoneProgressCancel>(
6842                                WorkDoneProgressCancelParams {
6843                                    token: lsp::NumberOrString::String(token.clone()),
6844                                },
6845                            )
6846                            .ok();
6847                    }
6848                }
6849            }
6850        } else if let Some((client, project_id)) = self.upstream_client() {
6851            let request = client.request(proto::CancelLanguageServerWork {
6852                project_id,
6853                work: Some(
6854                    proto::cancel_language_server_work::Work::LanguageServerWork(
6855                        proto::cancel_language_server_work::LanguageServerWork {
6856                            language_server_id: server_id.to_proto(),
6857                            token: token_to_cancel,
6858                        },
6859                    ),
6860                ),
6861            });
6862            cx.background_executor()
6863                .spawn(request)
6864                .detach_and_log_err(cx);
6865        }
6866    }
6867
6868    pub fn language_servers(
6869        &self,
6870    ) -> impl '_ + Iterator<Item = (LanguageServerId, LanguageServerName, WorktreeId)> {
6871        self.language_server_ids
6872            .iter()
6873            .map(|((worktree_id, server_name), server_id)| {
6874                (*server_id, server_name.clone(), *worktree_id)
6875            })
6876    }
6877
6878    fn register_supplementary_language_server(
6879        &mut self,
6880        id: LanguageServerId,
6881        name: LanguageServerName,
6882        server: Arc<LanguageServer>,
6883        cx: &mut ModelContext<Self>,
6884    ) {
6885        if let Some(local) = self.as_local_mut() {
6886            local
6887                .supplementary_language_servers
6888                .insert(id, (name.clone(), server));
6889            cx.emit(LspStoreEvent::LanguageServerAdded(id, name, None));
6890        }
6891    }
6892
6893    fn unregister_supplementary_language_server(
6894        &mut self,
6895        id: LanguageServerId,
6896        cx: &mut ModelContext<Self>,
6897    ) {
6898        if let Some(local) = self.as_local_mut() {
6899            local.supplementary_language_servers.remove(&id);
6900            cx.emit(LspStoreEvent::LanguageServerRemoved(id));
6901        }
6902    }
6903
6904    pub fn supplementary_language_servers(
6905        &self,
6906    ) -> impl '_ + Iterator<Item = (LanguageServerId, LanguageServerName)> {
6907        self.as_local().into_iter().flat_map(|local| {
6908            local
6909                .supplementary_language_servers
6910                .iter()
6911                .map(|(id, (name, _))| (*id, name.clone()))
6912        })
6913    }
6914
6915    pub fn language_server_adapter_for_id(
6916        &self,
6917        id: LanguageServerId,
6918    ) -> Option<Arc<CachedLspAdapter>> {
6919        self.as_local()
6920            .and_then(|local| local.language_servers.get(&id))
6921            .and_then(|language_server_state| match language_server_state {
6922                LanguageServerState::Running { adapter, .. } => Some(adapter.clone()),
6923                _ => None,
6924            })
6925    }
6926
6927    pub(super) fn update_local_worktree_language_servers(
6928        &mut self,
6929        worktree_handle: &Model<Worktree>,
6930        changes: &[(Arc<Path>, ProjectEntryId, PathChange)],
6931        cx: &mut ModelContext<Self>,
6932    ) {
6933        if changes.is_empty() {
6934            return;
6935        }
6936
6937        let Some(local) = self.as_local() else { return };
6938
6939        local.prettier_store.update(cx, |prettier_store, cx| {
6940            prettier_store.update_prettier_settings(&worktree_handle, changes, cx)
6941        });
6942
6943        let worktree_id = worktree_handle.read(cx).id();
6944        let mut language_server_ids = self
6945            .language_server_ids
6946            .iter()
6947            .filter_map(|((server_worktree_id, _), server_id)| {
6948                (*server_worktree_id == worktree_id).then_some(*server_id)
6949            })
6950            .collect::<Vec<_>>();
6951        language_server_ids.sort();
6952        language_server_ids.dedup();
6953
6954        let abs_path = worktree_handle.read(cx).abs_path();
6955        for server_id in &language_server_ids {
6956            if let Some(LanguageServerState::Running { server, .. }) =
6957                local.language_servers.get(server_id)
6958            {
6959                if let Some(watched_paths) = local
6960                    .language_server_watched_paths
6961                    .get(server_id)
6962                    .and_then(|paths| paths.read(cx).worktree_paths.get(&worktree_id))
6963                {
6964                    let params = lsp::DidChangeWatchedFilesParams {
6965                        changes: changes
6966                            .iter()
6967                            .filter_map(|(path, _, change)| {
6968                                if !watched_paths.is_match(path) {
6969                                    return None;
6970                                }
6971                                let typ = match change {
6972                                    PathChange::Loaded => return None,
6973                                    PathChange::Added => lsp::FileChangeType::CREATED,
6974                                    PathChange::Removed => lsp::FileChangeType::DELETED,
6975                                    PathChange::Updated => lsp::FileChangeType::CHANGED,
6976                                    PathChange::AddedOrUpdated => lsp::FileChangeType::CHANGED,
6977                                };
6978                                Some(lsp::FileEvent {
6979                                    uri: lsp::Url::from_file_path(abs_path.join(path)).unwrap(),
6980                                    typ,
6981                                })
6982                            })
6983                            .collect(),
6984                    };
6985                    if !params.changes.is_empty() {
6986                        server
6987                            .notify::<lsp::notification::DidChangeWatchedFiles>(params)
6988                            .log_err();
6989                    }
6990                }
6991            }
6992        }
6993    }
6994
6995    pub fn wait_for_remote_buffer(
6996        &mut self,
6997        id: BufferId,
6998        cx: &mut ModelContext<Self>,
6999    ) -> Task<Result<Model<Buffer>>> {
7000        self.buffer_store.update(cx, |buffer_store, cx| {
7001            buffer_store.wait_for_remote_buffer(id, cx)
7002        })
7003    }
7004
7005    pub(crate) fn language_server_ids_for_buffer(
7006        &self,
7007        buffer: &Buffer,
7008        cx: &AppContext,
7009    ) -> Vec<LanguageServerId> {
7010        if let Some((file, language)) = File::from_dyn(buffer.file()).zip(buffer.language()) {
7011            let worktree_id = file.worktree_id(cx);
7012            self.languages
7013                .lsp_adapters(&language.name())
7014                .iter()
7015                .flat_map(|adapter| {
7016                    let key = (worktree_id, adapter.name.clone());
7017                    self.language_server_ids.get(&key).copied()
7018                })
7019                .collect()
7020        } else {
7021            Vec::new()
7022        }
7023    }
7024
7025    pub async fn deserialize_text_edits(
7026        this: Model<Self>,
7027        buffer_to_edit: Model<Buffer>,
7028        edits: Vec<lsp::TextEdit>,
7029        push_to_history: bool,
7030        _: Arc<CachedLspAdapter>,
7031        language_server: Arc<LanguageServer>,
7032        cx: &mut AsyncAppContext,
7033    ) -> Result<Option<Transaction>> {
7034        let edits = this
7035            .update(cx, |this, cx| {
7036                this.edits_from_lsp(
7037                    &buffer_to_edit,
7038                    edits,
7039                    language_server.server_id(),
7040                    None,
7041                    cx,
7042                )
7043            })?
7044            .await?;
7045
7046        let transaction = buffer_to_edit.update(cx, |buffer, cx| {
7047            buffer.finalize_last_transaction();
7048            buffer.start_transaction();
7049            for (range, text) in edits {
7050                buffer.edit([(range, text)], None, cx);
7051            }
7052
7053            if buffer.end_transaction(cx).is_some() {
7054                let transaction = buffer.finalize_last_transaction().unwrap().clone();
7055                if !push_to_history {
7056                    buffer.forget_transaction(transaction.id);
7057                }
7058                Some(transaction)
7059            } else {
7060                None
7061            }
7062        })?;
7063
7064        Ok(transaction)
7065    }
7066
7067    pub async fn deserialize_workspace_edit(
7068        this: Model<Self>,
7069        edit: lsp::WorkspaceEdit,
7070        push_to_history: bool,
7071        lsp_adapter: Arc<CachedLspAdapter>,
7072        language_server: Arc<LanguageServer>,
7073        cx: &mut AsyncAppContext,
7074    ) -> Result<ProjectTransaction> {
7075        let fs = this.read_with(cx, |this, _| this.as_local().unwrap().fs.clone())?;
7076
7077        let mut operations = Vec::new();
7078        if let Some(document_changes) = edit.document_changes {
7079            match document_changes {
7080                lsp::DocumentChanges::Edits(edits) => {
7081                    operations.extend(edits.into_iter().map(lsp::DocumentChangeOperation::Edit))
7082                }
7083                lsp::DocumentChanges::Operations(ops) => operations = ops,
7084            }
7085        } else if let Some(changes) = edit.changes {
7086            operations.extend(changes.into_iter().map(|(uri, edits)| {
7087                lsp::DocumentChangeOperation::Edit(lsp::TextDocumentEdit {
7088                    text_document: lsp::OptionalVersionedTextDocumentIdentifier {
7089                        uri,
7090                        version: None,
7091                    },
7092                    edits: edits.into_iter().map(Edit::Plain).collect(),
7093                })
7094            }));
7095        }
7096
7097        let mut project_transaction = ProjectTransaction::default();
7098        for operation in operations {
7099            match operation {
7100                lsp::DocumentChangeOperation::Op(lsp::ResourceOp::Create(op)) => {
7101                    let abs_path = op
7102                        .uri
7103                        .to_file_path()
7104                        .map_err(|_| anyhow!("can't convert URI to path"))?;
7105
7106                    if let Some(parent_path) = abs_path.parent() {
7107                        fs.create_dir(parent_path).await?;
7108                    }
7109                    if abs_path.ends_with("/") {
7110                        fs.create_dir(&abs_path).await?;
7111                    } else {
7112                        fs.create_file(
7113                            &abs_path,
7114                            op.options
7115                                .map(|options| fs::CreateOptions {
7116                                    overwrite: options.overwrite.unwrap_or(false),
7117                                    ignore_if_exists: options.ignore_if_exists.unwrap_or(false),
7118                                })
7119                                .unwrap_or_default(),
7120                        )
7121                        .await?;
7122                    }
7123                }
7124
7125                lsp::DocumentChangeOperation::Op(lsp::ResourceOp::Rename(op)) => {
7126                    let source_abs_path = op
7127                        .old_uri
7128                        .to_file_path()
7129                        .map_err(|_| anyhow!("can't convert URI to path"))?;
7130                    let target_abs_path = op
7131                        .new_uri
7132                        .to_file_path()
7133                        .map_err(|_| anyhow!("can't convert URI to path"))?;
7134                    fs.rename(
7135                        &source_abs_path,
7136                        &target_abs_path,
7137                        op.options
7138                            .map(|options| fs::RenameOptions {
7139                                overwrite: options.overwrite.unwrap_or(false),
7140                                ignore_if_exists: options.ignore_if_exists.unwrap_or(false),
7141                            })
7142                            .unwrap_or_default(),
7143                    )
7144                    .await?;
7145                }
7146
7147                lsp::DocumentChangeOperation::Op(lsp::ResourceOp::Delete(op)) => {
7148                    let abs_path = op
7149                        .uri
7150                        .to_file_path()
7151                        .map_err(|_| anyhow!("can't convert URI to path"))?;
7152                    let options = op
7153                        .options
7154                        .map(|options| fs::RemoveOptions {
7155                            recursive: options.recursive.unwrap_or(false),
7156                            ignore_if_not_exists: options.ignore_if_not_exists.unwrap_or(false),
7157                        })
7158                        .unwrap_or_default();
7159                    if abs_path.ends_with("/") {
7160                        fs.remove_dir(&abs_path, options).await?;
7161                    } else {
7162                        fs.remove_file(&abs_path, options).await?;
7163                    }
7164                }
7165
7166                lsp::DocumentChangeOperation::Edit(op) => {
7167                    let buffer_to_edit = this
7168                        .update(cx, |this, cx| {
7169                            this.open_local_buffer_via_lsp(
7170                                op.text_document.uri.clone(),
7171                                language_server.server_id(),
7172                                lsp_adapter.name.clone(),
7173                                cx,
7174                            )
7175                        })?
7176                        .await?;
7177
7178                    let edits = this
7179                        .update(cx, |this, cx| {
7180                            let path = buffer_to_edit.read(cx).project_path(cx);
7181                            let active_entry = this.active_entry;
7182                            let is_active_entry = path.clone().map_or(false, |project_path| {
7183                                this.worktree_store
7184                                    .read(cx)
7185                                    .entry_for_path(&project_path, cx)
7186                                    .map_or(false, |entry| Some(entry.id) == active_entry)
7187                            });
7188
7189                            let (mut edits, mut snippet_edits) = (vec![], vec![]);
7190                            for edit in op.edits {
7191                                match edit {
7192                                    Edit::Plain(edit) => edits.push(edit),
7193                                    Edit::Annotated(edit) => edits.push(edit.text_edit),
7194                                    Edit::Snippet(edit) => {
7195                                        let Ok(snippet) = Snippet::parse(&edit.snippet.value)
7196                                        else {
7197                                            continue;
7198                                        };
7199
7200                                        if is_active_entry {
7201                                            snippet_edits.push((edit.range, snippet));
7202                                        } else {
7203                                            // Since this buffer is not focused, apply a normal edit.
7204                                            edits.push(TextEdit {
7205                                                range: edit.range,
7206                                                new_text: snippet.text,
7207                                            });
7208                                        }
7209                                    }
7210                                }
7211                            }
7212                            if !snippet_edits.is_empty() {
7213                                let buffer_id = buffer_to_edit.read(cx).remote_id();
7214                                let version = if let Some(buffer_version) = op.text_document.version
7215                                {
7216                                    this.buffer_snapshot_for_lsp_version(
7217                                        &buffer_to_edit,
7218                                        language_server.server_id(),
7219                                        Some(buffer_version),
7220                                        cx,
7221                                    )
7222                                    .ok()
7223                                    .map(|snapshot| snapshot.version)
7224                                } else {
7225                                    Some(buffer_to_edit.read(cx).saved_version().clone())
7226                                };
7227
7228                                let most_recent_edit = version.and_then(|version| {
7229                                    version.iter().max_by_key(|timestamp| timestamp.value)
7230                                });
7231                                // Check if the edit that triggered that edit has been made by this participant.
7232
7233                                if let Some(most_recent_edit) = most_recent_edit {
7234                                    cx.emit(LspStoreEvent::SnippetEdit {
7235                                        buffer_id,
7236                                        edits: snippet_edits,
7237                                        most_recent_edit,
7238                                    });
7239                                }
7240                            }
7241
7242                            this.edits_from_lsp(
7243                                &buffer_to_edit,
7244                                edits,
7245                                language_server.server_id(),
7246                                op.text_document.version,
7247                                cx,
7248                            )
7249                        })?
7250                        .await?;
7251
7252                    let transaction = buffer_to_edit.update(cx, |buffer, cx| {
7253                        buffer.finalize_last_transaction();
7254                        buffer.start_transaction();
7255                        for (range, text) in edits {
7256                            buffer.edit([(range, text)], None, cx);
7257                        }
7258                        let transaction = if buffer.end_transaction(cx).is_some() {
7259                            let transaction = buffer.finalize_last_transaction().unwrap().clone();
7260                            if !push_to_history {
7261                                buffer.forget_transaction(transaction.id);
7262                            }
7263                            Some(transaction)
7264                        } else {
7265                            None
7266                        };
7267
7268                        transaction
7269                    })?;
7270                    if let Some(transaction) = transaction {
7271                        project_transaction.0.insert(buffer_to_edit, transaction);
7272                    }
7273                }
7274            }
7275        }
7276
7277        Ok(project_transaction)
7278    }
7279
7280    fn serialize_symbol(symbol: &Symbol) -> proto::Symbol {
7281        proto::Symbol {
7282            language_server_name: symbol.language_server_name.0.to_string(),
7283            source_worktree_id: symbol.source_worktree_id.to_proto(),
7284            worktree_id: symbol.path.worktree_id.to_proto(),
7285            path: symbol.path.path.to_string_lossy().to_string(),
7286            name: symbol.name.clone(),
7287            kind: unsafe { mem::transmute::<lsp::SymbolKind, i32>(symbol.kind) },
7288            start: Some(proto::PointUtf16 {
7289                row: symbol.range.start.0.row,
7290                column: symbol.range.start.0.column,
7291            }),
7292            end: Some(proto::PointUtf16 {
7293                row: symbol.range.end.0.row,
7294                column: symbol.range.end.0.column,
7295            }),
7296            signature: symbol.signature.to_vec(),
7297        }
7298    }
7299
7300    fn deserialize_symbol(serialized_symbol: proto::Symbol) -> Result<CoreSymbol> {
7301        let source_worktree_id = WorktreeId::from_proto(serialized_symbol.source_worktree_id);
7302        let worktree_id = WorktreeId::from_proto(serialized_symbol.worktree_id);
7303        let kind = unsafe { mem::transmute::<i32, lsp::SymbolKind>(serialized_symbol.kind) };
7304        let path = ProjectPath {
7305            worktree_id,
7306            path: PathBuf::from(serialized_symbol.path).into(),
7307        };
7308
7309        let start = serialized_symbol
7310            .start
7311            .ok_or_else(|| anyhow!("invalid start"))?;
7312        let end = serialized_symbol
7313            .end
7314            .ok_or_else(|| anyhow!("invalid end"))?;
7315        Ok(CoreSymbol {
7316            language_server_name: LanguageServerName(serialized_symbol.language_server_name.into()),
7317            source_worktree_id,
7318            path,
7319            name: serialized_symbol.name,
7320            range: Unclipped(PointUtf16::new(start.row, start.column))
7321                ..Unclipped(PointUtf16::new(end.row, end.column)),
7322            kind,
7323            signature: serialized_symbol
7324                .signature
7325                .try_into()
7326                .map_err(|_| anyhow!("invalid signature"))?,
7327        })
7328    }
7329
7330    pub(crate) fn serialize_completion(completion: &CoreCompletion) -> proto::Completion {
7331        proto::Completion {
7332            old_start: Some(serialize_anchor(&completion.old_range.start)),
7333            old_end: Some(serialize_anchor(&completion.old_range.end)),
7334            new_text: completion.new_text.clone(),
7335            server_id: completion.server_id.0 as u64,
7336            lsp_completion: serde_json::to_vec(&completion.lsp_completion).unwrap(),
7337        }
7338    }
7339
7340    pub(crate) fn deserialize_completion(completion: proto::Completion) -> Result<CoreCompletion> {
7341        let old_start = completion
7342            .old_start
7343            .and_then(deserialize_anchor)
7344            .ok_or_else(|| anyhow!("invalid old start"))?;
7345        let old_end = completion
7346            .old_end
7347            .and_then(deserialize_anchor)
7348            .ok_or_else(|| anyhow!("invalid old end"))?;
7349        let lsp_completion = serde_json::from_slice(&completion.lsp_completion)?;
7350
7351        Ok(CoreCompletion {
7352            old_range: old_start..old_end,
7353            new_text: completion.new_text,
7354            server_id: LanguageServerId(completion.server_id as usize),
7355            lsp_completion,
7356        })
7357    }
7358
7359    pub(crate) fn serialize_code_action(action: &CodeAction) -> proto::CodeAction {
7360        proto::CodeAction {
7361            server_id: action.server_id.0 as u64,
7362            start: Some(serialize_anchor(&action.range.start)),
7363            end: Some(serialize_anchor(&action.range.end)),
7364            lsp_action: serde_json::to_vec(&action.lsp_action).unwrap(),
7365        }
7366    }
7367
7368    pub(crate) fn deserialize_code_action(action: proto::CodeAction) -> Result<CodeAction> {
7369        let start = action
7370            .start
7371            .and_then(deserialize_anchor)
7372            .ok_or_else(|| anyhow!("invalid start"))?;
7373        let end = action
7374            .end
7375            .and_then(deserialize_anchor)
7376            .ok_or_else(|| anyhow!("invalid end"))?;
7377        let lsp_action = serde_json::from_slice(&action.lsp_action)?;
7378        Ok(CodeAction {
7379            server_id: LanguageServerId(action.server_id as usize),
7380            range: start..end,
7381            lsp_action,
7382        })
7383    }
7384
7385    fn update_last_formatting_failure<T>(&mut self, formatting_result: &anyhow::Result<T>) {
7386        match &formatting_result {
7387            Ok(_) => self.last_formatting_failure = None,
7388            Err(error) => {
7389                let error_string = format!("{error:#}");
7390                log::error!("Formatting failed: {error_string}");
7391                self.last_formatting_failure
7392                    .replace(error_string.lines().join(" "));
7393            }
7394        }
7395    }
7396}
7397
7398impl EventEmitter<LspStoreEvent> for LspStore {}
7399
7400fn remove_empty_hover_blocks(mut hover: Hover) -> Option<Hover> {
7401    hover
7402        .contents
7403        .retain(|hover_block| !hover_block.text.trim().is_empty());
7404    if hover.contents.is_empty() {
7405        None
7406    } else {
7407        Some(hover)
7408    }
7409}
7410
7411async fn populate_labels_for_completions(
7412    mut new_completions: Vec<CoreCompletion>,
7413    language_registry: &Arc<LanguageRegistry>,
7414    language: Option<Arc<Language>>,
7415    lsp_adapter: Option<Arc<CachedLspAdapter>>,
7416    completions: &mut Vec<Completion>,
7417) {
7418    let lsp_completions = new_completions
7419        .iter_mut()
7420        .map(|completion| mem::take(&mut completion.lsp_completion))
7421        .collect::<Vec<_>>();
7422
7423    let labels = if let Some((language, lsp_adapter)) = language.as_ref().zip(lsp_adapter) {
7424        lsp_adapter
7425            .labels_for_completions(&lsp_completions, language)
7426            .await
7427            .log_err()
7428            .unwrap_or_default()
7429    } else {
7430        Vec::new()
7431    };
7432
7433    for ((completion, lsp_completion), label) in new_completions
7434        .into_iter()
7435        .zip(lsp_completions)
7436        .zip(labels.into_iter().chain(iter::repeat(None)))
7437    {
7438        let documentation = if let Some(docs) = &lsp_completion.documentation {
7439            Some(prepare_completion_documentation(docs, language_registry, language.clone()).await)
7440        } else {
7441            None
7442        };
7443
7444        completions.push(Completion {
7445            old_range: completion.old_range,
7446            new_text: completion.new_text,
7447            label: label.unwrap_or_else(|| {
7448                CodeLabel::plain(
7449                    lsp_completion.label.clone(),
7450                    lsp_completion.filter_text.as_deref(),
7451                )
7452            }),
7453            server_id: completion.server_id,
7454            documentation,
7455            lsp_completion,
7456            confirm: None,
7457        })
7458    }
7459}
7460
7461#[derive(Debug)]
7462pub enum LanguageServerToQuery {
7463    Primary,
7464    Other(LanguageServerId),
7465}
7466
7467#[derive(Default)]
7468struct LanguageServerWatchedPaths {
7469    worktree_paths: HashMap<WorktreeId, GlobSet>,
7470    abs_paths: HashMap<Arc<Path>, (GlobSet, Task<()>)>,
7471}
7472
7473#[derive(Default)]
7474struct LanguageServerWatchedPathsBuilder {
7475    worktree_paths: HashMap<WorktreeId, GlobSet>,
7476    abs_paths: HashMap<Arc<Path>, GlobSet>,
7477}
7478
7479impl LanguageServerWatchedPathsBuilder {
7480    fn watch_worktree(&mut self, worktree_id: WorktreeId, glob_set: GlobSet) {
7481        self.worktree_paths.insert(worktree_id, glob_set);
7482    }
7483    fn watch_abs_path(&mut self, path: Arc<Path>, glob_set: GlobSet) {
7484        self.abs_paths.insert(path, glob_set);
7485    }
7486    fn build(
7487        self,
7488        fs: Arc<dyn Fs>,
7489        language_server_id: LanguageServerId,
7490        cx: &mut ModelContext<LspStore>,
7491    ) -> Model<LanguageServerWatchedPaths> {
7492        let project = cx.weak_model();
7493
7494        cx.new_model(|cx| {
7495                let this_id = cx.entity_id();
7496                const LSP_ABS_PATH_OBSERVE: Duration = Duration::from_millis(100);
7497                let abs_paths = self
7498                    .abs_paths
7499                    .into_iter()
7500                    .map(|(abs_path, globset)| {
7501                        let task = cx.spawn({
7502                            let abs_path = abs_path.clone();
7503                            let fs = fs.clone();
7504
7505                            let lsp_store = project.clone();
7506                            |_, mut cx| async move {
7507                                maybe!(async move {
7508                                    let mut push_updates =
7509                                        fs.watch(&abs_path, LSP_ABS_PATH_OBSERVE).await;
7510                                    while let Some(update) = push_updates.0.next().await {
7511                                        let action = lsp_store
7512                                            .update(&mut cx, |this, cx| {
7513                                                let Some(local) = this.as_local() else {
7514                                                    return ControlFlow::Break(());
7515                                                };
7516                                                let Some(watcher) = local
7517                                                    .language_server_watched_paths
7518                                                    .get(&language_server_id)
7519                                                else {
7520                                                    return ControlFlow::Break(());
7521                                                };
7522                                                if watcher.entity_id() != this_id {
7523                                                    // This watcher is no longer registered on the project, which means that we should
7524                                                    // cease operations.
7525                                                    return ControlFlow::Break(());
7526                                                }
7527                                                let (globs, _) = watcher
7528                                                    .read(cx)
7529                                                    .abs_paths
7530                                                    .get(&abs_path)
7531                                                    .expect(
7532                                                    "Watched abs path is not registered with a watcher",
7533                                                );
7534                                                let matching_entries = update
7535                                                    .into_iter()
7536                                                    .filter(|event| globs.is_match(&event.path))
7537                                                    .collect::<Vec<_>>();
7538                                                this.lsp_notify_abs_paths_changed(
7539                                                    language_server_id,
7540                                                    matching_entries,
7541                                                );
7542                                                ControlFlow::Continue(())
7543                                            })
7544                                            .ok()?;
7545
7546                                        if action.is_break() {
7547                                            break;
7548                                        }
7549                                    }
7550                                    Some(())
7551                                })
7552                                    .await;
7553                            }
7554                        });
7555                        (abs_path, (globset, task))
7556                    })
7557                    .collect();
7558                LanguageServerWatchedPaths {
7559                    worktree_paths: self.worktree_paths,
7560                    abs_paths,
7561                }
7562            })
7563    }
7564}
7565
7566struct LspBufferSnapshot {
7567    version: i32,
7568    snapshot: TextBufferSnapshot,
7569}
7570
7571/// A prompt requested by LSP server.
7572#[derive(Clone, Debug)]
7573pub struct LanguageServerPromptRequest {
7574    pub level: PromptLevel,
7575    pub message: String,
7576    pub actions: Vec<MessageActionItem>,
7577    pub lsp_name: String,
7578    pub(crate) response_channel: Sender<MessageActionItem>,
7579}
7580
7581impl LanguageServerPromptRequest {
7582    pub async fn respond(self, index: usize) -> Option<()> {
7583        if let Some(response) = self.actions.into_iter().nth(index) {
7584            self.response_channel.send(response).await.ok()
7585        } else {
7586            None
7587        }
7588    }
7589}
7590impl PartialEq for LanguageServerPromptRequest {
7591    fn eq(&self, other: &Self) -> bool {
7592        self.message == other.message && self.actions == other.actions
7593    }
7594}
7595
7596#[derive(Clone, Debug, PartialEq)]
7597pub enum LanguageServerLogType {
7598    Log(MessageType),
7599    Trace(Option<String>),
7600}
7601
7602impl LanguageServerLogType {
7603    pub fn to_proto(&self) -> proto::language_server_log::LogType {
7604        match self {
7605            Self::Log(log_type) => {
7606                let message_type = match *log_type {
7607                    MessageType::ERROR => 1,
7608                    MessageType::WARNING => 2,
7609                    MessageType::INFO => 3,
7610                    MessageType::LOG => 4,
7611                    other => {
7612                        log::warn!("Unknown lsp log message type: {:?}", other);
7613                        4
7614                    }
7615                };
7616                proto::language_server_log::LogType::LogMessageType(message_type)
7617            }
7618            Self::Trace(message) => {
7619                proto::language_server_log::LogType::LogTrace(proto::LspLogTrace {
7620                    message: message.clone(),
7621                })
7622            }
7623        }
7624    }
7625
7626    pub fn from_proto(log_type: proto::language_server_log::LogType) -> Self {
7627        match log_type {
7628            proto::language_server_log::LogType::LogMessageType(message_type) => {
7629                Self::Log(match message_type {
7630                    1 => MessageType::ERROR,
7631                    2 => MessageType::WARNING,
7632                    3 => MessageType::INFO,
7633                    4 => MessageType::LOG,
7634                    _ => MessageType::LOG,
7635                })
7636            }
7637            proto::language_server_log::LogType::LogTrace(trace) => Self::Trace(trace.message),
7638        }
7639    }
7640}
7641
7642pub enum LanguageServerState {
7643    Starting(Task<Option<Arc<LanguageServer>>>),
7644
7645    Running {
7646        language: LanguageName,
7647        adapter: Arc<CachedLspAdapter>,
7648        server: Arc<LanguageServer>,
7649        simulate_disk_based_diagnostics_completion: Option<Task<()>>,
7650    },
7651}
7652
7653impl std::fmt::Debug for LanguageServerState {
7654    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7655        match self {
7656            LanguageServerState::Starting(_) => {
7657                f.debug_struct("LanguageServerState::Starting").finish()
7658            }
7659            LanguageServerState::Running { language, .. } => f
7660                .debug_struct("LanguageServerState::Running")
7661                .field("language", &language)
7662                .finish(),
7663        }
7664    }
7665}
7666
7667#[derive(Clone, Debug, Serialize)]
7668pub struct LanguageServerProgress {
7669    pub is_disk_based_diagnostics_progress: bool,
7670    pub is_cancellable: bool,
7671    pub title: Option<String>,
7672    pub message: Option<String>,
7673    pub percentage: Option<usize>,
7674    #[serde(skip_serializing)]
7675    pub last_update_at: Instant,
7676}
7677
7678#[derive(Copy, Clone, Debug, Default, PartialEq, Serialize)]
7679pub struct DiagnosticSummary {
7680    pub error_count: usize,
7681    pub warning_count: usize,
7682}
7683
7684impl DiagnosticSummary {
7685    pub fn new<'a, T: 'a>(diagnostics: impl IntoIterator<Item = &'a DiagnosticEntry<T>>) -> Self {
7686        let mut this = Self {
7687            error_count: 0,
7688            warning_count: 0,
7689        };
7690
7691        for entry in diagnostics {
7692            if entry.diagnostic.is_primary {
7693                match entry.diagnostic.severity {
7694                    DiagnosticSeverity::ERROR => this.error_count += 1,
7695                    DiagnosticSeverity::WARNING => this.warning_count += 1,
7696                    _ => {}
7697                }
7698            }
7699        }
7700
7701        this
7702    }
7703
7704    pub fn is_empty(&self) -> bool {
7705        self.error_count == 0 && self.warning_count == 0
7706    }
7707
7708    pub fn to_proto(
7709        &self,
7710        language_server_id: LanguageServerId,
7711        path: &Path,
7712    ) -> proto::DiagnosticSummary {
7713        proto::DiagnosticSummary {
7714            path: path.to_string_lossy().to_string(),
7715            language_server_id: language_server_id.0 as u64,
7716            error_count: self.error_count as u32,
7717            warning_count: self.warning_count as u32,
7718        }
7719    }
7720}
7721
7722fn glob_literal_prefix(glob: &str) -> &str {
7723    let is_absolute = glob.starts_with(path::MAIN_SEPARATOR);
7724
7725    let mut literal_end = is_absolute as usize;
7726    for (i, part) in glob.split(path::MAIN_SEPARATOR).enumerate() {
7727        if part.contains(['*', '?', '{', '}']) {
7728            break;
7729        } else {
7730            if i > 0 {
7731                // Account for separator prior to this part
7732                literal_end += path::MAIN_SEPARATOR.len_utf8();
7733            }
7734            literal_end += part.len();
7735        }
7736    }
7737    let literal_end = literal_end.min(glob.len());
7738    &glob[..literal_end]
7739}
7740
7741pub struct SshLspAdapter {
7742    name: LanguageServerName,
7743    binary: LanguageServerBinary,
7744    initialization_options: Option<String>,
7745    code_action_kinds: Option<Vec<CodeActionKind>>,
7746}
7747
7748impl SshLspAdapter {
7749    pub fn new(
7750        name: LanguageServerName,
7751        binary: LanguageServerBinary,
7752        initialization_options: Option<String>,
7753        code_action_kinds: Option<String>,
7754    ) -> Self {
7755        Self {
7756            name,
7757            binary,
7758            initialization_options,
7759            code_action_kinds: code_action_kinds
7760                .as_ref()
7761                .and_then(|c| serde_json::from_str(c).ok()),
7762        }
7763    }
7764}
7765
7766#[async_trait(?Send)]
7767impl LspAdapter for SshLspAdapter {
7768    fn name(&self) -> LanguageServerName {
7769        self.name.clone()
7770    }
7771
7772    async fn initialization_options(
7773        self: Arc<Self>,
7774        _: &Arc<dyn LspAdapterDelegate>,
7775    ) -> Result<Option<serde_json::Value>> {
7776        let Some(options) = &self.initialization_options else {
7777            return Ok(None);
7778        };
7779        let result = serde_json::from_str(options)?;
7780        Ok(result)
7781    }
7782
7783    fn code_action_kinds(&self) -> Option<Vec<CodeActionKind>> {
7784        self.code_action_kinds.clone()
7785    }
7786
7787    async fn check_if_user_installed(
7788        &self,
7789        _: &dyn LspAdapterDelegate,
7790        _: &AsyncAppContext,
7791    ) -> Option<LanguageServerBinary> {
7792        Some(self.binary.clone())
7793    }
7794
7795    async fn cached_server_binary(
7796        &self,
7797        _: PathBuf,
7798        _: &dyn LspAdapterDelegate,
7799    ) -> Option<LanguageServerBinary> {
7800        None
7801    }
7802
7803    async fn fetch_latest_server_version(
7804        &self,
7805        _: &dyn LspAdapterDelegate,
7806    ) -> Result<Box<dyn 'static + Send + Any>> {
7807        anyhow::bail!("SshLspAdapter does not support fetch_latest_server_version")
7808    }
7809
7810    async fn fetch_server_binary(
7811        &self,
7812        _: Box<dyn 'static + Send + Any>,
7813        _: PathBuf,
7814        _: &dyn LspAdapterDelegate,
7815    ) -> Result<LanguageServerBinary> {
7816        anyhow::bail!("SshLspAdapter does not support fetch_server_binary")
7817    }
7818}
7819
7820pub fn language_server_settings<'a, 'b: 'a>(
7821    delegate: &'a dyn LspAdapterDelegate,
7822    language: &LanguageServerName,
7823    cx: &'b AppContext,
7824) -> Option<&'a LspSettings> {
7825    ProjectSettings::get(
7826        Some(SettingsLocation {
7827            worktree_id: delegate.worktree_id(),
7828            path: delegate.worktree_root_path(),
7829        }),
7830        cx,
7831    )
7832    .lsp
7833    .get(language)
7834}
7835
7836pub struct LocalLspAdapterDelegate {
7837    lsp_store: WeakModel<LspStore>,
7838    worktree: worktree::Snapshot,
7839    fs: Arc<dyn Fs>,
7840    http_client: Arc<dyn HttpClient>,
7841    language_registry: Arc<LanguageRegistry>,
7842    load_shell_env_task: Shared<Task<Option<HashMap<String, String>>>>,
7843}
7844
7845impl LocalLspAdapterDelegate {
7846    fn for_local(
7847        lsp_store: &LspStore,
7848        worktree: &Model<Worktree>,
7849        cx: &mut ModelContext<LspStore>,
7850    ) -> Arc<Self> {
7851        let local = lsp_store
7852            .as_local()
7853            .expect("LocalLspAdapterDelegate cannot be constructed on a remote");
7854
7855        let http_client = local.http_client.clone();
7856
7857        Self::new(lsp_store, worktree, http_client, local.fs.clone(), cx)
7858    }
7859
7860    pub fn new(
7861        lsp_store: &LspStore,
7862        worktree: &Model<Worktree>,
7863        http_client: Arc<dyn HttpClient>,
7864        fs: Arc<dyn Fs>,
7865        cx: &mut ModelContext<LspStore>,
7866    ) -> Arc<Self> {
7867        let worktree_id = worktree.read(cx).id();
7868        let worktree_abs_path = worktree.read(cx).abs_path();
7869        let load_shell_env_task = if let Some(environment) =
7870            &lsp_store.as_local().map(|local| local.environment.clone())
7871        {
7872            environment.update(cx, |env, cx| {
7873                env.get_environment(Some(worktree_id), Some(worktree_abs_path), cx)
7874            })
7875        } else {
7876            Task::ready(None).shared()
7877        };
7878
7879        Arc::new(Self {
7880            lsp_store: cx.weak_model(),
7881            worktree: worktree.read(cx).snapshot(),
7882            fs,
7883            http_client,
7884            language_registry: lsp_store.languages.clone(),
7885            load_shell_env_task,
7886        })
7887    }
7888}
7889
7890#[async_trait]
7891impl LspAdapterDelegate for LocalLspAdapterDelegate {
7892    fn show_notification(&self, message: &str, cx: &mut AppContext) {
7893        self.lsp_store
7894            .update(cx, |_, cx| {
7895                cx.emit(LspStoreEvent::Notification(message.to_owned()))
7896            })
7897            .ok();
7898    }
7899
7900    fn http_client(&self) -> Arc<dyn HttpClient> {
7901        self.http_client.clone()
7902    }
7903
7904    fn worktree_id(&self) -> WorktreeId {
7905        self.worktree.id()
7906    }
7907
7908    fn worktree_root_path(&self) -> &Path {
7909        self.worktree.abs_path().as_ref()
7910    }
7911
7912    async fn shell_env(&self) -> HashMap<String, String> {
7913        let task = self.load_shell_env_task.clone();
7914        task.await.unwrap_or_default()
7915    }
7916
7917    async fn npm_package_installed_version(
7918        &self,
7919        package_name: &str,
7920    ) -> Result<Option<(PathBuf, String)>> {
7921        let local_package_directory = self.worktree_root_path();
7922        let node_modules_directory = local_package_directory.join("node_modules");
7923
7924        if let Some(version) =
7925            read_package_installed_version(node_modules_directory.clone(), package_name).await?
7926        {
7927            return Ok(Some((node_modules_directory, version)));
7928        }
7929        let Some(npm) = self.which("npm".as_ref()).await else {
7930            log::warn!(
7931                "Failed to find npm executable for {:?}",
7932                local_package_directory
7933            );
7934            return Ok(None);
7935        };
7936
7937        let env = self.shell_env().await;
7938        let output = smol::process::Command::new(&npm)
7939            .args(["root", "-g"])
7940            .envs(env)
7941            .current_dir(local_package_directory)
7942            .output()
7943            .await?;
7944        let global_node_modules =
7945            PathBuf::from(String::from_utf8_lossy(&output.stdout).to_string());
7946
7947        if let Some(version) =
7948            read_package_installed_version(global_node_modules.clone(), package_name).await?
7949        {
7950            return Ok(Some((global_node_modules, version)));
7951        }
7952        return Ok(None);
7953    }
7954
7955    #[cfg(not(target_os = "windows"))]
7956    async fn which(&self, command: &OsStr) -> Option<PathBuf> {
7957        let worktree_abs_path = self.worktree.abs_path();
7958        let shell_path = self.shell_env().await.get("PATH").cloned();
7959        which::which_in(command, shell_path.as_ref(), worktree_abs_path).ok()
7960    }
7961
7962    #[cfg(target_os = "windows")]
7963    async fn which(&self, command: &OsStr) -> Option<PathBuf> {
7964        // todo(windows) Getting the shell env variables in a current directory on Windows is more complicated than other platforms
7965        //               there isn't a 'default shell' necessarily. The closest would be the default profile on the windows terminal
7966        //               SEE: https://learn.microsoft.com/en-us/windows/terminal/customize-settings/startup
7967        which::which(command).ok()
7968    }
7969
7970    async fn try_exec(&self, command: LanguageServerBinary) -> Result<()> {
7971        let working_dir = self.worktree_root_path();
7972        let output = smol::process::Command::new(&command.path)
7973            .args(command.arguments)
7974            .envs(command.env.clone().unwrap_or_default())
7975            .current_dir(working_dir)
7976            .output()
7977            .await?;
7978
7979        if output.status.success() {
7980            return Ok(());
7981        }
7982        Err(anyhow!(
7983            "{}, stdout: {:?}, stderr: {:?}",
7984            output.status,
7985            String::from_utf8_lossy(&output.stdout),
7986            String::from_utf8_lossy(&output.stderr)
7987        ))
7988    }
7989
7990    fn update_status(
7991        &self,
7992        server_name: LanguageServerName,
7993        status: language::LanguageServerBinaryStatus,
7994    ) {
7995        self.language_registry
7996            .update_lsp_status(server_name, status);
7997    }
7998
7999    async fn language_server_download_dir(&self, name: &LanguageServerName) -> Option<Arc<Path>> {
8000        let dir = self.language_registry.language_server_download_dir(name)?;
8001
8002        if !dir.exists() {
8003            smol::fs::create_dir_all(&dir)
8004                .await
8005                .context("failed to create container directory")
8006                .log_err()?;
8007        }
8008
8009        Some(dir)
8010    }
8011
8012    async fn read_text_file(&self, path: PathBuf) -> Result<String> {
8013        let entry = self
8014            .worktree
8015            .entry_for_path(&path)
8016            .with_context(|| format!("no worktree entry for path {path:?}"))?;
8017        let abs_path = self
8018            .worktree
8019            .absolutize(&entry.path)
8020            .with_context(|| format!("cannot absolutize path {path:?}"))?;
8021
8022        self.fs.load(&abs_path).await
8023    }
8024}
8025
8026async fn populate_labels_for_symbols(
8027    symbols: Vec<CoreSymbol>,
8028    language_registry: &Arc<LanguageRegistry>,
8029    default_language: Option<LanguageName>,
8030    lsp_adapter: Option<Arc<CachedLspAdapter>>,
8031    output: &mut Vec<Symbol>,
8032) {
8033    #[allow(clippy::mutable_key_type)]
8034    let mut symbols_by_language = HashMap::<Option<Arc<Language>>, Vec<CoreSymbol>>::default();
8035
8036    let mut unknown_path = None;
8037    for symbol in symbols {
8038        let language = language_registry
8039            .language_for_file_path(&symbol.path.path)
8040            .await
8041            .ok()
8042            .or_else(|| {
8043                unknown_path.get_or_insert(symbol.path.path.clone());
8044                default_language.as_ref().and_then(|name| {
8045                    language_registry
8046                        .language_for_name(&name.0)
8047                        .now_or_never()?
8048                        .ok()
8049                })
8050            });
8051        symbols_by_language
8052            .entry(language)
8053            .or_default()
8054            .push(symbol);
8055    }
8056
8057    if let Some(unknown_path) = unknown_path {
8058        log::info!(
8059            "no language found for symbol path {}",
8060            unknown_path.display()
8061        );
8062    }
8063
8064    let mut label_params = Vec::new();
8065    for (language, mut symbols) in symbols_by_language {
8066        label_params.clear();
8067        label_params.extend(
8068            symbols
8069                .iter_mut()
8070                .map(|symbol| (mem::take(&mut symbol.name), symbol.kind)),
8071        );
8072
8073        let mut labels = Vec::new();
8074        if let Some(language) = language {
8075            let lsp_adapter = lsp_adapter.clone().or_else(|| {
8076                language_registry
8077                    .lsp_adapters(&language.name())
8078                    .first()
8079                    .cloned()
8080            });
8081            if let Some(lsp_adapter) = lsp_adapter {
8082                labels = lsp_adapter
8083                    .labels_for_symbols(&label_params, &language)
8084                    .await
8085                    .log_err()
8086                    .unwrap_or_default();
8087            }
8088        }
8089
8090        for ((symbol, (name, _)), label) in symbols
8091            .into_iter()
8092            .zip(label_params.drain(..))
8093            .zip(labels.into_iter().chain(iter::repeat(None)))
8094        {
8095            output.push(Symbol {
8096                language_server_name: symbol.language_server_name,
8097                source_worktree_id: symbol.source_worktree_id,
8098                path: symbol.path,
8099                label: label.unwrap_or_else(|| CodeLabel::plain(name.clone(), None)),
8100                name,
8101                kind: symbol.kind,
8102                range: symbol.range,
8103                signature: symbol.signature,
8104            });
8105        }
8106    }
8107}
8108
8109fn include_text(server: &lsp::LanguageServer) -> Option<bool> {
8110    match server.capabilities().text_document_sync.as_ref()? {
8111        lsp::TextDocumentSyncCapability::Kind(kind) => match *kind {
8112            lsp::TextDocumentSyncKind::NONE => None,
8113            lsp::TextDocumentSyncKind::FULL => Some(true),
8114            lsp::TextDocumentSyncKind::INCREMENTAL => Some(false),
8115            _ => None,
8116        },
8117        lsp::TextDocumentSyncCapability::Options(options) => match options.save.as_ref()? {
8118            lsp::TextDocumentSyncSaveOptions::Supported(supported) => {
8119                if *supported {
8120                    Some(true)
8121                } else {
8122                    None
8123                }
8124            }
8125            lsp::TextDocumentSyncSaveOptions::SaveOptions(save_options) => {
8126                Some(save_options.include_text.unwrap_or(false))
8127            }
8128        },
8129    }
8130}
8131
8132#[cfg(test)]
8133#[test]
8134fn test_glob_literal_prefix() {
8135    assert_eq!(glob_literal_prefix("**/*.js"), "");
8136    assert_eq!(glob_literal_prefix("node_modules/**/*.js"), "node_modules");
8137    assert_eq!(glob_literal_prefix("foo/{bar,baz}.js"), "foo");
8138    assert_eq!(glob_literal_prefix("foo/bar/baz.js"), "foo/bar/baz.js");
8139}