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            // If we do have a project environment (either by spawning a shell in in the project directory
5544            // or by getting it from the CLI) and the language server command itself
5545            // doesn't have an environment, then we use the project environment.
5546            if binary.env.is_none() {
5547                log::info!(
5548                    "using project environment for language server {:?}",
5549                    adapter.name()
5550                );
5551                binary.env = Some(delegate.shell_env().await);
5552            }
5553            Ok(binary)
5554        })
5555    }
5556
5557    fn start_language_server(
5558        &mut self,
5559        worktree_handle: &Model<Worktree>,
5560        adapter: Arc<CachedLspAdapter>,
5561        language: LanguageName,
5562        cx: &mut ModelContext<Self>,
5563    ) {
5564        if self.mode.is_remote() {
5565            return;
5566        }
5567
5568        let worktree = worktree_handle.read(cx);
5569        let worktree_id = worktree.id();
5570        let worktree_path = worktree.abs_path();
5571        let key = (worktree_id, adapter.name.clone());
5572
5573        if self.language_server_ids.contains_key(&key) {
5574            return;
5575        }
5576
5577        let project_settings = ProjectSettings::get(
5578            Some(SettingsLocation {
5579                worktree_id,
5580                path: Path::new(""),
5581            }),
5582            cx,
5583        );
5584        let lsp = project_settings.lsp.get(&adapter.name);
5585        let override_options = lsp.and_then(|s| s.initialization_options.clone());
5586
5587        let stderr_capture = Arc::new(Mutex::new(Some(String::new())));
5588        let delegate = LocalLspAdapterDelegate::for_local(self, worktree_handle, cx)
5589            as Arc<dyn LspAdapterDelegate>;
5590
5591        let server_id = self.languages.next_language_server_id();
5592        let root_path = worktree_path.clone();
5593        log::info!(
5594            "attempting to start language server {:?}, path: {root_path:?}, id: {server_id}",
5595            adapter.name.0
5596        );
5597
5598        let binary = self.get_language_server_binary(adapter.clone(), delegate.clone(), true, cx);
5599
5600        let pending_server = cx.spawn({
5601            let adapter = adapter.clone();
5602            let server_name = adapter.name.clone();
5603            let stderr_capture = stderr_capture.clone();
5604
5605            move |_lsp_store, cx| async move {
5606                let binary = binary.await?;
5607
5608                #[cfg(any(test, feature = "test-support"))]
5609                if let Some(server) = _lsp_store
5610                    .update(&mut cx.clone(), |this, cx| {
5611                        this.languages.create_fake_language_server(
5612                            server_id,
5613                            &server_name,
5614                            binary.clone(),
5615                            cx.to_async(),
5616                        )
5617                    })
5618                    .ok()
5619                    .flatten()
5620                {
5621                    return Ok(server);
5622                }
5623
5624                lsp::LanguageServer::new(
5625                    stderr_capture,
5626                    server_id,
5627                    server_name,
5628                    binary,
5629                    &root_path,
5630                    adapter.code_action_kinds(),
5631                    cx,
5632                )
5633            }
5634        });
5635
5636        let state = LanguageServerState::Starting({
5637            let server_name = adapter.name.0.clone();
5638            let delegate = delegate as Arc<dyn LspAdapterDelegate>;
5639            let language = language.clone();
5640            let key = key.clone();
5641            let adapter = adapter.clone();
5642
5643            cx.spawn(move |this, mut cx| async move {
5644                let result = {
5645                    let delegate = delegate.clone();
5646                    let adapter = adapter.clone();
5647                    let this = this.clone();
5648                    let toolchains = this
5649                        .update(&mut cx, |this, cx| this.toolchain_store(cx))
5650                        .ok()?;
5651                    let mut cx = cx.clone();
5652                    async move {
5653                        let language_server = pending_server.await?;
5654
5655                        let workspace_config = adapter
5656                            .adapter
5657                            .clone()
5658                            .workspace_configuration(&delegate, toolchains.clone(), &mut cx)
5659                            .await?;
5660
5661                        let mut initialization_options = adapter
5662                            .adapter
5663                            .clone()
5664                            .initialization_options(&(delegate))
5665                            .await?;
5666
5667                        Self::setup_lsp_messages(this.clone(), &language_server, delegate, adapter);
5668
5669                        match (&mut initialization_options, override_options) {
5670                            (Some(initialization_options), Some(override_options)) => {
5671                                merge_json_value_into(override_options, initialization_options);
5672                            }
5673                            (None, override_options) => initialization_options = override_options,
5674                            _ => {}
5675                        }
5676
5677                        let language_server = cx
5678                            .update(|cx| language_server.initialize(initialization_options, cx))?
5679                            .await
5680                            .inspect_err(|_| {
5681                                if let Some(this) = this.upgrade() {
5682                                    this.update(&mut cx, |_, cx| {
5683                                        cx.emit(LspStoreEvent::LanguageServerRemoved(server_id))
5684                                    })
5685                                    .ok();
5686                                }
5687                            })?;
5688
5689                        language_server
5690                            .notify::<lsp::notification::DidChangeConfiguration>(
5691                                lsp::DidChangeConfigurationParams {
5692                                    settings: workspace_config,
5693                                },
5694                            )
5695                            .ok();
5696
5697                        anyhow::Ok(language_server)
5698                    }
5699                }
5700                .await;
5701
5702                match result {
5703                    Ok(server) => {
5704                        this.update(&mut cx, |this, mut cx| {
5705                            this.insert_newly_running_language_server(
5706                                language,
5707                                adapter,
5708                                server.clone(),
5709                                server_id,
5710                                key,
5711                                &mut cx,
5712                            );
5713                        })
5714                        .ok();
5715                        stderr_capture.lock().take();
5716                        Some(server)
5717                    }
5718
5719                    Err(err) => {
5720                        let log = stderr_capture.lock().take().unwrap_or_default();
5721                        delegate.update_status(
5722                            adapter.name(),
5723                            LanguageServerBinaryStatus::Failed {
5724                                error: format!("{err}\n-- stderr--\n{}", log),
5725                            },
5726                        );
5727                        log::error!("Failed to start language server {server_name:?}: {err}");
5728                        log::error!("server stderr: {:?}", log);
5729                        None
5730                    }
5731                }
5732            })
5733        });
5734
5735        self.as_local_mut()
5736            .unwrap()
5737            .language_servers
5738            .insert(server_id, state);
5739        self.language_server_ids.insert(key, server_id);
5740    }
5741
5742    async fn shutdown_language_server(
5743        server_state: Option<LanguageServerState>,
5744        name: LanguageServerName,
5745        cx: AsyncAppContext,
5746    ) {
5747        let server = match server_state {
5748            Some(LanguageServerState::Starting(task)) => {
5749                let mut timer = cx
5750                    .background_executor()
5751                    .timer(SERVER_LAUNCHING_BEFORE_SHUTDOWN_TIMEOUT)
5752                    .fuse();
5753
5754                select! {
5755                    server = task.fuse() => server,
5756                    _ = timer => {
5757                        log::info!(
5758                            "timeout waiting for language server {} to finish launching before stopping",
5759                            name
5760                        );
5761                        None
5762                    },
5763                }
5764            }
5765
5766            Some(LanguageServerState::Running { server, .. }) => Some(server),
5767
5768            None => None,
5769        };
5770
5771        if let Some(server) = server {
5772            if let Some(shutdown) = server.shutdown() {
5773                shutdown.await;
5774            }
5775        }
5776    }
5777
5778    // Returns a list of all of the worktrees which no longer have a language server and the root path
5779    // for the stopped server
5780    fn stop_local_language_server(
5781        &mut self,
5782        worktree_id: WorktreeId,
5783        adapter_name: LanguageServerName,
5784        cx: &mut ModelContext<Self>,
5785    ) -> Task<Vec<WorktreeId>> {
5786        let key = (worktree_id, adapter_name);
5787        if self.mode.is_local() {
5788            if let Some(server_id) = self.language_server_ids.remove(&key) {
5789                let name = key.1;
5790                log::info!("stopping language server {name}");
5791
5792                // Remove other entries for this language server as well
5793                let mut orphaned_worktrees = vec![worktree_id];
5794                let other_keys = self.language_server_ids.keys().cloned().collect::<Vec<_>>();
5795                for other_key in other_keys {
5796                    if self.language_server_ids.get(&other_key) == Some(&server_id) {
5797                        self.language_server_ids.remove(&other_key);
5798                        orphaned_worktrees.push(other_key.0);
5799                    }
5800                }
5801
5802                self.buffer_store.update(cx, |buffer_store, cx| {
5803                    for buffer in buffer_store.buffers() {
5804                        buffer.update(cx, |buffer, cx| {
5805                            buffer.update_diagnostics(
5806                                server_id,
5807                                DiagnosticSet::new([], buffer),
5808                                cx,
5809                            );
5810                            buffer.set_completion_triggers(server_id, Default::default(), cx);
5811                        });
5812                    }
5813                });
5814
5815                for (worktree_id, summaries) in self.diagnostic_summaries.iter_mut() {
5816                    summaries.retain(|path, summaries_by_server_id| {
5817                        if summaries_by_server_id.remove(&server_id).is_some() {
5818                            if let Some((client, project_id)) = self.downstream_client.clone() {
5819                                client
5820                                    .send(proto::UpdateDiagnosticSummary {
5821                                        project_id,
5822                                        worktree_id: worktree_id.to_proto(),
5823                                        summary: Some(proto::DiagnosticSummary {
5824                                            path: path.to_string_lossy().to_string(),
5825                                            language_server_id: server_id.0 as u64,
5826                                            error_count: 0,
5827                                            warning_count: 0,
5828                                        }),
5829                                    })
5830                                    .log_err();
5831                            }
5832                            !summaries_by_server_id.is_empty()
5833                        } else {
5834                            true
5835                        }
5836                    });
5837                }
5838
5839                for diagnostics in self.diagnostics.values_mut() {
5840                    diagnostics.retain(|_, diagnostics_by_server_id| {
5841                        if let Ok(ix) =
5842                            diagnostics_by_server_id.binary_search_by_key(&server_id, |e| e.0)
5843                        {
5844                            diagnostics_by_server_id.remove(ix);
5845                            !diagnostics_by_server_id.is_empty()
5846                        } else {
5847                            true
5848                        }
5849                    });
5850                }
5851
5852                self.as_local_mut()
5853                    .unwrap()
5854                    .language_server_watched_paths
5855                    .remove(&server_id);
5856                self.language_server_statuses.remove(&server_id);
5857                cx.notify();
5858
5859                let server_state = self
5860                    .as_local_mut()
5861                    .unwrap()
5862                    .language_servers
5863                    .remove(&server_id);
5864                cx.emit(LspStoreEvent::LanguageServerRemoved(server_id));
5865                cx.spawn(move |_, cx| async move {
5866                    Self::shutdown_language_server(server_state, name, cx).await;
5867                    orphaned_worktrees
5868                })
5869            } else {
5870                Task::ready(Vec::new())
5871            }
5872        } else {
5873            Task::ready(Vec::new())
5874        }
5875    }
5876
5877    pub fn restart_language_servers_for_buffers(
5878        &mut self,
5879        buffers: impl IntoIterator<Item = Model<Buffer>>,
5880        cx: &mut ModelContext<Self>,
5881    ) {
5882        if let Some((client, project_id)) = self.upstream_client() {
5883            let request = client.request(proto::RestartLanguageServers {
5884                project_id,
5885                buffer_ids: buffers
5886                    .into_iter()
5887                    .map(|b| b.read(cx).remote_id().to_proto())
5888                    .collect(),
5889            });
5890            cx.background_executor()
5891                .spawn(request)
5892                .detach_and_log_err(cx);
5893        } else {
5894            let language_server_lookup_info: HashSet<(Model<Worktree>, LanguageName)> = buffers
5895                .into_iter()
5896                .filter_map(|buffer| {
5897                    let buffer = buffer.read(cx);
5898                    let file = buffer.file()?;
5899                    let worktree = File::from_dyn(Some(file))?.worktree.clone();
5900                    let language =
5901                        self.languages
5902                            .language_for_file(file, Some(buffer.as_rope()), cx)?;
5903
5904                    Some((worktree, language.name()))
5905                })
5906                .collect();
5907
5908            for (worktree, language) in language_server_lookup_info {
5909                self.restart_local_language_servers(worktree, language, cx);
5910            }
5911        }
5912    }
5913
5914    fn restart_local_language_servers(
5915        &mut self,
5916        worktree: Model<Worktree>,
5917        language: LanguageName,
5918        cx: &mut ModelContext<Self>,
5919    ) {
5920        let worktree_id = worktree.read(cx).id();
5921
5922        let stop_tasks = self
5923            .languages
5924            .clone()
5925            .lsp_adapters(&language)
5926            .iter()
5927            .map(|adapter| {
5928                let stop_task =
5929                    self.stop_local_language_server(worktree_id, adapter.name.clone(), cx);
5930                (stop_task, adapter.name.clone())
5931            })
5932            .collect::<Vec<_>>();
5933        if stop_tasks.is_empty() {
5934            return;
5935        }
5936
5937        cx.spawn(move |this, mut cx| async move {
5938            // For each stopped language server, record all of the worktrees with which
5939            // it was associated.
5940            let mut affected_worktrees = Vec::new();
5941            for (stop_task, language_server_name) in stop_tasks {
5942                for affected_worktree_id in stop_task.await {
5943                    affected_worktrees.push((affected_worktree_id, language_server_name.clone()));
5944                }
5945            }
5946
5947            this.update(&mut cx, |this, cx| {
5948                // Restart the language server for the given worktree.
5949                this.start_language_servers(&worktree, language.clone(), cx);
5950
5951                // Lookup new server ids and set them for each of the orphaned worktrees
5952                for (affected_worktree_id, language_server_name) in affected_worktrees {
5953                    if let Some(new_server_id) = this
5954                        .language_server_ids
5955                        .get(&(worktree_id, language_server_name.clone()))
5956                        .cloned()
5957                    {
5958                        this.language_server_ids
5959                            .insert((affected_worktree_id, language_server_name), new_server_id);
5960                    }
5961                }
5962            })
5963            .ok();
5964        })
5965        .detach();
5966    }
5967
5968    fn setup_lsp_messages(
5969        this: WeakModel<Self>,
5970        language_server: &LanguageServer,
5971        delegate: Arc<dyn LspAdapterDelegate>,
5972        adapter: Arc<CachedLspAdapter>,
5973    ) {
5974        let name = language_server.name();
5975        let server_id = language_server.server_id();
5976        language_server
5977            .on_notification::<lsp::notification::PublishDiagnostics, _>({
5978                let adapter = adapter.clone();
5979                let this = this.clone();
5980                move |mut params, mut cx| {
5981                    let adapter = adapter.clone();
5982                    if let Some(this) = this.upgrade() {
5983                        adapter.process_diagnostics(&mut params);
5984                        this.update(&mut cx, |this, cx| {
5985                            this.update_diagnostics(
5986                                server_id,
5987                                params,
5988                                &adapter.disk_based_diagnostic_sources,
5989                                cx,
5990                            )
5991                            .log_err();
5992                        })
5993                        .ok();
5994                    }
5995                }
5996            })
5997            .detach();
5998        language_server
5999            .on_request::<lsp::request::WorkspaceConfiguration, _, _>({
6000                let adapter = adapter.adapter.clone();
6001                let delegate = delegate.clone();
6002                let this = this.clone();
6003                move |params, mut cx| {
6004                    let adapter = adapter.clone();
6005                    let delegate = delegate.clone();
6006                    let this = this.clone();
6007                    async move {
6008                        let toolchains =
6009                            this.update(&mut cx, |this, cx| this.toolchain_store(cx))?;
6010                        let workspace_config = adapter
6011                            .workspace_configuration(&delegate, toolchains, &mut cx)
6012                            .await?;
6013                        Ok(params
6014                            .items
6015                            .into_iter()
6016                            .map(|item| {
6017                                if let Some(section) = &item.section {
6018                                    workspace_config
6019                                        .get(section)
6020                                        .cloned()
6021                                        .unwrap_or(serde_json::Value::Null)
6022                                } else {
6023                                    workspace_config.clone()
6024                                }
6025                            })
6026                            .collect())
6027                    }
6028                }
6029            })
6030            .detach();
6031
6032        language_server
6033            .on_request::<lsp::request::WorkspaceFoldersRequest, _, _>({
6034                let this = this.clone();
6035                move |_, mut cx| {
6036                    let this = this.clone();
6037                    async move {
6038                        let Some(server) =
6039                            this.update(&mut cx, |this, _| this.language_server_for_id(server_id))?
6040                        else {
6041                            return Ok(None);
6042                        };
6043                        let root = server.root_path();
6044                        let Ok(uri) = Url::from_file_path(&root) else {
6045                            return Ok(None);
6046                        };
6047                        Ok(Some(vec![WorkspaceFolder {
6048                            uri,
6049                            name: Default::default(),
6050                        }]))
6051                    }
6052                }
6053            })
6054            .detach();
6055        // Even though we don't have handling for these requests, respond to them to
6056        // avoid stalling any language server like `gopls` which waits for a response
6057        // to these requests when initializing.
6058        language_server
6059            .on_request::<lsp::request::WorkDoneProgressCreate, _, _>({
6060                let this = this.clone();
6061                move |params, mut cx| {
6062                    let this = this.clone();
6063                    async move {
6064                        this.update(&mut cx, |this, _| {
6065                            if let Some(status) = this.language_server_statuses.get_mut(&server_id)
6066                            {
6067                                if let lsp::NumberOrString::String(token) = params.token {
6068                                    status.progress_tokens.insert(token);
6069                                }
6070                            }
6071                        })?;
6072
6073                        Ok(())
6074                    }
6075                }
6076            })
6077            .detach();
6078
6079        language_server
6080            .on_request::<lsp::request::RegisterCapability, _, _>({
6081                let this = this.clone();
6082                move |params, mut cx| {
6083                    let this = this.clone();
6084                    async move {
6085                        for reg in params.registrations {
6086                            match reg.method.as_str() {
6087                                "workspace/didChangeWatchedFiles" => {
6088                                    if let Some(options) = reg.register_options {
6089                                        let options = serde_json::from_value(options)?;
6090                                        this.update(&mut cx, |this, cx| {
6091                                            this.on_lsp_did_change_watched_files(
6092                                                server_id, &reg.id, options, cx,
6093                                            );
6094                                        })?;
6095                                    }
6096                                }
6097                                "textDocument/rangeFormatting" => {
6098                                    this.update(&mut cx, |this, _| {
6099                                        if let Some(server) = this.language_server_for_id(server_id)
6100                                        {
6101                                            let options = reg
6102                                                .register_options
6103                                                .map(|options| {
6104                                                    serde_json::from_value::<
6105                                                        lsp::DocumentRangeFormattingOptions,
6106                                                    >(
6107                                                        options
6108                                                    )
6109                                                })
6110                                                .transpose()?;
6111                                            let provider = match options {
6112                                                None => OneOf::Left(true),
6113                                                Some(options) => OneOf::Right(options),
6114                                            };
6115                                            server.update_capabilities(|capabilities| {
6116                                                capabilities.document_range_formatting_provider =
6117                                                    Some(provider);
6118                                            })
6119                                        }
6120                                        anyhow::Ok(())
6121                                    })??;
6122                                }
6123                                "textDocument/onTypeFormatting" => {
6124                                    this.update(&mut cx, |this, _| {
6125                                        if let Some(server) = this.language_server_for_id(server_id)
6126                                        {
6127                                            let options = reg
6128                                                .register_options
6129                                                .map(|options| {
6130                                                    serde_json::from_value::<
6131                                                        lsp::DocumentOnTypeFormattingOptions,
6132                                                    >(
6133                                                        options
6134                                                    )
6135                                                })
6136                                                .transpose()?;
6137                                            if let Some(options) = options {
6138                                                server.update_capabilities(|capabilities| {
6139                                                    capabilities
6140                                                        .document_on_type_formatting_provider =
6141                                                        Some(options);
6142                                                })
6143                                            }
6144                                        }
6145                                        anyhow::Ok(())
6146                                    })??;
6147                                }
6148                                "textDocument/formatting" => {
6149                                    this.update(&mut cx, |this, _| {
6150                                        if let Some(server) = this.language_server_for_id(server_id)
6151                                        {
6152                                            let options = reg
6153                                                .register_options
6154                                                .map(|options| {
6155                                                    serde_json::from_value::<
6156                                                        lsp::DocumentFormattingOptions,
6157                                                    >(
6158                                                        options
6159                                                    )
6160                                                })
6161                                                .transpose()?;
6162                                            let provider = match options {
6163                                                None => OneOf::Left(true),
6164                                                Some(options) => OneOf::Right(options),
6165                                            };
6166                                            server.update_capabilities(|capabilities| {
6167                                                capabilities.document_formatting_provider =
6168                                                    Some(provider);
6169                                            })
6170                                        }
6171                                        anyhow::Ok(())
6172                                    })??;
6173                                }
6174                                _ => log::warn!("unhandled capability registration: {reg:?}"),
6175                            }
6176                        }
6177                        Ok(())
6178                    }
6179                }
6180            })
6181            .detach();
6182
6183        language_server
6184            .on_request::<lsp::request::UnregisterCapability, _, _>({
6185                let this = this.clone();
6186                move |params, mut cx| {
6187                    let this = this.clone();
6188                    async move {
6189                        for unreg in params.unregisterations.iter() {
6190                            match unreg.method.as_str() {
6191                                "workspace/didChangeWatchedFiles" => {
6192                                    this.update(&mut cx, |this, cx| {
6193                                        this.on_lsp_unregister_did_change_watched_files(
6194                                            server_id, &unreg.id, cx,
6195                                        );
6196                                    })?;
6197                                }
6198                                "textDocument/rename" => {
6199                                    this.update(&mut cx, |this, _| {
6200                                        if let Some(server) = this.language_server_for_id(server_id)
6201                                        {
6202                                            server.update_capabilities(|capabilities| {
6203                                                capabilities.rename_provider = None
6204                                            })
6205                                        }
6206                                    })?;
6207                                }
6208                                "textDocument/rangeFormatting" => {
6209                                    this.update(&mut cx, |this, _| {
6210                                        if let Some(server) = this.language_server_for_id(server_id)
6211                                        {
6212                                            server.update_capabilities(|capabilities| {
6213                                                capabilities.document_range_formatting_provider =
6214                                                    None
6215                                            })
6216                                        }
6217                                    })?;
6218                                }
6219                                "textDocument/onTypeFormatting" => {
6220                                    this.update(&mut cx, |this, _| {
6221                                        if let Some(server) = this.language_server_for_id(server_id)
6222                                        {
6223                                            server.update_capabilities(|capabilities| {
6224                                                capabilities.document_on_type_formatting_provider =
6225                                                    None;
6226                                            })
6227                                        }
6228                                    })?;
6229                                }
6230                                "textDocument/formatting" => {
6231                                    this.update(&mut cx, |this, _| {
6232                                        if let Some(server) = this.language_server_for_id(server_id)
6233                                        {
6234                                            server.update_capabilities(|capabilities| {
6235                                                capabilities.document_formatting_provider = None;
6236                                            })
6237                                        }
6238                                    })?;
6239                                }
6240                                _ => log::warn!("unhandled capability unregistration: {unreg:?}"),
6241                            }
6242                        }
6243                        Ok(())
6244                    }
6245                }
6246            })
6247            .detach();
6248
6249        language_server
6250            .on_request::<lsp::request::ApplyWorkspaceEdit, _, _>({
6251                let adapter = adapter.clone();
6252                let this = this.clone();
6253                move |params, cx| {
6254                    Self::on_lsp_workspace_edit(
6255                        this.clone(),
6256                        params,
6257                        server_id,
6258                        adapter.clone(),
6259                        cx,
6260                    )
6261                }
6262            })
6263            .detach();
6264
6265        language_server
6266            .on_request::<lsp::request::InlayHintRefreshRequest, _, _>({
6267                let this = this.clone();
6268                move |(), mut cx| {
6269                    let this = this.clone();
6270                    async move {
6271                        this.update(&mut cx, |this, cx| {
6272                            cx.emit(LspStoreEvent::RefreshInlayHints);
6273                            this.downstream_client.as_ref().map(|(client, project_id)| {
6274                                client.send(proto::RefreshInlayHints {
6275                                    project_id: *project_id,
6276                                })
6277                            })
6278                        })?
6279                        .transpose()?;
6280                        Ok(())
6281                    }
6282                }
6283            })
6284            .detach();
6285
6286        language_server
6287            .on_request::<lsp::request::ShowMessageRequest, _, _>({
6288                let this = this.clone();
6289                let name = name.to_string();
6290                move |params, mut cx| {
6291                    let this = this.clone();
6292                    let name = name.to_string();
6293                    async move {
6294                        let actions = params.actions.unwrap_or_default();
6295                        let (tx, mut rx) = smol::channel::bounded(1);
6296                        let request = LanguageServerPromptRequest {
6297                            level: match params.typ {
6298                                lsp::MessageType::ERROR => PromptLevel::Critical,
6299                                lsp::MessageType::WARNING => PromptLevel::Warning,
6300                                _ => PromptLevel::Info,
6301                            },
6302                            message: params.message,
6303                            actions,
6304                            response_channel: tx,
6305                            lsp_name: name.clone(),
6306                        };
6307
6308                        let did_update = this
6309                            .update(&mut cx, |_, cx| {
6310                                cx.emit(LspStoreEvent::LanguageServerPrompt(request));
6311                            })
6312                            .is_ok();
6313                        if did_update {
6314                            let response = rx.next().await;
6315
6316                            Ok(response)
6317                        } else {
6318                            Ok(None)
6319                        }
6320                    }
6321                }
6322            })
6323            .detach();
6324
6325        language_server
6326            .on_notification::<ServerStatus, _>({
6327                let this = this.clone();
6328                let name = name.to_string();
6329                move |params, mut cx| {
6330                    let this = this.clone();
6331                    let name = name.to_string();
6332                    if let Some(ref message) = params.message {
6333                        let message = message.trim();
6334                        if !message.is_empty() {
6335                            let formatted_message = format!(
6336                                "Language server {name} (id {server_id}) status update: {message}"
6337                            );
6338                            match params.health {
6339                                ServerHealthStatus::Ok => log::info!("{}", formatted_message),
6340                                ServerHealthStatus::Warning => log::warn!("{}", formatted_message),
6341                                ServerHealthStatus::Error => {
6342                                    log::error!("{}", formatted_message);
6343                                    let (tx, _rx) = smol::channel::bounded(1);
6344                                    let request = LanguageServerPromptRequest {
6345                                        level: PromptLevel::Critical,
6346                                        message: params.message.unwrap_or_default(),
6347                                        actions: Vec::new(),
6348                                        response_channel: tx,
6349                                        lsp_name: name.clone(),
6350                                    };
6351                                    let _ = this
6352                                        .update(&mut cx, |_, cx| {
6353                                            cx.emit(LspStoreEvent::LanguageServerPrompt(request));
6354                                        })
6355                                        .ok();
6356                                }
6357                                ServerHealthStatus::Other(status) => {
6358                                    log::info!(
6359                                        "Unknown server health: {status}\n{formatted_message}"
6360                                    )
6361                                }
6362                            }
6363                        }
6364                    }
6365                }
6366            })
6367            .detach();
6368        language_server
6369            .on_notification::<lsp::notification::ShowMessage, _>({
6370                let this = this.clone();
6371                let name = name.to_string();
6372                move |params, mut cx| {
6373                    let this = this.clone();
6374                    let name = name.to_string();
6375
6376                    let (tx, _) = smol::channel::bounded(1);
6377                    let request = LanguageServerPromptRequest {
6378                        level: match params.typ {
6379                            lsp::MessageType::ERROR => PromptLevel::Critical,
6380                            lsp::MessageType::WARNING => PromptLevel::Warning,
6381                            _ => PromptLevel::Info,
6382                        },
6383                        message: params.message,
6384                        actions: vec![],
6385                        response_channel: tx,
6386                        lsp_name: name.clone(),
6387                    };
6388
6389                    let _ = this.update(&mut cx, |_, cx| {
6390                        cx.emit(LspStoreEvent::LanguageServerPrompt(request));
6391                    });
6392                }
6393            })
6394            .detach();
6395
6396        let disk_based_diagnostics_progress_token =
6397            adapter.disk_based_diagnostics_progress_token.clone();
6398
6399        language_server
6400            .on_notification::<lsp::notification::Progress, _>({
6401                let this = this.clone();
6402                move |params, mut cx| {
6403                    if let Some(this) = this.upgrade() {
6404                        this.update(&mut cx, |this, cx| {
6405                            this.on_lsp_progress(
6406                                params,
6407                                server_id,
6408                                disk_based_diagnostics_progress_token.clone(),
6409                                cx,
6410                            );
6411                        })
6412                        .ok();
6413                    }
6414                }
6415            })
6416            .detach();
6417
6418        language_server
6419            .on_notification::<lsp::notification::LogMessage, _>({
6420                let this = this.clone();
6421                move |params, mut cx| {
6422                    if let Some(this) = this.upgrade() {
6423                        this.update(&mut cx, |_, cx| {
6424                            cx.emit(LspStoreEvent::LanguageServerLog(
6425                                server_id,
6426                                LanguageServerLogType::Log(params.typ),
6427                                params.message,
6428                            ));
6429                        })
6430                        .ok();
6431                    }
6432                }
6433            })
6434            .detach();
6435
6436        language_server
6437            .on_notification::<lsp::notification::LogTrace, _>({
6438                let this = this.clone();
6439                move |params, mut cx| {
6440                    if let Some(this) = this.upgrade() {
6441                        this.update(&mut cx, |_, cx| {
6442                            cx.emit(LspStoreEvent::LanguageServerLog(
6443                                server_id,
6444                                LanguageServerLogType::Trace(params.verbose),
6445                                params.message,
6446                            ));
6447                        })
6448                        .ok();
6449                    }
6450                }
6451            })
6452            .detach();
6453    }
6454
6455    pub fn update_diagnostics(
6456        &mut self,
6457        language_server_id: LanguageServerId,
6458        mut params: lsp::PublishDiagnosticsParams,
6459        disk_based_sources: &[String],
6460        cx: &mut ModelContext<Self>,
6461    ) -> Result<()> {
6462        let abs_path = params
6463            .uri
6464            .to_file_path()
6465            .map_err(|_| anyhow!("URI is not a file"))?;
6466        let mut diagnostics = Vec::default();
6467        let mut primary_diagnostic_group_ids = HashMap::default();
6468        let mut sources_by_group_id = HashMap::default();
6469        let mut supporting_diagnostics = HashMap::default();
6470
6471        // Ensure that primary diagnostics are always the most severe
6472        params.diagnostics.sort_by_key(|item| item.severity);
6473
6474        for diagnostic in &params.diagnostics {
6475            let source = diagnostic.source.as_ref();
6476            let code = diagnostic.code.as_ref().map(|code| match code {
6477                lsp::NumberOrString::Number(code) => code.to_string(),
6478                lsp::NumberOrString::String(code) => code.clone(),
6479            });
6480            let range = range_from_lsp(diagnostic.range);
6481            let is_supporting = diagnostic
6482                .related_information
6483                .as_ref()
6484                .map_or(false, |infos| {
6485                    infos.iter().any(|info| {
6486                        primary_diagnostic_group_ids.contains_key(&(
6487                            source,
6488                            code.clone(),
6489                            range_from_lsp(info.location.range),
6490                        ))
6491                    })
6492                });
6493
6494            let is_unnecessary = diagnostic.tags.as_ref().map_or(false, |tags| {
6495                tags.iter().any(|tag| *tag == DiagnosticTag::UNNECESSARY)
6496            });
6497
6498            if is_supporting {
6499                supporting_diagnostics.insert(
6500                    (source, code.clone(), range),
6501                    (diagnostic.severity, is_unnecessary),
6502                );
6503            } else {
6504                let group_id = post_inc(&mut self.next_diagnostic_group_id);
6505                let is_disk_based =
6506                    source.map_or(false, |source| disk_based_sources.contains(source));
6507
6508                sources_by_group_id.insert(group_id, source);
6509                primary_diagnostic_group_ids
6510                    .insert((source, code.clone(), range.clone()), group_id);
6511
6512                diagnostics.push(DiagnosticEntry {
6513                    range,
6514                    diagnostic: Diagnostic {
6515                        source: diagnostic.source.clone(),
6516                        code: code.clone(),
6517                        severity: diagnostic.severity.unwrap_or(DiagnosticSeverity::ERROR),
6518                        message: diagnostic.message.trim().to_string(),
6519                        group_id,
6520                        is_primary: true,
6521                        is_disk_based,
6522                        is_unnecessary,
6523                        data: diagnostic.data.clone(),
6524                    },
6525                });
6526                if let Some(infos) = &diagnostic.related_information {
6527                    for info in infos {
6528                        if info.location.uri == params.uri && !info.message.is_empty() {
6529                            let range = range_from_lsp(info.location.range);
6530                            diagnostics.push(DiagnosticEntry {
6531                                range,
6532                                diagnostic: Diagnostic {
6533                                    source: diagnostic.source.clone(),
6534                                    code: code.clone(),
6535                                    severity: DiagnosticSeverity::INFORMATION,
6536                                    message: info.message.trim().to_string(),
6537                                    group_id,
6538                                    is_primary: false,
6539                                    is_disk_based,
6540                                    is_unnecessary: false,
6541                                    data: diagnostic.data.clone(),
6542                                },
6543                            });
6544                        }
6545                    }
6546                }
6547            }
6548        }
6549
6550        for entry in &mut diagnostics {
6551            let diagnostic = &mut entry.diagnostic;
6552            if !diagnostic.is_primary {
6553                let source = *sources_by_group_id.get(&diagnostic.group_id).unwrap();
6554                if let Some(&(severity, is_unnecessary)) = supporting_diagnostics.get(&(
6555                    source,
6556                    diagnostic.code.clone(),
6557                    entry.range.clone(),
6558                )) {
6559                    if let Some(severity) = severity {
6560                        diagnostic.severity = severity;
6561                    }
6562                    diagnostic.is_unnecessary = is_unnecessary;
6563                }
6564            }
6565        }
6566
6567        self.update_diagnostic_entries(
6568            language_server_id,
6569            abs_path,
6570            params.version,
6571            diagnostics,
6572            cx,
6573        )?;
6574        Ok(())
6575    }
6576
6577    fn insert_newly_running_language_server(
6578        &mut self,
6579        language: LanguageName,
6580        adapter: Arc<CachedLspAdapter>,
6581        language_server: Arc<LanguageServer>,
6582        server_id: LanguageServerId,
6583        key: (WorktreeId, LanguageServerName),
6584        cx: &mut ModelContext<Self>,
6585    ) {
6586        // If the language server for this key doesn't match the server id, don't store the
6587        // server. Which will cause it to be dropped, killing the process
6588        if self
6589            .language_server_ids
6590            .get(&key)
6591            .map(|id| id != &server_id)
6592            .unwrap_or(false)
6593        {
6594            return;
6595        }
6596
6597        // Update language_servers collection with Running variant of LanguageServerState
6598        // indicating that the server is up and running and ready
6599        if let Some(local) = self.as_local_mut() {
6600            local.language_servers.insert(
6601                server_id,
6602                LanguageServerState::Running {
6603                    adapter: adapter.clone(),
6604                    language: language.clone(),
6605                    server: language_server.clone(),
6606                    simulate_disk_based_diagnostics_completion: None,
6607                },
6608            );
6609        }
6610
6611        self.language_server_statuses.insert(
6612            server_id,
6613            LanguageServerStatus {
6614                name: language_server.name().to_string(),
6615                pending_work: Default::default(),
6616                has_pending_diagnostic_updates: false,
6617                progress_tokens: Default::default(),
6618            },
6619        );
6620
6621        cx.emit(LspStoreEvent::LanguageServerAdded(
6622            server_id,
6623            language_server.name(),
6624            Some(key.0),
6625        ));
6626
6627        if let Some((downstream_client, project_id)) = self.downstream_client.as_ref() {
6628            downstream_client
6629                .send(proto::StartLanguageServer {
6630                    project_id: *project_id,
6631                    server: Some(proto::LanguageServer {
6632                        id: server_id.0 as u64,
6633                        name: language_server.name().to_string(),
6634                        worktree_id: Some(key.0.to_proto()),
6635                    }),
6636                })
6637                .log_err();
6638        }
6639
6640        // Tell the language server about every open buffer in the worktree that matches the language.
6641        self.buffer_store.update(cx, |buffer_store, cx| {
6642            for buffer_handle in buffer_store.buffers() {
6643                let buffer = buffer_handle.read(cx);
6644                let file = match File::from_dyn(buffer.file()) {
6645                    Some(file) => file,
6646                    None => continue,
6647                };
6648                let language = match buffer.language() {
6649                    Some(language) => language,
6650                    None => continue,
6651                };
6652
6653                if file.worktree.read(cx).id() != key.0
6654                    || !self
6655                        .languages
6656                        .lsp_adapters(&language.name())
6657                        .iter()
6658                        .any(|a| a.name == key.1)
6659                {
6660                    continue;
6661                }
6662
6663                let file = match file.as_local() {
6664                    Some(file) => file,
6665                    None => continue,
6666                };
6667
6668                let versions = self
6669                    .buffer_snapshots
6670                    .entry(buffer.remote_id())
6671                    .or_default()
6672                    .entry(server_id)
6673                    .or_insert_with(|| {
6674                        vec![LspBufferSnapshot {
6675                            version: 0,
6676                            snapshot: buffer.text_snapshot(),
6677                        }]
6678                    });
6679
6680                let snapshot = versions.last().unwrap();
6681                let version = snapshot.version;
6682                let initial_snapshot = &snapshot.snapshot;
6683                let uri = lsp::Url::from_file_path(file.abs_path(cx)).unwrap();
6684                language_server
6685                    .notify::<lsp::notification::DidOpenTextDocument>(
6686                        lsp::DidOpenTextDocumentParams {
6687                            text_document: lsp::TextDocumentItem::new(
6688                                uri,
6689                                adapter.language_id(&language.name()),
6690                                version,
6691                                initial_snapshot.text(),
6692                            ),
6693                        },
6694                    )
6695                    .log_err();
6696
6697                buffer_handle.update(cx, |buffer, cx| {
6698                    buffer.set_completion_triggers(
6699                        server_id,
6700                        language_server
6701                            .capabilities()
6702                            .completion_provider
6703                            .as_ref()
6704                            .and_then(|provider| {
6705                                provider
6706                                    .trigger_characters
6707                                    .as_ref()
6708                                    .map(|characters| characters.iter().cloned().collect())
6709                            })
6710                            .unwrap_or_default(),
6711                        cx,
6712                    )
6713                });
6714            }
6715        });
6716
6717        cx.notify();
6718    }
6719
6720    fn buffer_snapshot_for_lsp_version(
6721        &mut self,
6722        buffer: &Model<Buffer>,
6723        server_id: LanguageServerId,
6724        version: Option<i32>,
6725        cx: &AppContext,
6726    ) -> Result<TextBufferSnapshot> {
6727        const OLD_VERSIONS_TO_RETAIN: i32 = 10;
6728
6729        if let Some(version) = version {
6730            let buffer_id = buffer.read(cx).remote_id();
6731            let snapshots = self
6732                .buffer_snapshots
6733                .get_mut(&buffer_id)
6734                .and_then(|m| m.get_mut(&server_id))
6735                .ok_or_else(|| {
6736                    anyhow!("no snapshots found for buffer {buffer_id} and server {server_id}")
6737                })?;
6738
6739            let found_snapshot = snapshots
6740                    .binary_search_by_key(&version, |e| e.version)
6741                    .map(|ix| snapshots[ix].snapshot.clone())
6742                    .map_err(|_| {
6743                        anyhow!("snapshot not found for buffer {buffer_id} server {server_id} at version {version}")
6744                    })?;
6745
6746            snapshots.retain(|snapshot| snapshot.version + OLD_VERSIONS_TO_RETAIN >= version);
6747            Ok(found_snapshot)
6748        } else {
6749            Ok((buffer.read(cx)).text_snapshot())
6750        }
6751    }
6752
6753    pub fn language_servers_running_disk_based_diagnostics(
6754        &self,
6755    ) -> impl Iterator<Item = LanguageServerId> + '_ {
6756        self.language_server_statuses
6757            .iter()
6758            .filter_map(|(id, status)| {
6759                if status.has_pending_diagnostic_updates {
6760                    Some(*id)
6761                } else {
6762                    None
6763                }
6764            })
6765    }
6766
6767    pub(crate) fn language_servers_for_buffer<'a>(
6768        &'a self,
6769        buffer: &'a Buffer,
6770        cx: &'a AppContext,
6771    ) -> impl Iterator<Item = (&'a Arc<CachedLspAdapter>, &'a Arc<LanguageServer>)> {
6772        self.language_server_ids_for_buffer(buffer, cx)
6773            .into_iter()
6774            .filter_map(
6775                |server_id| match self.as_local()?.language_servers.get(&server_id)? {
6776                    LanguageServerState::Running {
6777                        adapter, server, ..
6778                    } => Some((adapter, server)),
6779                    _ => None,
6780                },
6781            )
6782    }
6783
6784    pub(crate) fn cancel_language_server_work_for_buffers(
6785        &mut self,
6786        buffers: impl IntoIterator<Item = Model<Buffer>>,
6787        cx: &mut ModelContext<Self>,
6788    ) {
6789        if let Some((client, project_id)) = self.upstream_client() {
6790            let request = client.request(proto::CancelLanguageServerWork {
6791                project_id,
6792                work: Some(proto::cancel_language_server_work::Work::Buffers(
6793                    proto::cancel_language_server_work::Buffers {
6794                        buffer_ids: buffers
6795                            .into_iter()
6796                            .map(|b| b.read(cx).remote_id().to_proto())
6797                            .collect(),
6798                    },
6799                )),
6800            });
6801            cx.background_executor()
6802                .spawn(request)
6803                .detach_and_log_err(cx);
6804        } else {
6805            let servers = buffers
6806                .into_iter()
6807                .flat_map(|buffer| {
6808                    self.language_server_ids_for_buffer(buffer.read(cx), cx)
6809                        .into_iter()
6810                })
6811                .collect::<HashSet<_>>();
6812
6813            for server_id in servers {
6814                self.cancel_language_server_work(server_id, None, cx);
6815            }
6816        }
6817    }
6818
6819    pub(crate) fn cancel_language_server_work(
6820        &mut self,
6821        server_id: LanguageServerId,
6822        token_to_cancel: Option<String>,
6823        cx: &mut ModelContext<Self>,
6824    ) {
6825        if let Some(local) = self.as_local() {
6826            let status = self.language_server_statuses.get(&server_id);
6827            let server = local.language_servers.get(&server_id);
6828            if let Some((LanguageServerState::Running { server, .. }, status)) = server.zip(status)
6829            {
6830                for (token, progress) in &status.pending_work {
6831                    if let Some(token_to_cancel) = token_to_cancel.as_ref() {
6832                        if token != token_to_cancel {
6833                            continue;
6834                        }
6835                    }
6836                    if progress.is_cancellable {
6837                        server
6838                            .notify::<lsp::notification::WorkDoneProgressCancel>(
6839                                WorkDoneProgressCancelParams {
6840                                    token: lsp::NumberOrString::String(token.clone()),
6841                                },
6842                            )
6843                            .ok();
6844                    }
6845
6846                    if progress.is_cancellable {
6847                        server
6848                            .notify::<lsp::notification::WorkDoneProgressCancel>(
6849                                WorkDoneProgressCancelParams {
6850                                    token: lsp::NumberOrString::String(token.clone()),
6851                                },
6852                            )
6853                            .ok();
6854                    }
6855                }
6856            }
6857        } else if let Some((client, project_id)) = self.upstream_client() {
6858            let request = client.request(proto::CancelLanguageServerWork {
6859                project_id,
6860                work: Some(
6861                    proto::cancel_language_server_work::Work::LanguageServerWork(
6862                        proto::cancel_language_server_work::LanguageServerWork {
6863                            language_server_id: server_id.to_proto(),
6864                            token: token_to_cancel,
6865                        },
6866                    ),
6867                ),
6868            });
6869            cx.background_executor()
6870                .spawn(request)
6871                .detach_and_log_err(cx);
6872        }
6873    }
6874
6875    pub fn language_servers(
6876        &self,
6877    ) -> impl '_ + Iterator<Item = (LanguageServerId, LanguageServerName, WorktreeId)> {
6878        self.language_server_ids
6879            .iter()
6880            .map(|((worktree_id, server_name), server_id)| {
6881                (*server_id, server_name.clone(), *worktree_id)
6882            })
6883    }
6884
6885    fn register_supplementary_language_server(
6886        &mut self,
6887        id: LanguageServerId,
6888        name: LanguageServerName,
6889        server: Arc<LanguageServer>,
6890        cx: &mut ModelContext<Self>,
6891    ) {
6892        if let Some(local) = self.as_local_mut() {
6893            local
6894                .supplementary_language_servers
6895                .insert(id, (name.clone(), server));
6896            cx.emit(LspStoreEvent::LanguageServerAdded(id, name, None));
6897        }
6898    }
6899
6900    fn unregister_supplementary_language_server(
6901        &mut self,
6902        id: LanguageServerId,
6903        cx: &mut ModelContext<Self>,
6904    ) {
6905        if let Some(local) = self.as_local_mut() {
6906            local.supplementary_language_servers.remove(&id);
6907            cx.emit(LspStoreEvent::LanguageServerRemoved(id));
6908        }
6909    }
6910
6911    pub fn supplementary_language_servers(
6912        &self,
6913    ) -> impl '_ + Iterator<Item = (LanguageServerId, LanguageServerName)> {
6914        self.as_local().into_iter().flat_map(|local| {
6915            local
6916                .supplementary_language_servers
6917                .iter()
6918                .map(|(id, (name, _))| (*id, name.clone()))
6919        })
6920    }
6921
6922    pub fn language_server_adapter_for_id(
6923        &self,
6924        id: LanguageServerId,
6925    ) -> Option<Arc<CachedLspAdapter>> {
6926        self.as_local()
6927            .and_then(|local| local.language_servers.get(&id))
6928            .and_then(|language_server_state| match language_server_state {
6929                LanguageServerState::Running { adapter, .. } => Some(adapter.clone()),
6930                _ => None,
6931            })
6932    }
6933
6934    pub(super) fn update_local_worktree_language_servers(
6935        &mut self,
6936        worktree_handle: &Model<Worktree>,
6937        changes: &[(Arc<Path>, ProjectEntryId, PathChange)],
6938        cx: &mut ModelContext<Self>,
6939    ) {
6940        if changes.is_empty() {
6941            return;
6942        }
6943
6944        let Some(local) = self.as_local() else { return };
6945
6946        local.prettier_store.update(cx, |prettier_store, cx| {
6947            prettier_store.update_prettier_settings(&worktree_handle, changes, cx)
6948        });
6949
6950        let worktree_id = worktree_handle.read(cx).id();
6951        let mut language_server_ids = self
6952            .language_server_ids
6953            .iter()
6954            .filter_map(|((server_worktree_id, _), server_id)| {
6955                (*server_worktree_id == worktree_id).then_some(*server_id)
6956            })
6957            .collect::<Vec<_>>();
6958        language_server_ids.sort();
6959        language_server_ids.dedup();
6960
6961        let abs_path = worktree_handle.read(cx).abs_path();
6962        for server_id in &language_server_ids {
6963            if let Some(LanguageServerState::Running { server, .. }) =
6964                local.language_servers.get(server_id)
6965            {
6966                if let Some(watched_paths) = local
6967                    .language_server_watched_paths
6968                    .get(server_id)
6969                    .and_then(|paths| paths.read(cx).worktree_paths.get(&worktree_id))
6970                {
6971                    let params = lsp::DidChangeWatchedFilesParams {
6972                        changes: changes
6973                            .iter()
6974                            .filter_map(|(path, _, change)| {
6975                                if !watched_paths.is_match(path) {
6976                                    return None;
6977                                }
6978                                let typ = match change {
6979                                    PathChange::Loaded => return None,
6980                                    PathChange::Added => lsp::FileChangeType::CREATED,
6981                                    PathChange::Removed => lsp::FileChangeType::DELETED,
6982                                    PathChange::Updated => lsp::FileChangeType::CHANGED,
6983                                    PathChange::AddedOrUpdated => lsp::FileChangeType::CHANGED,
6984                                };
6985                                Some(lsp::FileEvent {
6986                                    uri: lsp::Url::from_file_path(abs_path.join(path)).unwrap(),
6987                                    typ,
6988                                })
6989                            })
6990                            .collect(),
6991                    };
6992                    if !params.changes.is_empty() {
6993                        server
6994                            .notify::<lsp::notification::DidChangeWatchedFiles>(params)
6995                            .log_err();
6996                    }
6997                }
6998            }
6999        }
7000    }
7001
7002    pub fn wait_for_remote_buffer(
7003        &mut self,
7004        id: BufferId,
7005        cx: &mut ModelContext<Self>,
7006    ) -> Task<Result<Model<Buffer>>> {
7007        self.buffer_store.update(cx, |buffer_store, cx| {
7008            buffer_store.wait_for_remote_buffer(id, cx)
7009        })
7010    }
7011
7012    pub(crate) fn language_server_ids_for_buffer(
7013        &self,
7014        buffer: &Buffer,
7015        cx: &AppContext,
7016    ) -> Vec<LanguageServerId> {
7017        if let Some((file, language)) = File::from_dyn(buffer.file()).zip(buffer.language()) {
7018            let worktree_id = file.worktree_id(cx);
7019            self.languages
7020                .lsp_adapters(&language.name())
7021                .iter()
7022                .flat_map(|adapter| {
7023                    let key = (worktree_id, adapter.name.clone());
7024                    self.language_server_ids.get(&key).copied()
7025                })
7026                .collect()
7027        } else {
7028            Vec::new()
7029        }
7030    }
7031
7032    pub async fn deserialize_text_edits(
7033        this: Model<Self>,
7034        buffer_to_edit: Model<Buffer>,
7035        edits: Vec<lsp::TextEdit>,
7036        push_to_history: bool,
7037        _: Arc<CachedLspAdapter>,
7038        language_server: Arc<LanguageServer>,
7039        cx: &mut AsyncAppContext,
7040    ) -> Result<Option<Transaction>> {
7041        let edits = this
7042            .update(cx, |this, cx| {
7043                this.edits_from_lsp(
7044                    &buffer_to_edit,
7045                    edits,
7046                    language_server.server_id(),
7047                    None,
7048                    cx,
7049                )
7050            })?
7051            .await?;
7052
7053        let transaction = buffer_to_edit.update(cx, |buffer, cx| {
7054            buffer.finalize_last_transaction();
7055            buffer.start_transaction();
7056            for (range, text) in edits {
7057                buffer.edit([(range, text)], None, cx);
7058            }
7059
7060            if buffer.end_transaction(cx).is_some() {
7061                let transaction = buffer.finalize_last_transaction().unwrap().clone();
7062                if !push_to_history {
7063                    buffer.forget_transaction(transaction.id);
7064                }
7065                Some(transaction)
7066            } else {
7067                None
7068            }
7069        })?;
7070
7071        Ok(transaction)
7072    }
7073
7074    pub async fn deserialize_workspace_edit(
7075        this: Model<Self>,
7076        edit: lsp::WorkspaceEdit,
7077        push_to_history: bool,
7078        lsp_adapter: Arc<CachedLspAdapter>,
7079        language_server: Arc<LanguageServer>,
7080        cx: &mut AsyncAppContext,
7081    ) -> Result<ProjectTransaction> {
7082        let fs = this.read_with(cx, |this, _| this.as_local().unwrap().fs.clone())?;
7083
7084        let mut operations = Vec::new();
7085        if let Some(document_changes) = edit.document_changes {
7086            match document_changes {
7087                lsp::DocumentChanges::Edits(edits) => {
7088                    operations.extend(edits.into_iter().map(lsp::DocumentChangeOperation::Edit))
7089                }
7090                lsp::DocumentChanges::Operations(ops) => operations = ops,
7091            }
7092        } else if let Some(changes) = edit.changes {
7093            operations.extend(changes.into_iter().map(|(uri, edits)| {
7094                lsp::DocumentChangeOperation::Edit(lsp::TextDocumentEdit {
7095                    text_document: lsp::OptionalVersionedTextDocumentIdentifier {
7096                        uri,
7097                        version: None,
7098                    },
7099                    edits: edits.into_iter().map(Edit::Plain).collect(),
7100                })
7101            }));
7102        }
7103
7104        let mut project_transaction = ProjectTransaction::default();
7105        for operation in operations {
7106            match operation {
7107                lsp::DocumentChangeOperation::Op(lsp::ResourceOp::Create(op)) => {
7108                    let abs_path = op
7109                        .uri
7110                        .to_file_path()
7111                        .map_err(|_| anyhow!("can't convert URI to path"))?;
7112
7113                    if let Some(parent_path) = abs_path.parent() {
7114                        fs.create_dir(parent_path).await?;
7115                    }
7116                    if abs_path.ends_with("/") {
7117                        fs.create_dir(&abs_path).await?;
7118                    } else {
7119                        fs.create_file(
7120                            &abs_path,
7121                            op.options
7122                                .map(|options| fs::CreateOptions {
7123                                    overwrite: options.overwrite.unwrap_or(false),
7124                                    ignore_if_exists: options.ignore_if_exists.unwrap_or(false),
7125                                })
7126                                .unwrap_or_default(),
7127                        )
7128                        .await?;
7129                    }
7130                }
7131
7132                lsp::DocumentChangeOperation::Op(lsp::ResourceOp::Rename(op)) => {
7133                    let source_abs_path = op
7134                        .old_uri
7135                        .to_file_path()
7136                        .map_err(|_| anyhow!("can't convert URI to path"))?;
7137                    let target_abs_path = op
7138                        .new_uri
7139                        .to_file_path()
7140                        .map_err(|_| anyhow!("can't convert URI to path"))?;
7141                    fs.rename(
7142                        &source_abs_path,
7143                        &target_abs_path,
7144                        op.options
7145                            .map(|options| fs::RenameOptions {
7146                                overwrite: options.overwrite.unwrap_or(false),
7147                                ignore_if_exists: options.ignore_if_exists.unwrap_or(false),
7148                            })
7149                            .unwrap_or_default(),
7150                    )
7151                    .await?;
7152                }
7153
7154                lsp::DocumentChangeOperation::Op(lsp::ResourceOp::Delete(op)) => {
7155                    let abs_path = op
7156                        .uri
7157                        .to_file_path()
7158                        .map_err(|_| anyhow!("can't convert URI to path"))?;
7159                    let options = op
7160                        .options
7161                        .map(|options| fs::RemoveOptions {
7162                            recursive: options.recursive.unwrap_or(false),
7163                            ignore_if_not_exists: options.ignore_if_not_exists.unwrap_or(false),
7164                        })
7165                        .unwrap_or_default();
7166                    if abs_path.ends_with("/") {
7167                        fs.remove_dir(&abs_path, options).await?;
7168                    } else {
7169                        fs.remove_file(&abs_path, options).await?;
7170                    }
7171                }
7172
7173                lsp::DocumentChangeOperation::Edit(op) => {
7174                    let buffer_to_edit = this
7175                        .update(cx, |this, cx| {
7176                            this.open_local_buffer_via_lsp(
7177                                op.text_document.uri.clone(),
7178                                language_server.server_id(),
7179                                lsp_adapter.name.clone(),
7180                                cx,
7181                            )
7182                        })?
7183                        .await?;
7184
7185                    let edits = this
7186                        .update(cx, |this, cx| {
7187                            let path = buffer_to_edit.read(cx).project_path(cx);
7188                            let active_entry = this.active_entry;
7189                            let is_active_entry = path.clone().map_or(false, |project_path| {
7190                                this.worktree_store
7191                                    .read(cx)
7192                                    .entry_for_path(&project_path, cx)
7193                                    .map_or(false, |entry| Some(entry.id) == active_entry)
7194                            });
7195
7196                            let (mut edits, mut snippet_edits) = (vec![], vec![]);
7197                            for edit in op.edits {
7198                                match edit {
7199                                    Edit::Plain(edit) => edits.push(edit),
7200                                    Edit::Annotated(edit) => edits.push(edit.text_edit),
7201                                    Edit::Snippet(edit) => {
7202                                        let Ok(snippet) = Snippet::parse(&edit.snippet.value)
7203                                        else {
7204                                            continue;
7205                                        };
7206
7207                                        if is_active_entry {
7208                                            snippet_edits.push((edit.range, snippet));
7209                                        } else {
7210                                            // Since this buffer is not focused, apply a normal edit.
7211                                            edits.push(TextEdit {
7212                                                range: edit.range,
7213                                                new_text: snippet.text,
7214                                            });
7215                                        }
7216                                    }
7217                                }
7218                            }
7219                            if !snippet_edits.is_empty() {
7220                                let buffer_id = buffer_to_edit.read(cx).remote_id();
7221                                let version = if let Some(buffer_version) = op.text_document.version
7222                                {
7223                                    this.buffer_snapshot_for_lsp_version(
7224                                        &buffer_to_edit,
7225                                        language_server.server_id(),
7226                                        Some(buffer_version),
7227                                        cx,
7228                                    )
7229                                    .ok()
7230                                    .map(|snapshot| snapshot.version)
7231                                } else {
7232                                    Some(buffer_to_edit.read(cx).saved_version().clone())
7233                                };
7234
7235                                let most_recent_edit = version.and_then(|version| {
7236                                    version.iter().max_by_key(|timestamp| timestamp.value)
7237                                });
7238                                // Check if the edit that triggered that edit has been made by this participant.
7239
7240                                if let Some(most_recent_edit) = most_recent_edit {
7241                                    cx.emit(LspStoreEvent::SnippetEdit {
7242                                        buffer_id,
7243                                        edits: snippet_edits,
7244                                        most_recent_edit,
7245                                    });
7246                                }
7247                            }
7248
7249                            this.edits_from_lsp(
7250                                &buffer_to_edit,
7251                                edits,
7252                                language_server.server_id(),
7253                                op.text_document.version,
7254                                cx,
7255                            )
7256                        })?
7257                        .await?;
7258
7259                    let transaction = buffer_to_edit.update(cx, |buffer, cx| {
7260                        buffer.finalize_last_transaction();
7261                        buffer.start_transaction();
7262                        for (range, text) in edits {
7263                            buffer.edit([(range, text)], None, cx);
7264                        }
7265                        let transaction = if buffer.end_transaction(cx).is_some() {
7266                            let transaction = buffer.finalize_last_transaction().unwrap().clone();
7267                            if !push_to_history {
7268                                buffer.forget_transaction(transaction.id);
7269                            }
7270                            Some(transaction)
7271                        } else {
7272                            None
7273                        };
7274
7275                        transaction
7276                    })?;
7277                    if let Some(transaction) = transaction {
7278                        project_transaction.0.insert(buffer_to_edit, transaction);
7279                    }
7280                }
7281            }
7282        }
7283
7284        Ok(project_transaction)
7285    }
7286
7287    fn serialize_symbol(symbol: &Symbol) -> proto::Symbol {
7288        proto::Symbol {
7289            language_server_name: symbol.language_server_name.0.to_string(),
7290            source_worktree_id: symbol.source_worktree_id.to_proto(),
7291            worktree_id: symbol.path.worktree_id.to_proto(),
7292            path: symbol.path.path.to_string_lossy().to_string(),
7293            name: symbol.name.clone(),
7294            kind: unsafe { mem::transmute::<lsp::SymbolKind, i32>(symbol.kind) },
7295            start: Some(proto::PointUtf16 {
7296                row: symbol.range.start.0.row,
7297                column: symbol.range.start.0.column,
7298            }),
7299            end: Some(proto::PointUtf16 {
7300                row: symbol.range.end.0.row,
7301                column: symbol.range.end.0.column,
7302            }),
7303            signature: symbol.signature.to_vec(),
7304        }
7305    }
7306
7307    fn deserialize_symbol(serialized_symbol: proto::Symbol) -> Result<CoreSymbol> {
7308        let source_worktree_id = WorktreeId::from_proto(serialized_symbol.source_worktree_id);
7309        let worktree_id = WorktreeId::from_proto(serialized_symbol.worktree_id);
7310        let kind = unsafe { mem::transmute::<i32, lsp::SymbolKind>(serialized_symbol.kind) };
7311        let path = ProjectPath {
7312            worktree_id,
7313            path: PathBuf::from(serialized_symbol.path).into(),
7314        };
7315
7316        let start = serialized_symbol
7317            .start
7318            .ok_or_else(|| anyhow!("invalid start"))?;
7319        let end = serialized_symbol
7320            .end
7321            .ok_or_else(|| anyhow!("invalid end"))?;
7322        Ok(CoreSymbol {
7323            language_server_name: LanguageServerName(serialized_symbol.language_server_name.into()),
7324            source_worktree_id,
7325            path,
7326            name: serialized_symbol.name,
7327            range: Unclipped(PointUtf16::new(start.row, start.column))
7328                ..Unclipped(PointUtf16::new(end.row, end.column)),
7329            kind,
7330            signature: serialized_symbol
7331                .signature
7332                .try_into()
7333                .map_err(|_| anyhow!("invalid signature"))?,
7334        })
7335    }
7336
7337    pub(crate) fn serialize_completion(completion: &CoreCompletion) -> proto::Completion {
7338        proto::Completion {
7339            old_start: Some(serialize_anchor(&completion.old_range.start)),
7340            old_end: Some(serialize_anchor(&completion.old_range.end)),
7341            new_text: completion.new_text.clone(),
7342            server_id: completion.server_id.0 as u64,
7343            lsp_completion: serde_json::to_vec(&completion.lsp_completion).unwrap(),
7344        }
7345    }
7346
7347    pub(crate) fn deserialize_completion(completion: proto::Completion) -> Result<CoreCompletion> {
7348        let old_start = completion
7349            .old_start
7350            .and_then(deserialize_anchor)
7351            .ok_or_else(|| anyhow!("invalid old start"))?;
7352        let old_end = completion
7353            .old_end
7354            .and_then(deserialize_anchor)
7355            .ok_or_else(|| anyhow!("invalid old end"))?;
7356        let lsp_completion = serde_json::from_slice(&completion.lsp_completion)?;
7357
7358        Ok(CoreCompletion {
7359            old_range: old_start..old_end,
7360            new_text: completion.new_text,
7361            server_id: LanguageServerId(completion.server_id as usize),
7362            lsp_completion,
7363        })
7364    }
7365
7366    pub(crate) fn serialize_code_action(action: &CodeAction) -> proto::CodeAction {
7367        proto::CodeAction {
7368            server_id: action.server_id.0 as u64,
7369            start: Some(serialize_anchor(&action.range.start)),
7370            end: Some(serialize_anchor(&action.range.end)),
7371            lsp_action: serde_json::to_vec(&action.lsp_action).unwrap(),
7372        }
7373    }
7374
7375    pub(crate) fn deserialize_code_action(action: proto::CodeAction) -> Result<CodeAction> {
7376        let start = action
7377            .start
7378            .and_then(deserialize_anchor)
7379            .ok_or_else(|| anyhow!("invalid start"))?;
7380        let end = action
7381            .end
7382            .and_then(deserialize_anchor)
7383            .ok_or_else(|| anyhow!("invalid end"))?;
7384        let lsp_action = serde_json::from_slice(&action.lsp_action)?;
7385        Ok(CodeAction {
7386            server_id: LanguageServerId(action.server_id as usize),
7387            range: start..end,
7388            lsp_action,
7389        })
7390    }
7391
7392    fn update_last_formatting_failure<T>(&mut self, formatting_result: &anyhow::Result<T>) {
7393        match &formatting_result {
7394            Ok(_) => self.last_formatting_failure = None,
7395            Err(error) => {
7396                let error_string = format!("{error:#}");
7397                log::error!("Formatting failed: {error_string}");
7398                self.last_formatting_failure
7399                    .replace(error_string.lines().join(" "));
7400            }
7401        }
7402    }
7403}
7404
7405impl EventEmitter<LspStoreEvent> for LspStore {}
7406
7407fn remove_empty_hover_blocks(mut hover: Hover) -> Option<Hover> {
7408    hover
7409        .contents
7410        .retain(|hover_block| !hover_block.text.trim().is_empty());
7411    if hover.contents.is_empty() {
7412        None
7413    } else {
7414        Some(hover)
7415    }
7416}
7417
7418async fn populate_labels_for_completions(
7419    mut new_completions: Vec<CoreCompletion>,
7420    language_registry: &Arc<LanguageRegistry>,
7421    language: Option<Arc<Language>>,
7422    lsp_adapter: Option<Arc<CachedLspAdapter>>,
7423    completions: &mut Vec<Completion>,
7424) {
7425    let lsp_completions = new_completions
7426        .iter_mut()
7427        .map(|completion| mem::take(&mut completion.lsp_completion))
7428        .collect::<Vec<_>>();
7429
7430    let labels = if let Some((language, lsp_adapter)) = language.as_ref().zip(lsp_adapter) {
7431        lsp_adapter
7432            .labels_for_completions(&lsp_completions, language)
7433            .await
7434            .log_err()
7435            .unwrap_or_default()
7436    } else {
7437        Vec::new()
7438    };
7439
7440    for ((completion, lsp_completion), label) in new_completions
7441        .into_iter()
7442        .zip(lsp_completions)
7443        .zip(labels.into_iter().chain(iter::repeat(None)))
7444    {
7445        let documentation = if let Some(docs) = &lsp_completion.documentation {
7446            Some(prepare_completion_documentation(docs, language_registry, language.clone()).await)
7447        } else {
7448            None
7449        };
7450
7451        completions.push(Completion {
7452            old_range: completion.old_range,
7453            new_text: completion.new_text,
7454            label: label.unwrap_or_else(|| {
7455                CodeLabel::plain(
7456                    lsp_completion.label.clone(),
7457                    lsp_completion.filter_text.as_deref(),
7458                )
7459            }),
7460            server_id: completion.server_id,
7461            documentation,
7462            lsp_completion,
7463            confirm: None,
7464        })
7465    }
7466}
7467
7468#[derive(Debug)]
7469pub enum LanguageServerToQuery {
7470    Primary,
7471    Other(LanguageServerId),
7472}
7473
7474#[derive(Default)]
7475struct LanguageServerWatchedPaths {
7476    worktree_paths: HashMap<WorktreeId, GlobSet>,
7477    abs_paths: HashMap<Arc<Path>, (GlobSet, Task<()>)>,
7478}
7479
7480#[derive(Default)]
7481struct LanguageServerWatchedPathsBuilder {
7482    worktree_paths: HashMap<WorktreeId, GlobSet>,
7483    abs_paths: HashMap<Arc<Path>, GlobSet>,
7484}
7485
7486impl LanguageServerWatchedPathsBuilder {
7487    fn watch_worktree(&mut self, worktree_id: WorktreeId, glob_set: GlobSet) {
7488        self.worktree_paths.insert(worktree_id, glob_set);
7489    }
7490    fn watch_abs_path(&mut self, path: Arc<Path>, glob_set: GlobSet) {
7491        self.abs_paths.insert(path, glob_set);
7492    }
7493    fn build(
7494        self,
7495        fs: Arc<dyn Fs>,
7496        language_server_id: LanguageServerId,
7497        cx: &mut ModelContext<LspStore>,
7498    ) -> Model<LanguageServerWatchedPaths> {
7499        let project = cx.weak_model();
7500
7501        cx.new_model(|cx| {
7502                let this_id = cx.entity_id();
7503                const LSP_ABS_PATH_OBSERVE: Duration = Duration::from_millis(100);
7504                let abs_paths = self
7505                    .abs_paths
7506                    .into_iter()
7507                    .map(|(abs_path, globset)| {
7508                        let task = cx.spawn({
7509                            let abs_path = abs_path.clone();
7510                            let fs = fs.clone();
7511
7512                            let lsp_store = project.clone();
7513                            |_, mut cx| async move {
7514                                maybe!(async move {
7515                                    let mut push_updates =
7516                                        fs.watch(&abs_path, LSP_ABS_PATH_OBSERVE).await;
7517                                    while let Some(update) = push_updates.0.next().await {
7518                                        let action = lsp_store
7519                                            .update(&mut cx, |this, cx| {
7520                                                let Some(local) = this.as_local() else {
7521                                                    return ControlFlow::Break(());
7522                                                };
7523                                                let Some(watcher) = local
7524                                                    .language_server_watched_paths
7525                                                    .get(&language_server_id)
7526                                                else {
7527                                                    return ControlFlow::Break(());
7528                                                };
7529                                                if watcher.entity_id() != this_id {
7530                                                    // This watcher is no longer registered on the project, which means that we should
7531                                                    // cease operations.
7532                                                    return ControlFlow::Break(());
7533                                                }
7534                                                let (globs, _) = watcher
7535                                                    .read(cx)
7536                                                    .abs_paths
7537                                                    .get(&abs_path)
7538                                                    .expect(
7539                                                    "Watched abs path is not registered with a watcher",
7540                                                );
7541                                                let matching_entries = update
7542                                                    .into_iter()
7543                                                    .filter(|event| globs.is_match(&event.path))
7544                                                    .collect::<Vec<_>>();
7545                                                this.lsp_notify_abs_paths_changed(
7546                                                    language_server_id,
7547                                                    matching_entries,
7548                                                );
7549                                                ControlFlow::Continue(())
7550                                            })
7551                                            .ok()?;
7552
7553                                        if action.is_break() {
7554                                            break;
7555                                        }
7556                                    }
7557                                    Some(())
7558                                })
7559                                    .await;
7560                            }
7561                        });
7562                        (abs_path, (globset, task))
7563                    })
7564                    .collect();
7565                LanguageServerWatchedPaths {
7566                    worktree_paths: self.worktree_paths,
7567                    abs_paths,
7568                }
7569            })
7570    }
7571}
7572
7573struct LspBufferSnapshot {
7574    version: i32,
7575    snapshot: TextBufferSnapshot,
7576}
7577
7578/// A prompt requested by LSP server.
7579#[derive(Clone, Debug)]
7580pub struct LanguageServerPromptRequest {
7581    pub level: PromptLevel,
7582    pub message: String,
7583    pub actions: Vec<MessageActionItem>,
7584    pub lsp_name: String,
7585    pub(crate) response_channel: Sender<MessageActionItem>,
7586}
7587
7588impl LanguageServerPromptRequest {
7589    pub async fn respond(self, index: usize) -> Option<()> {
7590        if let Some(response) = self.actions.into_iter().nth(index) {
7591            self.response_channel.send(response).await.ok()
7592        } else {
7593            None
7594        }
7595    }
7596}
7597impl PartialEq for LanguageServerPromptRequest {
7598    fn eq(&self, other: &Self) -> bool {
7599        self.message == other.message && self.actions == other.actions
7600    }
7601}
7602
7603#[derive(Clone, Debug, PartialEq)]
7604pub enum LanguageServerLogType {
7605    Log(MessageType),
7606    Trace(Option<String>),
7607}
7608
7609impl LanguageServerLogType {
7610    pub fn to_proto(&self) -> proto::language_server_log::LogType {
7611        match self {
7612            Self::Log(log_type) => {
7613                let message_type = match *log_type {
7614                    MessageType::ERROR => 1,
7615                    MessageType::WARNING => 2,
7616                    MessageType::INFO => 3,
7617                    MessageType::LOG => 4,
7618                    other => {
7619                        log::warn!("Unknown lsp log message type: {:?}", other);
7620                        4
7621                    }
7622                };
7623                proto::language_server_log::LogType::LogMessageType(message_type)
7624            }
7625            Self::Trace(message) => {
7626                proto::language_server_log::LogType::LogTrace(proto::LspLogTrace {
7627                    message: message.clone(),
7628                })
7629            }
7630        }
7631    }
7632
7633    pub fn from_proto(log_type: proto::language_server_log::LogType) -> Self {
7634        match log_type {
7635            proto::language_server_log::LogType::LogMessageType(message_type) => {
7636                Self::Log(match message_type {
7637                    1 => MessageType::ERROR,
7638                    2 => MessageType::WARNING,
7639                    3 => MessageType::INFO,
7640                    4 => MessageType::LOG,
7641                    _ => MessageType::LOG,
7642                })
7643            }
7644            proto::language_server_log::LogType::LogTrace(trace) => Self::Trace(trace.message),
7645        }
7646    }
7647}
7648
7649pub enum LanguageServerState {
7650    Starting(Task<Option<Arc<LanguageServer>>>),
7651
7652    Running {
7653        language: LanguageName,
7654        adapter: Arc<CachedLspAdapter>,
7655        server: Arc<LanguageServer>,
7656        simulate_disk_based_diagnostics_completion: Option<Task<()>>,
7657    },
7658}
7659
7660impl std::fmt::Debug for LanguageServerState {
7661    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7662        match self {
7663            LanguageServerState::Starting(_) => {
7664                f.debug_struct("LanguageServerState::Starting").finish()
7665            }
7666            LanguageServerState::Running { language, .. } => f
7667                .debug_struct("LanguageServerState::Running")
7668                .field("language", &language)
7669                .finish(),
7670        }
7671    }
7672}
7673
7674#[derive(Clone, Debug, Serialize)]
7675pub struct LanguageServerProgress {
7676    pub is_disk_based_diagnostics_progress: bool,
7677    pub is_cancellable: bool,
7678    pub title: Option<String>,
7679    pub message: Option<String>,
7680    pub percentage: Option<usize>,
7681    #[serde(skip_serializing)]
7682    pub last_update_at: Instant,
7683}
7684
7685#[derive(Copy, Clone, Debug, Default, PartialEq, Serialize)]
7686pub struct DiagnosticSummary {
7687    pub error_count: usize,
7688    pub warning_count: usize,
7689}
7690
7691impl DiagnosticSummary {
7692    pub fn new<'a, T: 'a>(diagnostics: impl IntoIterator<Item = &'a DiagnosticEntry<T>>) -> Self {
7693        let mut this = Self {
7694            error_count: 0,
7695            warning_count: 0,
7696        };
7697
7698        for entry in diagnostics {
7699            if entry.diagnostic.is_primary {
7700                match entry.diagnostic.severity {
7701                    DiagnosticSeverity::ERROR => this.error_count += 1,
7702                    DiagnosticSeverity::WARNING => this.warning_count += 1,
7703                    _ => {}
7704                }
7705            }
7706        }
7707
7708        this
7709    }
7710
7711    pub fn is_empty(&self) -> bool {
7712        self.error_count == 0 && self.warning_count == 0
7713    }
7714
7715    pub fn to_proto(
7716        &self,
7717        language_server_id: LanguageServerId,
7718        path: &Path,
7719    ) -> proto::DiagnosticSummary {
7720        proto::DiagnosticSummary {
7721            path: path.to_string_lossy().to_string(),
7722            language_server_id: language_server_id.0 as u64,
7723            error_count: self.error_count as u32,
7724            warning_count: self.warning_count as u32,
7725        }
7726    }
7727}
7728
7729fn glob_literal_prefix(glob: &str) -> &str {
7730    let is_absolute = glob.starts_with(path::MAIN_SEPARATOR);
7731
7732    let mut literal_end = is_absolute as usize;
7733    for (i, part) in glob.split(path::MAIN_SEPARATOR).enumerate() {
7734        if part.contains(['*', '?', '{', '}']) {
7735            break;
7736        } else {
7737            if i > 0 {
7738                // Account for separator prior to this part
7739                literal_end += path::MAIN_SEPARATOR.len_utf8();
7740            }
7741            literal_end += part.len();
7742        }
7743    }
7744    let literal_end = literal_end.min(glob.len());
7745    &glob[..literal_end]
7746}
7747
7748pub struct SshLspAdapter {
7749    name: LanguageServerName,
7750    binary: LanguageServerBinary,
7751    initialization_options: Option<String>,
7752    code_action_kinds: Option<Vec<CodeActionKind>>,
7753}
7754
7755impl SshLspAdapter {
7756    pub fn new(
7757        name: LanguageServerName,
7758        binary: LanguageServerBinary,
7759        initialization_options: Option<String>,
7760        code_action_kinds: Option<String>,
7761    ) -> Self {
7762        Self {
7763            name,
7764            binary,
7765            initialization_options,
7766            code_action_kinds: code_action_kinds
7767                .as_ref()
7768                .and_then(|c| serde_json::from_str(c).ok()),
7769        }
7770    }
7771}
7772
7773#[async_trait(?Send)]
7774impl LspAdapter for SshLspAdapter {
7775    fn name(&self) -> LanguageServerName {
7776        self.name.clone()
7777    }
7778
7779    async fn initialization_options(
7780        self: Arc<Self>,
7781        _: &Arc<dyn LspAdapterDelegate>,
7782    ) -> Result<Option<serde_json::Value>> {
7783        let Some(options) = &self.initialization_options else {
7784            return Ok(None);
7785        };
7786        let result = serde_json::from_str(options)?;
7787        Ok(result)
7788    }
7789
7790    fn code_action_kinds(&self) -> Option<Vec<CodeActionKind>> {
7791        self.code_action_kinds.clone()
7792    }
7793
7794    async fn check_if_user_installed(
7795        &self,
7796        _: &dyn LspAdapterDelegate,
7797        _: &AsyncAppContext,
7798    ) -> Option<LanguageServerBinary> {
7799        Some(self.binary.clone())
7800    }
7801
7802    async fn cached_server_binary(
7803        &self,
7804        _: PathBuf,
7805        _: &dyn LspAdapterDelegate,
7806    ) -> Option<LanguageServerBinary> {
7807        None
7808    }
7809
7810    async fn fetch_latest_server_version(
7811        &self,
7812        _: &dyn LspAdapterDelegate,
7813    ) -> Result<Box<dyn 'static + Send + Any>> {
7814        anyhow::bail!("SshLspAdapter does not support fetch_latest_server_version")
7815    }
7816
7817    async fn fetch_server_binary(
7818        &self,
7819        _: Box<dyn 'static + Send + Any>,
7820        _: PathBuf,
7821        _: &dyn LspAdapterDelegate,
7822    ) -> Result<LanguageServerBinary> {
7823        anyhow::bail!("SshLspAdapter does not support fetch_server_binary")
7824    }
7825}
7826
7827pub fn language_server_settings<'a, 'b: 'a>(
7828    delegate: &'a dyn LspAdapterDelegate,
7829    language: &LanguageServerName,
7830    cx: &'b AppContext,
7831) -> Option<&'a LspSettings> {
7832    ProjectSettings::get(
7833        Some(SettingsLocation {
7834            worktree_id: delegate.worktree_id(),
7835            path: delegate.worktree_root_path(),
7836        }),
7837        cx,
7838    )
7839    .lsp
7840    .get(language)
7841}
7842
7843pub struct LocalLspAdapterDelegate {
7844    lsp_store: WeakModel<LspStore>,
7845    worktree: worktree::Snapshot,
7846    fs: Arc<dyn Fs>,
7847    http_client: Arc<dyn HttpClient>,
7848    language_registry: Arc<LanguageRegistry>,
7849    load_shell_env_task: Shared<Task<Option<HashMap<String, String>>>>,
7850}
7851
7852impl LocalLspAdapterDelegate {
7853    fn for_local(
7854        lsp_store: &LspStore,
7855        worktree: &Model<Worktree>,
7856        cx: &mut ModelContext<LspStore>,
7857    ) -> Arc<Self> {
7858        let local = lsp_store
7859            .as_local()
7860            .expect("LocalLspAdapterDelegate cannot be constructed on a remote");
7861
7862        let http_client = local.http_client.clone();
7863
7864        Self::new(lsp_store, worktree, http_client, local.fs.clone(), cx)
7865    }
7866
7867    pub fn new(
7868        lsp_store: &LspStore,
7869        worktree: &Model<Worktree>,
7870        http_client: Arc<dyn HttpClient>,
7871        fs: Arc<dyn Fs>,
7872        cx: &mut ModelContext<LspStore>,
7873    ) -> Arc<Self> {
7874        let worktree_id = worktree.read(cx).id();
7875        let worktree_abs_path = worktree.read(cx).abs_path();
7876        let load_shell_env_task = if let Some(environment) =
7877            &lsp_store.as_local().map(|local| local.environment.clone())
7878        {
7879            environment.update(cx, |env, cx| {
7880                env.get_environment(Some(worktree_id), Some(worktree_abs_path), cx)
7881            })
7882        } else {
7883            Task::ready(None).shared()
7884        };
7885
7886        Arc::new(Self {
7887            lsp_store: cx.weak_model(),
7888            worktree: worktree.read(cx).snapshot(),
7889            fs,
7890            http_client,
7891            language_registry: lsp_store.languages.clone(),
7892            load_shell_env_task,
7893        })
7894    }
7895}
7896
7897#[async_trait]
7898impl LspAdapterDelegate for LocalLspAdapterDelegate {
7899    fn show_notification(&self, message: &str, cx: &mut AppContext) {
7900        self.lsp_store
7901            .update(cx, |_, cx| {
7902                cx.emit(LspStoreEvent::Notification(message.to_owned()))
7903            })
7904            .ok();
7905    }
7906
7907    fn http_client(&self) -> Arc<dyn HttpClient> {
7908        self.http_client.clone()
7909    }
7910
7911    fn worktree_id(&self) -> WorktreeId {
7912        self.worktree.id()
7913    }
7914
7915    fn worktree_root_path(&self) -> &Path {
7916        self.worktree.abs_path().as_ref()
7917    }
7918
7919    async fn shell_env(&self) -> HashMap<String, String> {
7920        let task = self.load_shell_env_task.clone();
7921        task.await.unwrap_or_default()
7922    }
7923
7924    async fn npm_package_installed_version(
7925        &self,
7926        package_name: &str,
7927    ) -> Result<Option<(PathBuf, String)>> {
7928        let local_package_directory = self.worktree_root_path();
7929        let node_modules_directory = local_package_directory.join("node_modules");
7930
7931        if let Some(version) =
7932            read_package_installed_version(node_modules_directory.clone(), package_name).await?
7933        {
7934            return Ok(Some((node_modules_directory, version)));
7935        }
7936        let Some(npm) = self.which("npm".as_ref()).await else {
7937            log::warn!(
7938                "Failed to find npm executable for {:?}",
7939                local_package_directory
7940            );
7941            return Ok(None);
7942        };
7943
7944        let env = self.shell_env().await;
7945        let output = smol::process::Command::new(&npm)
7946            .args(["root", "-g"])
7947            .envs(env)
7948            .current_dir(local_package_directory)
7949            .output()
7950            .await?;
7951        let global_node_modules =
7952            PathBuf::from(String::from_utf8_lossy(&output.stdout).to_string());
7953
7954        if let Some(version) =
7955            read_package_installed_version(global_node_modules.clone(), package_name).await?
7956        {
7957            return Ok(Some((global_node_modules, version)));
7958        }
7959        return Ok(None);
7960    }
7961
7962    #[cfg(not(target_os = "windows"))]
7963    async fn which(&self, command: &OsStr) -> Option<PathBuf> {
7964        let worktree_abs_path = self.worktree.abs_path();
7965        let shell_path = self.shell_env().await.get("PATH").cloned();
7966        which::which_in(command, shell_path.as_ref(), worktree_abs_path).ok()
7967    }
7968
7969    #[cfg(target_os = "windows")]
7970    async fn which(&self, command: &OsStr) -> Option<PathBuf> {
7971        // todo(windows) Getting the shell env variables in a current directory on Windows is more complicated than other platforms
7972        //               there isn't a 'default shell' necessarily. The closest would be the default profile on the windows terminal
7973        //               SEE: https://learn.microsoft.com/en-us/windows/terminal/customize-settings/startup
7974        which::which(command).ok()
7975    }
7976
7977    async fn try_exec(&self, command: LanguageServerBinary) -> Result<()> {
7978        let working_dir = self.worktree_root_path();
7979        let output = smol::process::Command::new(&command.path)
7980            .args(command.arguments)
7981            .envs(command.env.clone().unwrap_or_default())
7982            .current_dir(working_dir)
7983            .output()
7984            .await?;
7985
7986        if output.status.success() {
7987            return Ok(());
7988        }
7989        Err(anyhow!(
7990            "{}, stdout: {:?}, stderr: {:?}",
7991            output.status,
7992            String::from_utf8_lossy(&output.stdout),
7993            String::from_utf8_lossy(&output.stderr)
7994        ))
7995    }
7996
7997    fn update_status(
7998        &self,
7999        server_name: LanguageServerName,
8000        status: language::LanguageServerBinaryStatus,
8001    ) {
8002        self.language_registry
8003            .update_lsp_status(server_name, status);
8004    }
8005
8006    async fn language_server_download_dir(&self, name: &LanguageServerName) -> Option<Arc<Path>> {
8007        let dir = self.language_registry.language_server_download_dir(name)?;
8008
8009        if !dir.exists() {
8010            smol::fs::create_dir_all(&dir)
8011                .await
8012                .context("failed to create container directory")
8013                .log_err()?;
8014        }
8015
8016        Some(dir)
8017    }
8018
8019    async fn read_text_file(&self, path: PathBuf) -> Result<String> {
8020        let entry = self
8021            .worktree
8022            .entry_for_path(&path)
8023            .with_context(|| format!("no worktree entry for path {path:?}"))?;
8024        let abs_path = self
8025            .worktree
8026            .absolutize(&entry.path)
8027            .with_context(|| format!("cannot absolutize path {path:?}"))?;
8028
8029        self.fs.load(&abs_path).await
8030    }
8031}
8032
8033async fn populate_labels_for_symbols(
8034    symbols: Vec<CoreSymbol>,
8035    language_registry: &Arc<LanguageRegistry>,
8036    default_language: Option<LanguageName>,
8037    lsp_adapter: Option<Arc<CachedLspAdapter>>,
8038    output: &mut Vec<Symbol>,
8039) {
8040    #[allow(clippy::mutable_key_type)]
8041    let mut symbols_by_language = HashMap::<Option<Arc<Language>>, Vec<CoreSymbol>>::default();
8042
8043    let mut unknown_path = None;
8044    for symbol in symbols {
8045        let language = language_registry
8046            .language_for_file_path(&symbol.path.path)
8047            .await
8048            .ok()
8049            .or_else(|| {
8050                unknown_path.get_or_insert(symbol.path.path.clone());
8051                default_language.as_ref().and_then(|name| {
8052                    language_registry
8053                        .language_for_name(&name.0)
8054                        .now_or_never()?
8055                        .ok()
8056                })
8057            });
8058        symbols_by_language
8059            .entry(language)
8060            .or_default()
8061            .push(symbol);
8062    }
8063
8064    if let Some(unknown_path) = unknown_path {
8065        log::info!(
8066            "no language found for symbol path {}",
8067            unknown_path.display()
8068        );
8069    }
8070
8071    let mut label_params = Vec::new();
8072    for (language, mut symbols) in symbols_by_language {
8073        label_params.clear();
8074        label_params.extend(
8075            symbols
8076                .iter_mut()
8077                .map(|symbol| (mem::take(&mut symbol.name), symbol.kind)),
8078        );
8079
8080        let mut labels = Vec::new();
8081        if let Some(language) = language {
8082            let lsp_adapter = lsp_adapter.clone().or_else(|| {
8083                language_registry
8084                    .lsp_adapters(&language.name())
8085                    .first()
8086                    .cloned()
8087            });
8088            if let Some(lsp_adapter) = lsp_adapter {
8089                labels = lsp_adapter
8090                    .labels_for_symbols(&label_params, &language)
8091                    .await
8092                    .log_err()
8093                    .unwrap_or_default();
8094            }
8095        }
8096
8097        for ((symbol, (name, _)), label) in symbols
8098            .into_iter()
8099            .zip(label_params.drain(..))
8100            .zip(labels.into_iter().chain(iter::repeat(None)))
8101        {
8102            output.push(Symbol {
8103                language_server_name: symbol.language_server_name,
8104                source_worktree_id: symbol.source_worktree_id,
8105                path: symbol.path,
8106                label: label.unwrap_or_else(|| CodeLabel::plain(name.clone(), None)),
8107                name,
8108                kind: symbol.kind,
8109                range: symbol.range,
8110                signature: symbol.signature,
8111            });
8112        }
8113    }
8114}
8115
8116fn include_text(server: &lsp::LanguageServer) -> Option<bool> {
8117    match server.capabilities().text_document_sync.as_ref()? {
8118        lsp::TextDocumentSyncCapability::Kind(kind) => match *kind {
8119            lsp::TextDocumentSyncKind::NONE => None,
8120            lsp::TextDocumentSyncKind::FULL => Some(true),
8121            lsp::TextDocumentSyncKind::INCREMENTAL => Some(false),
8122            _ => None,
8123        },
8124        lsp::TextDocumentSyncCapability::Options(options) => match options.save.as_ref()? {
8125            lsp::TextDocumentSyncSaveOptions::Supported(supported) => {
8126                if *supported {
8127                    Some(true)
8128                } else {
8129                    None
8130                }
8131            }
8132            lsp::TextDocumentSyncSaveOptions::SaveOptions(save_options) => {
8133                Some(save_options.include_text.unwrap_or(false))
8134            }
8135        },
8136    }
8137}
8138
8139#[cfg(test)]
8140#[test]
8141fn test_glob_literal_prefix() {
8142    assert_eq!(glob_literal_prefix("**/*.js"), "");
8143    assert_eq!(glob_literal_prefix("node_modules/**/*.js"), "node_modules");
8144    assert_eq!(glob_literal_prefix("foo/{bar,baz}.js"), "foo");
8145    assert_eq!(glob_literal_prefix("foo/bar/baz.js"), "foo/bar/baz.js");
8146}