1pub mod items;
   2mod toolbar_controls;
   3
   4mod buffer_diagnostics;
   5mod diagnostic_renderer;
   6
   7#[cfg(test)]
   8mod diagnostics_tests;
   9
  10use anyhow::Result;
  11use buffer_diagnostics::BufferDiagnosticsEditor;
  12use collections::{BTreeSet, HashMap, HashSet};
  13use diagnostic_renderer::DiagnosticBlock;
  14use editor::{
  15    Editor, EditorEvent, ExcerptRange, MultiBuffer, PathKey,
  16    display_map::{BlockPlacement, BlockProperties, BlockStyle, CustomBlockId},
  17    multibuffer_context_lines,
  18};
  19use gpui::{
  20    AnyElement, AnyView, App, AsyncApp, Context, Entity, EventEmitter, FocusHandle, FocusOutEvent,
  21    Focusable, Global, InteractiveElement, IntoElement, ParentElement, Render, SharedString,
  22    Styled, Subscription, Task, WeakEntity, Window, actions, div,
  23};
  24use itertools::Itertools as _;
  25use language::{
  26    Bias, Buffer, BufferRow, BufferSnapshot, DiagnosticEntry, DiagnosticEntryRef, Point,
  27    ToTreeSitterPoint,
  28};
  29use project::{
  30    DiagnosticSummary, Project, ProjectPath,
  31    project_settings::{DiagnosticSeverity, ProjectSettings},
  32};
  33use settings::Settings;
  34use std::{
  35    any::{Any, TypeId},
  36    cmp,
  37    ops::{Range, RangeInclusive},
  38    sync::Arc,
  39    time::Duration,
  40};
  41use text::{BufferId, OffsetRangeExt};
  42use theme::ActiveTheme;
  43use toolbar_controls::DiagnosticsToolbarEditor;
  44pub use toolbar_controls::ToolbarControls;
  45use ui::{Icon, IconName, Label, h_flex, prelude::*};
  46use util::ResultExt;
  47use workspace::{
  48    ItemNavHistory, ToolbarItemLocation, Workspace,
  49    item::{BreadcrumbText, Item, ItemEvent, ItemHandle, SaveOptions, TabContentParams},
  50    searchable::SearchableItemHandle,
  51};
  52
  53actions!(
  54    diagnostics,
  55    [
  56        /// Opens the project diagnostics view.
  57        Deploy,
  58        /// Toggles the display of warning-level diagnostics.
  59        ToggleWarnings,
  60        /// Toggles automatic refresh of diagnostics.
  61        ToggleDiagnosticsRefresh
  62    ]
  63);
  64
  65#[derive(Default)]
  66pub(crate) struct IncludeWarnings(bool);
  67impl Global for IncludeWarnings {}
  68
  69pub fn init(cx: &mut App) {
  70    editor::set_diagnostic_renderer(diagnostic_renderer::DiagnosticRenderer {}, cx);
  71    cx.observe_new(ProjectDiagnosticsEditor::register).detach();
  72    cx.observe_new(BufferDiagnosticsEditor::register).detach();
  73}
  74
  75pub(crate) struct ProjectDiagnosticsEditor {
  76    project: Entity<Project>,
  77    workspace: WeakEntity<Workspace>,
  78    focus_handle: FocusHandle,
  79    editor: Entity<Editor>,
  80    diagnostics: HashMap<BufferId, Vec<DiagnosticEntry<text::Anchor>>>,
  81    blocks: HashMap<BufferId, Vec<CustomBlockId>>,
  82    summary: DiagnosticSummary,
  83    multibuffer: Entity<MultiBuffer>,
  84    paths_to_update: BTreeSet<ProjectPath>,
  85    include_warnings: bool,
  86    update_excerpts_task: Option<Task<Result<()>>>,
  87    diagnostic_summary_update: Task<()>,
  88    _subscription: Subscription,
  89}
  90
  91impl EventEmitter<EditorEvent> for ProjectDiagnosticsEditor {}
  92
  93const DIAGNOSTICS_UPDATE_DEBOUNCE: Duration = Duration::from_millis(50);
  94const DIAGNOSTICS_SUMMARY_UPDATE_DEBOUNCE: Duration = Duration::from_millis(30);
  95
  96impl Render for ProjectDiagnosticsEditor {
  97    fn render(&mut self, _: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
  98        let warning_count = if self.include_warnings {
  99            self.summary.warning_count
 100        } else {
 101            0
 102        };
 103
 104        let child =
 105            if warning_count + self.summary.error_count == 0 && self.editor.read(cx).is_empty(cx) {
 106                let label = if self.summary.warning_count == 0 {
 107                    SharedString::new_static("No problems in workspace")
 108                } else {
 109                    SharedString::new_static("No errors in workspace")
 110                };
 111                v_flex()
 112                    .key_context("EmptyPane")
 113                    .size_full()
 114                    .gap_1()
 115                    .justify_center()
 116                    .items_center()
 117                    .text_center()
 118                    .bg(cx.theme().colors().editor_background)
 119                    .child(Label::new(label).color(Color::Muted))
 120                    .when(self.summary.warning_count > 0, |this| {
 121                        let plural_suffix = if self.summary.warning_count > 1 {
 122                            "s"
 123                        } else {
 124                            ""
 125                        };
 126                        let label = format!(
 127                            "Show {} warning{}",
 128                            self.summary.warning_count, plural_suffix
 129                        );
 130                        this.child(
 131                            Button::new("diagnostics-show-warning-label", label).on_click(
 132                                cx.listener(|this, _, window, cx| {
 133                                    this.toggle_warnings(&Default::default(), window, cx);
 134                                    cx.notify();
 135                                }),
 136                            ),
 137                        )
 138                    })
 139            } else {
 140                div().size_full().child(self.editor.clone())
 141            };
 142
 143        div()
 144            .key_context("Diagnostics")
 145            .track_focus(&self.focus_handle(cx))
 146            .size_full()
 147            .on_action(cx.listener(Self::toggle_warnings))
 148            .on_action(cx.listener(Self::toggle_diagnostics_refresh))
 149            .child(child)
 150    }
 151}
 152
 153#[derive(PartialEq, Eq, Copy, Clone, Debug)]
 154enum RetainExcerpts {
 155    All,
 156    Dirty,
 157}
 158
 159impl ProjectDiagnosticsEditor {
 160    pub fn register(
 161        workspace: &mut Workspace,
 162        _window: Option<&mut Window>,
 163        _: &mut Context<Workspace>,
 164    ) {
 165        workspace.register_action(Self::deploy);
 166    }
 167
 168    fn new(
 169        include_warnings: bool,
 170        project_handle: Entity<Project>,
 171        workspace: WeakEntity<Workspace>,
 172        window: &mut Window,
 173        cx: &mut Context<Self>,
 174    ) -> Self {
 175        let project_event_subscription = cx.subscribe_in(
 176            &project_handle,
 177            window,
 178            |this, _project, event, window, cx| match event {
 179                project::Event::DiskBasedDiagnosticsStarted { .. } => {
 180                    cx.notify();
 181                }
 182                project::Event::DiskBasedDiagnosticsFinished { language_server_id } => {
 183                    log::debug!("disk based diagnostics finished for server {language_server_id}");
 184                    this.close_diagnosticless_buffers(
 185                        window,
 186                        cx,
 187                        this.editor.focus_handle(cx).contains_focused(window, cx)
 188                            || this.focus_handle.contains_focused(window, cx),
 189                    );
 190                }
 191                project::Event::DiagnosticsUpdated {
 192                    language_server_id,
 193                    paths,
 194                } => {
 195                    this.paths_to_update.extend(paths.clone());
 196                    this.diagnostic_summary_update = cx.spawn(async move |this, cx| {
 197                        cx.background_executor()
 198                            .timer(DIAGNOSTICS_SUMMARY_UPDATE_DEBOUNCE)
 199                            .await;
 200                        this.update(cx, |this, cx| {
 201                            this.update_diagnostic_summary(cx);
 202                        })
 203                        .log_err();
 204                    });
 205
 206                    log::debug!(
 207                        "diagnostics updated for server {language_server_id}, \
 208                        paths {paths:?}. updating excerpts"
 209                    );
 210                    this.update_stale_excerpts(window, cx);
 211                }
 212                _ => {}
 213            },
 214        );
 215
 216        let focus_handle = cx.focus_handle();
 217        cx.on_focus_in(&focus_handle, window, Self::focus_in)
 218            .detach();
 219        cx.on_focus_out(&focus_handle, window, Self::focus_out)
 220            .detach();
 221
 222        let excerpts = cx.new(|cx| MultiBuffer::new(project_handle.read(cx).capability()));
 223        let editor = cx.new(|cx| {
 224            let mut editor =
 225                Editor::for_multibuffer(excerpts.clone(), Some(project_handle.clone()), window, cx);
 226            editor.set_vertical_scroll_margin(5, cx);
 227            editor.disable_inline_diagnostics();
 228            editor.set_max_diagnostics_severity(
 229                if include_warnings {
 230                    DiagnosticSeverity::Warning
 231                } else {
 232                    DiagnosticSeverity::Error
 233                },
 234                cx,
 235            );
 236            editor.set_all_diagnostics_active(cx);
 237            editor
 238        });
 239        cx.subscribe_in(
 240            &editor,
 241            window,
 242            |this, _editor, event: &EditorEvent, window, cx| {
 243                cx.emit(event.clone());
 244                match event {
 245                    EditorEvent::Focused => {
 246                        if this.multibuffer.read(cx).is_empty() {
 247                            window.focus(&this.focus_handle);
 248                        }
 249                    }
 250                    EditorEvent::Blurred => this.close_diagnosticless_buffers(window, cx, false),
 251                    EditorEvent::Saved => this.close_diagnosticless_buffers(window, cx, true),
 252                    EditorEvent::SelectionsChanged { .. } => {
 253                        this.close_diagnosticless_buffers(window, cx, true)
 254                    }
 255                    _ => {}
 256                }
 257            },
 258        )
 259        .detach();
 260        cx.observe_global_in::<IncludeWarnings>(window, |this, window, cx| {
 261            let include_warnings = cx.global::<IncludeWarnings>().0;
 262            this.include_warnings = include_warnings;
 263            this.editor.update(cx, |editor, cx| {
 264                editor.set_max_diagnostics_severity(
 265                    if include_warnings {
 266                        DiagnosticSeverity::Warning
 267                    } else {
 268                        DiagnosticSeverity::Error
 269                    },
 270                    cx,
 271                )
 272            });
 273            this.refresh(window, cx);
 274        })
 275        .detach();
 276
 277        let project = project_handle.read(cx);
 278        let mut this = Self {
 279            project: project_handle.clone(),
 280            summary: project.diagnostic_summary(false, cx),
 281            diagnostics: Default::default(),
 282            blocks: Default::default(),
 283            include_warnings,
 284            workspace,
 285            multibuffer: excerpts,
 286            focus_handle,
 287            editor,
 288            paths_to_update: Default::default(),
 289            update_excerpts_task: None,
 290            diagnostic_summary_update: Task::ready(()),
 291            _subscription: project_event_subscription,
 292        };
 293        this.refresh(window, cx);
 294        this
 295    }
 296
 297    /// Closes all excerpts of buffers that:
 298    ///  - have no diagnostics anymore
 299    ///  - are saved (not dirty)
 300    ///  - and, if `retain_selections` is true, do not have selections within them
 301    fn close_diagnosticless_buffers(
 302        &mut self,
 303        _window: &mut Window,
 304        cx: &mut Context<Self>,
 305        retain_selections: bool,
 306    ) {
 307        let snapshot = self
 308            .editor
 309            .update(cx, |editor, cx| editor.display_snapshot(cx));
 310        let buffer = self.multibuffer.read(cx);
 311        let buffer_ids = buffer.all_buffer_ids();
 312        let selected_buffers = self.editor.update(cx, |editor, _| {
 313            editor
 314                .selections
 315                .all_anchors(&snapshot)
 316                .iter()
 317                .filter_map(|anchor| anchor.start.buffer_id)
 318                .collect::<HashSet<_>>()
 319        });
 320        for buffer_id in buffer_ids {
 321            if retain_selections && selected_buffers.contains(&buffer_id) {
 322                continue;
 323            }
 324            let has_no_blocks = self
 325                .blocks
 326                .get(&buffer_id)
 327                .is_none_or(|blocks| blocks.is_empty());
 328            if !has_no_blocks {
 329                continue;
 330            }
 331            let is_dirty = self
 332                .multibuffer
 333                .read(cx)
 334                .buffer(buffer_id)
 335                .is_none_or(|buffer| buffer.read(cx).is_dirty());
 336            if is_dirty {
 337                continue;
 338            }
 339            self.multibuffer.update(cx, |b, cx| {
 340                b.remove_excerpts_for_buffer(buffer_id, cx);
 341            });
 342        }
 343    }
 344
 345    fn update_stale_excerpts(&mut self, window: &mut Window, cx: &mut Context<Self>) {
 346        if self.update_excerpts_task.is_some() {
 347            return;
 348        }
 349
 350        let project_handle = self.project.clone();
 351        self.update_excerpts_task = Some(cx.spawn_in(window, async move |this, cx| {
 352            cx.background_executor()
 353                .timer(DIAGNOSTICS_UPDATE_DEBOUNCE)
 354                .await;
 355            loop {
 356                let Some(path) = this.update(cx, |this, cx| {
 357                    let Some(path) = this.paths_to_update.pop_first() else {
 358                        this.update_excerpts_task = None;
 359                        cx.notify();
 360                        return None;
 361                    };
 362                    Some(path)
 363                })?
 364                else {
 365                    break;
 366                };
 367
 368                if let Some(buffer) = project_handle
 369                    .update(cx, |project, cx| project.open_buffer(path.clone(), cx))?
 370                    .await
 371                    .log_err()
 372                {
 373                    this.update_in(cx, |this, window, cx| {
 374                        let focused = this.editor.focus_handle(cx).contains_focused(window, cx)
 375                            || this.focus_handle.contains_focused(window, cx);
 376                        let retain_excerpts = if focused {
 377                            RetainExcerpts::All
 378                        } else {
 379                            RetainExcerpts::Dirty
 380                        };
 381                        this.update_excerpts(buffer, retain_excerpts, window, cx)
 382                    })?
 383                    .await?;
 384                }
 385            }
 386            Ok(())
 387        }));
 388    }
 389
 390    fn deploy(
 391        workspace: &mut Workspace,
 392        _: &Deploy,
 393        window: &mut Window,
 394        cx: &mut Context<Workspace>,
 395    ) {
 396        if let Some(existing) = workspace.item_of_type::<ProjectDiagnosticsEditor>(cx) {
 397            let is_active = workspace
 398                .active_item(cx)
 399                .is_some_and(|item| item.item_id() == existing.item_id());
 400
 401            workspace.activate_item(&existing, true, !is_active, window, cx);
 402        } else {
 403            let workspace_handle = cx.entity().downgrade();
 404
 405            let include_warnings = match cx.try_global::<IncludeWarnings>() {
 406                Some(include_warnings) => include_warnings.0,
 407                None => ProjectSettings::get_global(cx).diagnostics.include_warnings,
 408            };
 409
 410            let diagnostics = cx.new(|cx| {
 411                ProjectDiagnosticsEditor::new(
 412                    include_warnings,
 413                    workspace.project().clone(),
 414                    workspace_handle,
 415                    window,
 416                    cx,
 417                )
 418            });
 419            workspace.add_item_to_active_pane(Box::new(diagnostics), None, true, window, cx);
 420        }
 421    }
 422
 423    fn toggle_warnings(&mut self, _: &ToggleWarnings, _: &mut Window, cx: &mut Context<Self>) {
 424        cx.set_global(IncludeWarnings(!self.include_warnings));
 425    }
 426
 427    fn toggle_diagnostics_refresh(
 428        &mut self,
 429        _: &ToggleDiagnosticsRefresh,
 430        window: &mut Window,
 431        cx: &mut Context<Self>,
 432    ) {
 433        if self.update_excerpts_task.is_some() {
 434            self.update_excerpts_task = None;
 435        } else {
 436            self.refresh(window, cx);
 437        }
 438        cx.notify();
 439    }
 440
 441    fn focus_in(&mut self, window: &mut Window, cx: &mut Context<Self>) {
 442        if self.focus_handle.is_focused(window) && !self.multibuffer.read(cx).is_empty() {
 443            self.editor.focus_handle(cx).focus(window)
 444        }
 445    }
 446
 447    fn focus_out(&mut self, _: FocusOutEvent, window: &mut Window, cx: &mut Context<Self>) {
 448        if !self.focus_handle.is_focused(window) && !self.editor.focus_handle(cx).is_focused(window)
 449        {
 450            self.close_diagnosticless_buffers(window, cx, false);
 451        }
 452    }
 453
 454    /// Clears all diagnostics in this view, and refetches them from the project.
 455    fn refresh(&mut self, window: &mut Window, cx: &mut Context<Self>) {
 456        self.diagnostics.clear();
 457        self.editor.update(cx, |editor, cx| {
 458            for (_, block_ids) in self.blocks.drain() {
 459                editor.display_map.update(cx, |display_map, cx| {
 460                    display_map.remove_blocks(block_ids.into_iter().collect(), cx)
 461                });
 462            }
 463        });
 464        self.multibuffer
 465            .update(cx, |multibuffer, cx| multibuffer.clear(cx));
 466        self.project.update(cx, |project, cx| {
 467            self.paths_to_update = project
 468                .diagnostic_summaries(false, cx)
 469                .map(|(project_path, _, _)| project_path)
 470                .collect::<BTreeSet<_>>();
 471        });
 472
 473        self.update_stale_excerpts(window, cx);
 474    }
 475
 476    fn diagnostics_are_unchanged(
 477        &self,
 478        existing: &[DiagnosticEntry<text::Anchor>],
 479        new: &[DiagnosticEntryRef<'_, text::Anchor>],
 480        snapshot: &BufferSnapshot,
 481    ) -> bool {
 482        if existing.len() != new.len() {
 483            return false;
 484        }
 485        existing.iter().zip(new.iter()).all(|(existing, new)| {
 486            existing.diagnostic.message == new.diagnostic.message
 487                && existing.diagnostic.severity == new.diagnostic.severity
 488                && existing.diagnostic.is_primary == new.diagnostic.is_primary
 489                && existing.range.to_offset(snapshot) == new.range.to_offset(snapshot)
 490        })
 491    }
 492
 493    fn update_excerpts(
 494        &mut self,
 495        buffer: Entity<Buffer>,
 496        retain_excerpts: RetainExcerpts,
 497        window: &mut Window,
 498        cx: &mut Context<Self>,
 499    ) -> Task<Result<()>> {
 500        let was_empty = self.multibuffer.read(cx).is_empty();
 501        let buffer_snapshot = buffer.read(cx).snapshot();
 502        let buffer_id = buffer_snapshot.remote_id();
 503
 504        let max_severity = if self.include_warnings {
 505            lsp::DiagnosticSeverity::WARNING
 506        } else {
 507            lsp::DiagnosticSeverity::ERROR
 508        };
 509
 510        cx.spawn_in(window, async move |this, cx| {
 511            let diagnostics = buffer_snapshot
 512                .diagnostics_in_range::<_, text::Anchor>(
 513                    Point::zero()..buffer_snapshot.max_point(),
 514                    false,
 515                )
 516                .collect::<Vec<_>>();
 517
 518            let unchanged = this.update(cx, |this, _| {
 519                if this.diagnostics.get(&buffer_id).is_some_and(|existing| {
 520                    this.diagnostics_are_unchanged(existing, &diagnostics, &buffer_snapshot)
 521                }) {
 522                    return true;
 523                }
 524                this.diagnostics.insert(
 525                    buffer_id,
 526                    diagnostics
 527                        .iter()
 528                        .map(DiagnosticEntryRef::to_owned)
 529                        .collect(),
 530                );
 531                false
 532            })?;
 533            if unchanged {
 534                return Ok(());
 535            }
 536
 537            let mut grouped: HashMap<usize, Vec<_>> = HashMap::default();
 538            for entry in diagnostics {
 539                grouped
 540                    .entry(entry.diagnostic.group_id)
 541                    .or_default()
 542                    .push(DiagnosticEntryRef {
 543                        range: entry.range.to_point(&buffer_snapshot),
 544                        diagnostic: entry.diagnostic,
 545                    })
 546            }
 547            let mut blocks: Vec<DiagnosticBlock> = Vec::new();
 548
 549            for (_, group) in grouped {
 550                let group_severity = group.iter().map(|d| d.diagnostic.severity).min();
 551                if group_severity.is_none_or(|s| s > max_severity) {
 552                    continue;
 553                }
 554                let more = cx.update(|_, cx| {
 555                    crate::diagnostic_renderer::DiagnosticRenderer::diagnostic_blocks_for_group(
 556                        group,
 557                        buffer_snapshot.remote_id(),
 558                        Some(Arc::new(this.clone())),
 559                        cx,
 560                    )
 561                })?;
 562
 563                blocks.extend(more);
 564            }
 565
 566            let mut excerpt_ranges: Vec<ExcerptRange<Point>> = this.update(cx, |this, cx| {
 567                this.multibuffer.update(cx, |multi_buffer, cx| {
 568                    let is_dirty = multi_buffer
 569                        .buffer(buffer_id)
 570                        .is_none_or(|buffer| buffer.read(cx).is_dirty());
 571                    match retain_excerpts {
 572                        RetainExcerpts::Dirty if !is_dirty => Vec::new(),
 573                        RetainExcerpts::All | RetainExcerpts::Dirty => multi_buffer
 574                            .excerpts_for_buffer(buffer_id, cx)
 575                            .into_iter()
 576                            .map(|(_, range)| ExcerptRange {
 577                                context: range.context.to_point(&buffer_snapshot),
 578                                primary: range.primary.to_point(&buffer_snapshot),
 579                            })
 580                            .collect(),
 581                    }
 582                })
 583            })?;
 584            let mut result_blocks = vec![None; excerpt_ranges.len()];
 585            let context_lines = cx.update(|_, cx| multibuffer_context_lines(cx))?;
 586            for b in blocks {
 587                let excerpt_range = context_range_for_entry(
 588                    b.initial_range.clone(),
 589                    context_lines,
 590                    buffer_snapshot.clone(),
 591                    cx,
 592                )
 593                .await;
 594
 595                let i = excerpt_ranges
 596                    .binary_search_by(|probe| {
 597                        probe
 598                            .context
 599                            .start
 600                            .cmp(&excerpt_range.start)
 601                            .then(probe.context.end.cmp(&excerpt_range.end))
 602                            .then(probe.primary.start.cmp(&b.initial_range.start))
 603                            .then(probe.primary.end.cmp(&b.initial_range.end))
 604                            .then(cmp::Ordering::Greater)
 605                    })
 606                    .unwrap_or_else(|i| i);
 607                excerpt_ranges.insert(
 608                    i,
 609                    ExcerptRange {
 610                        context: excerpt_range,
 611                        primary: b.initial_range.clone(),
 612                    },
 613                );
 614                result_blocks.insert(i, Some(b));
 615            }
 616
 617            this.update_in(cx, |this, window, cx| {
 618                if let Some(block_ids) = this.blocks.remove(&buffer_id) {
 619                    this.editor.update(cx, |editor, cx| {
 620                        editor.display_map.update(cx, |display_map, cx| {
 621                            display_map.remove_blocks(block_ids.into_iter().collect(), cx)
 622                        });
 623                    })
 624                }
 625                let (anchor_ranges, _) = this.multibuffer.update(cx, |multi_buffer, cx| {
 626                    multi_buffer.set_excerpt_ranges_for_path(
 627                        PathKey::for_buffer(&buffer, cx),
 628                        buffer.clone(),
 629                        &buffer_snapshot,
 630                        excerpt_ranges,
 631                        cx,
 632                    )
 633                });
 634                #[cfg(test)]
 635                let cloned_blocks = result_blocks.clone();
 636
 637                if was_empty && let Some(anchor_range) = anchor_ranges.first() {
 638                    let range_to_select = anchor_range.start..anchor_range.start;
 639                    this.editor.update(cx, |editor, cx| {
 640                        editor.change_selections(Default::default(), window, cx, |s| {
 641                            s.select_anchor_ranges([range_to_select]);
 642                        })
 643                    });
 644                    if this.focus_handle.is_focused(window) {
 645                        this.editor.read(cx).focus_handle(cx).focus(window);
 646                    }
 647                }
 648
 649                let editor_blocks = anchor_ranges
 650                    .into_iter()
 651                    .zip_eq(result_blocks.into_iter())
 652                    .filter_map(|(anchor, block)| {
 653                        let block = block?;
 654                        let editor = this.editor.downgrade();
 655                        Some(BlockProperties {
 656                            placement: BlockPlacement::Near(anchor.start),
 657                            height: Some(1),
 658                            style: BlockStyle::Flex,
 659                            render: Arc::new(move |bcx| block.render_block(editor.clone(), bcx)),
 660                            priority: 1,
 661                        })
 662                    });
 663
 664                let block_ids = this.editor.update(cx, |editor, cx| {
 665                    editor.display_map.update(cx, |display_map, cx| {
 666                        display_map.insert_blocks(editor_blocks, cx)
 667                    })
 668                });
 669
 670                #[cfg(test)]
 671                {
 672                    for (block_id, block) in
 673                        block_ids.iter().zip(cloned_blocks.into_iter().flatten())
 674                    {
 675                        let markdown = block.markdown.clone();
 676                        editor::test::set_block_content_for_tests(
 677                            &this.editor,
 678                            *block_id,
 679                            cx,
 680                            move |cx| {
 681                                markdown::MarkdownElement::rendered_text(
 682                                    markdown.clone(),
 683                                    cx,
 684                                    editor::hover_popover::diagnostics_markdown_style,
 685                                )
 686                            },
 687                        );
 688                    }
 689                }
 690
 691                this.blocks.insert(buffer_id, block_ids);
 692                cx.notify()
 693            })
 694        })
 695    }
 696
 697    fn update_diagnostic_summary(&mut self, cx: &mut Context<Self>) {
 698        self.summary = self.project.read(cx).diagnostic_summary(false, cx);
 699        cx.emit(EditorEvent::TitleChanged);
 700    }
 701}
 702
 703impl Focusable for ProjectDiagnosticsEditor {
 704    fn focus_handle(&self, _: &App) -> FocusHandle {
 705        self.focus_handle.clone()
 706    }
 707}
 708
 709impl Item for ProjectDiagnosticsEditor {
 710    type Event = EditorEvent;
 711
 712    fn to_item_events(event: &EditorEvent, f: impl FnMut(ItemEvent)) {
 713        Editor::to_item_events(event, f)
 714    }
 715
 716    fn deactivated(&mut self, window: &mut Window, cx: &mut Context<Self>) {
 717        self.editor
 718            .update(cx, |editor, cx| editor.deactivated(window, cx));
 719    }
 720
 721    fn navigate(
 722        &mut self,
 723        data: Box<dyn Any>,
 724        window: &mut Window,
 725        cx: &mut Context<Self>,
 726    ) -> bool {
 727        self.editor
 728            .update(cx, |editor, cx| editor.navigate(data, window, cx))
 729    }
 730
 731    fn tab_tooltip_text(&self, _: &App) -> Option<SharedString> {
 732        Some("Project Diagnostics".into())
 733    }
 734
 735    fn tab_content_text(&self, _detail: usize, _: &App) -> SharedString {
 736        "Diagnostics".into()
 737    }
 738
 739    fn tab_content(&self, params: TabContentParams, _window: &Window, _: &App) -> AnyElement {
 740        h_flex()
 741            .gap_1()
 742            .when(
 743                self.summary.error_count == 0 && self.summary.warning_count == 0,
 744                |then| {
 745                    then.child(
 746                        h_flex()
 747                            .gap_1()
 748                            .child(Icon::new(IconName::Check).color(Color::Success))
 749                            .child(Label::new("No problems").color(params.text_color())),
 750                    )
 751                },
 752            )
 753            .when(self.summary.error_count > 0, |then| {
 754                then.child(
 755                    h_flex()
 756                        .gap_1()
 757                        .child(Icon::new(IconName::XCircle).color(Color::Error))
 758                        .child(
 759                            Label::new(self.summary.error_count.to_string())
 760                                .color(params.text_color()),
 761                        ),
 762                )
 763            })
 764            .when(self.summary.warning_count > 0, |then| {
 765                then.child(
 766                    h_flex()
 767                        .gap_1()
 768                        .child(Icon::new(IconName::Warning).color(Color::Warning))
 769                        .child(
 770                            Label::new(self.summary.warning_count.to_string())
 771                                .color(params.text_color()),
 772                        ),
 773                )
 774            })
 775            .into_any_element()
 776    }
 777
 778    fn telemetry_event_text(&self) -> Option<&'static str> {
 779        Some("Project Diagnostics Opened")
 780    }
 781
 782    fn for_each_project_item(
 783        &self,
 784        cx: &App,
 785        f: &mut dyn FnMut(gpui::EntityId, &dyn project::ProjectItem),
 786    ) {
 787        self.editor.for_each_project_item(cx, f)
 788    }
 789
 790    fn set_nav_history(
 791        &mut self,
 792        nav_history: ItemNavHistory,
 793        _: &mut Window,
 794        cx: &mut Context<Self>,
 795    ) {
 796        self.editor.update(cx, |editor, _| {
 797            editor.set_nav_history(Some(nav_history));
 798        });
 799    }
 800
 801    fn can_split(&self) -> bool {
 802        true
 803    }
 804
 805    fn clone_on_split(
 806        &self,
 807        _workspace_id: Option<workspace::WorkspaceId>,
 808        window: &mut Window,
 809        cx: &mut Context<Self>,
 810    ) -> Task<Option<Entity<Self>>>
 811    where
 812        Self: Sized,
 813    {
 814        Task::ready(Some(cx.new(|cx| {
 815            ProjectDiagnosticsEditor::new(
 816                self.include_warnings,
 817                self.project.clone(),
 818                self.workspace.clone(),
 819                window,
 820                cx,
 821            )
 822        })))
 823    }
 824
 825    fn is_dirty(&self, cx: &App) -> bool {
 826        self.multibuffer.read(cx).is_dirty(cx)
 827    }
 828
 829    fn has_deleted_file(&self, cx: &App) -> bool {
 830        self.multibuffer.read(cx).has_deleted_file(cx)
 831    }
 832
 833    fn has_conflict(&self, cx: &App) -> bool {
 834        self.multibuffer.read(cx).has_conflict(cx)
 835    }
 836
 837    fn can_save(&self, _: &App) -> bool {
 838        true
 839    }
 840
 841    fn save(
 842        &mut self,
 843        options: SaveOptions,
 844        project: Entity<Project>,
 845        window: &mut Window,
 846        cx: &mut Context<Self>,
 847    ) -> Task<Result<()>> {
 848        self.editor.save(options, project, window, cx)
 849    }
 850
 851    fn save_as(
 852        &mut self,
 853        _: Entity<Project>,
 854        _: ProjectPath,
 855        _window: &mut Window,
 856        _: &mut Context<Self>,
 857    ) -> Task<Result<()>> {
 858        unreachable!()
 859    }
 860
 861    fn reload(
 862        &mut self,
 863        project: Entity<Project>,
 864        window: &mut Window,
 865        cx: &mut Context<Self>,
 866    ) -> Task<Result<()>> {
 867        self.editor.reload(project, window, cx)
 868    }
 869
 870    fn act_as_type<'a>(
 871        &'a self,
 872        type_id: TypeId,
 873        self_handle: &'a Entity<Self>,
 874        _: &'a App,
 875    ) -> Option<AnyView> {
 876        if type_id == TypeId::of::<Self>() {
 877            Some(self_handle.to_any())
 878        } else if type_id == TypeId::of::<Editor>() {
 879            Some(self.editor.to_any())
 880        } else {
 881            None
 882        }
 883    }
 884
 885    fn as_searchable(&self, _: &Entity<Self>) -> Option<Box<dyn SearchableItemHandle>> {
 886        Some(Box::new(self.editor.clone()))
 887    }
 888
 889    fn breadcrumb_location(&self, _: &App) -> ToolbarItemLocation {
 890        ToolbarItemLocation::PrimaryLeft
 891    }
 892
 893    fn breadcrumbs(&self, theme: &theme::Theme, cx: &App) -> Option<Vec<BreadcrumbText>> {
 894        self.editor.breadcrumbs(theme, cx)
 895    }
 896
 897    fn added_to_workspace(
 898        &mut self,
 899        workspace: &mut Workspace,
 900        window: &mut Window,
 901        cx: &mut Context<Self>,
 902    ) {
 903        self.editor.update(cx, |editor, cx| {
 904            editor.added_to_workspace(workspace, window, cx)
 905        });
 906    }
 907}
 908
 909impl DiagnosticsToolbarEditor for WeakEntity<ProjectDiagnosticsEditor> {
 910    fn include_warnings(&self, cx: &App) -> bool {
 911        self.read_with(cx, |project_diagnostics_editor, _cx| {
 912            project_diagnostics_editor.include_warnings
 913        })
 914        .unwrap_or(false)
 915    }
 916
 917    fn is_updating(&self, cx: &App) -> bool {
 918        self.read_with(cx, |project_diagnostics_editor, cx| {
 919            project_diagnostics_editor.update_excerpts_task.is_some()
 920                || project_diagnostics_editor
 921                    .project
 922                    .read(cx)
 923                    .language_servers_running_disk_based_diagnostics(cx)
 924                    .next()
 925                    .is_some()
 926        })
 927        .unwrap_or(false)
 928    }
 929
 930    fn stop_updating(&self, cx: &mut App) {
 931        let _ = self.update(cx, |project_diagnostics_editor, cx| {
 932            project_diagnostics_editor.update_excerpts_task = None;
 933            cx.notify();
 934        });
 935    }
 936
 937    fn refresh_diagnostics(&self, window: &mut Window, cx: &mut App) {
 938        let _ = self.update(cx, |project_diagnostics_editor, cx| {
 939            project_diagnostics_editor.refresh(window, cx);
 940        });
 941    }
 942
 943    fn toggle_warnings(&self, window: &mut Window, cx: &mut App) {
 944        let _ = self.update(cx, |project_diagnostics_editor, cx| {
 945            project_diagnostics_editor.toggle_warnings(&Default::default(), window, cx);
 946        });
 947    }
 948
 949    fn get_diagnostics_for_buffer(
 950        &self,
 951        buffer_id: text::BufferId,
 952        cx: &App,
 953    ) -> Vec<language::DiagnosticEntry<text::Anchor>> {
 954        self.read_with(cx, |project_diagnostics_editor, _cx| {
 955            project_diagnostics_editor
 956                .diagnostics
 957                .get(&buffer_id)
 958                .cloned()
 959                .unwrap_or_default()
 960        })
 961        .unwrap_or_default()
 962    }
 963}
 964const DIAGNOSTIC_EXPANSION_ROW_LIMIT: u32 = 32;
 965
 966async fn context_range_for_entry(
 967    range: Range<Point>,
 968    context: u32,
 969    snapshot: BufferSnapshot,
 970    cx: &mut AsyncApp,
 971) -> Range<Point> {
 972    if let Some(rows) = heuristic_syntactic_expand(
 973        range.clone(),
 974        DIAGNOSTIC_EXPANSION_ROW_LIMIT,
 975        snapshot.clone(),
 976        cx,
 977    )
 978    .await
 979    {
 980        return Range {
 981            start: Point::new(*rows.start(), 0),
 982            end: snapshot.clip_point(Point::new(*rows.end(), u32::MAX), Bias::Left),
 983        };
 984    }
 985    Range {
 986        start: Point::new(range.start.row.saturating_sub(context), 0),
 987        end: snapshot.clip_point(Point::new(range.end.row + context, u32::MAX), Bias::Left),
 988    }
 989}
 990
 991/// Expands the input range using syntax information from TreeSitter. This expansion will be limited
 992/// to the specified `max_row_count`.
 993///
 994/// If there is a containing outline item that is less than `max_row_count`, it will be returned.
 995/// Otherwise fairly arbitrary heuristics are applied to attempt to return a logical block of code.
 996async fn heuristic_syntactic_expand(
 997    input_range: Range<Point>,
 998    max_row_count: u32,
 999    snapshot: BufferSnapshot,
1000    cx: &mut AsyncApp,
1001) -> Option<RangeInclusive<BufferRow>> {
1002    let input_row_count = input_range.end.row - input_range.start.row;
1003    if input_row_count > max_row_count {
1004        return None;
1005    }
1006
1007    // If the outline node contains the diagnostic and is small enough, just use that.
1008    let outline_range = snapshot.outline_range_containing(input_range.clone());
1009    if let Some(outline_range) = outline_range.clone() {
1010        // Remove blank lines from start and end
1011        if let Some(start_row) = (outline_range.start.row..outline_range.end.row)
1012            .find(|row| !snapshot.line_indent_for_row(*row).is_line_blank())
1013            && let Some(end_row) = (outline_range.start.row..outline_range.end.row + 1)
1014                .rev()
1015                .find(|row| !snapshot.line_indent_for_row(*row).is_line_blank())
1016        {
1017            let row_count = end_row.saturating_sub(start_row);
1018            if row_count <= max_row_count {
1019                return Some(RangeInclusive::new(
1020                    outline_range.start.row,
1021                    outline_range.end.row,
1022                ));
1023            }
1024        }
1025    }
1026
1027    let mut node = snapshot.syntax_ancestor(input_range.clone())?;
1028
1029    loop {
1030        let node_start = Point::from_ts_point(node.start_position());
1031        let node_end = Point::from_ts_point(node.end_position());
1032        let node_range = node_start..node_end;
1033        let row_count = node_end.row - node_start.row + 1;
1034        let mut ancestor_range = None;
1035        let reached_outline_node = cx.background_executor().scoped({
1036            let node_range = node_range.clone();
1037            let outline_range = outline_range.clone();
1038            let ancestor_range = &mut ancestor_range;
1039            |scope| {
1040                scope.spawn(async move {
1041                    // Stop if we've exceeded the row count or reached an outline node. Then, find the interval
1042                    // of node children which contains the query range. For example, this allows just returning
1043                    // the header of a declaration rather than the entire declaration.
1044                    if row_count > max_row_count || outline_range == Some(node_range.clone()) {
1045                        let mut cursor = node.walk();
1046                        let mut included_child_start = None;
1047                        let mut included_child_end = None;
1048                        let mut previous_end = node_start;
1049                        if cursor.goto_first_child() {
1050                            loop {
1051                                let child_node = cursor.node();
1052                                let child_range =
1053                                    previous_end..Point::from_ts_point(child_node.end_position());
1054                                if included_child_start.is_none()
1055                                    && child_range.contains(&input_range.start)
1056                                {
1057                                    included_child_start = Some(child_range.start);
1058                                }
1059                                if child_range.contains(&input_range.end) {
1060                                    included_child_end = Some(child_range.end);
1061                                }
1062                                previous_end = child_range.end;
1063                                if !cursor.goto_next_sibling() {
1064                                    break;
1065                                }
1066                            }
1067                        }
1068                        let end = included_child_end.unwrap_or(node_range.end);
1069                        if let Some(start) = included_child_start {
1070                            let row_count = end.row - start.row;
1071                            if row_count < max_row_count {
1072                                *ancestor_range =
1073                                    Some(Some(RangeInclusive::new(start.row, end.row)));
1074                                return;
1075                            }
1076                        }
1077                        *ancestor_range = Some(None);
1078                    }
1079                })
1080            }
1081        });
1082        reached_outline_node.await;
1083        if let Some(node) = ancestor_range {
1084            return node;
1085        }
1086
1087        let node_name = node.grammar_name();
1088        let node_row_range = RangeInclusive::new(node_range.start.row, node_range.end.row);
1089        if node_name.ends_with("block") {
1090            return Some(node_row_range);
1091        } else if node_name.ends_with("statement") || node_name.ends_with("declaration") {
1092            // Expand to the nearest dedent or blank line for statements and declarations.
1093            let tab_size = cx
1094                .update(|cx| snapshot.settings_at(node_range.start, cx).tab_size.get())
1095                .ok()?;
1096            let indent_level = snapshot
1097                .line_indent_for_row(node_range.start.row)
1098                .len(tab_size);
1099            let rows_remaining = max_row_count.saturating_sub(row_count);
1100            let Some(start_row) = (node_range.start.row.saturating_sub(rows_remaining)
1101                ..node_range.start.row)
1102                .rev()
1103                .find(|row| {
1104                    is_line_blank_or_indented_less(indent_level, *row, tab_size, &snapshot.clone())
1105                })
1106            else {
1107                return Some(node_row_range);
1108            };
1109            let rows_remaining = max_row_count.saturating_sub(node_range.end.row - start_row);
1110            let Some(end_row) = (node_range.end.row + 1
1111                ..cmp::min(
1112                    node_range.end.row + rows_remaining + 1,
1113                    snapshot.row_count(),
1114                ))
1115                .find(|row| {
1116                    is_line_blank_or_indented_less(indent_level, *row, tab_size, &snapshot.clone())
1117                })
1118            else {
1119                return Some(node_row_range);
1120            };
1121            return Some(RangeInclusive::new(start_row, end_row));
1122        }
1123
1124        // TODO: doing this instead of walking a cursor as that doesn't work - why?
1125        let Some(parent) = node.parent() else {
1126            log::info!(
1127                "Expanding to ancestor reached the top node, so using default context line count.",
1128            );
1129            return None;
1130        };
1131        node = parent;
1132    }
1133}
1134
1135fn is_line_blank_or_indented_less(
1136    indent_level: u32,
1137    row: u32,
1138    tab_size: u32,
1139    snapshot: &BufferSnapshot,
1140) -> bool {
1141    let line_indent = snapshot.line_indent_for_row(row);
1142    line_indent.is_line_blank() || line_indent.len(tab_size) < indent_level
1143}