1use crate::{
   2    Anchor, Autoscroll, BufferSerialization, Capability, Editor, EditorEvent, EditorSettings,
   3    ExcerptId, ExcerptRange, FormatTarget, MultiBuffer, MultiBufferSnapshot, NavigationData,
   4    ReportEditorEvent, SelectionEffects, ToPoint as _,
   5    display_map::HighlightKey,
   6    editor_settings::SeedQuerySetting,
   7    persistence::{DB, SerializedEditor},
   8    scroll::{ScrollAnchor, ScrollOffset},
   9};
  10use anyhow::{Context as _, Result, anyhow};
  11use collections::{HashMap, HashSet};
  12use file_icons::FileIcons;
  13use fs::MTime;
  14use futures::future::try_join_all;
  15use git::status::GitSummary;
  16use gpui::{
  17    AnyElement, App, AsyncWindowContext, Context, Entity, EntityId, EventEmitter, IntoElement,
  18    ParentElement, Pixels, SharedString, Styled, Task, WeakEntity, Window, point,
  19};
  20use language::{
  21    Bias, Buffer, BufferRow, CharKind, CharScopeContext, LocalFile, Point, SelectionGoal,
  22    proto::serialize_anchor as serialize_text_anchor,
  23};
  24use lsp::DiagnosticSeverity;
  25use multi_buffer::MultiBufferOffset;
  26use project::{
  27    File, Project, ProjectItem as _, ProjectPath, lsp_store::FormatTrigger,
  28    project_settings::ProjectSettings, search::SearchQuery,
  29};
  30use rpc::proto::{self, update_view};
  31use settings::Settings;
  32use std::{
  33    any::{Any, TypeId},
  34    borrow::Cow,
  35    cmp::{self, Ordering},
  36    iter,
  37    ops::Range,
  38    path::{Path, PathBuf},
  39    sync::Arc,
  40};
  41use text::{BufferId, BufferSnapshot, Selection};
  42use ui::{IconDecorationKind, prelude::*};
  43use util::{ResultExt, TryFutureExt, paths::PathExt};
  44use workspace::{
  45    CollaboratorId, ItemId, ItemNavHistory, ToolbarItemLocation, ViewId, Workspace, WorkspaceId,
  46    invalid_item_view::InvalidItemView,
  47    item::{FollowableItem, Item, ItemBufferKind, ItemEvent, ProjectItem, SaveOptions},
  48    searchable::{
  49        Direction, FilteredSearchRange, SearchEvent, SearchToken, SearchableItem,
  50        SearchableItemHandle,
  51    },
  52};
  53use workspace::{
  54    OpenOptions,
  55    item::{Dedup, ItemSettings, SerializableItem, TabContentParams},
  56};
  57use workspace::{
  58    OpenVisible, Pane, WorkspaceSettings,
  59    item::{BreadcrumbText, FollowEvent, ProjectItemKind},
  60    searchable::SearchOptions,
  61};
  62use zed_actions::preview::{
  63    markdown::OpenPreview as OpenMarkdownPreview, svg::OpenPreview as OpenSvgPreview,
  64};
  65
  66pub const MAX_TAB_TITLE_LEN: usize = 24;
  67
  68impl FollowableItem for Editor {
  69    fn remote_id(&self) -> Option<ViewId> {
  70        self.remote_id
  71    }
  72
  73    fn from_state_proto(
  74        workspace: Entity<Workspace>,
  75        remote_id: ViewId,
  76        state: &mut Option<proto::view::Variant>,
  77        window: &mut Window,
  78        cx: &mut App,
  79    ) -> Option<Task<Result<Entity<Self>>>> {
  80        let project = workspace.read(cx).project().to_owned();
  81        let Some(proto::view::Variant::Editor(_)) = state else {
  82            return None;
  83        };
  84        let Some(proto::view::Variant::Editor(state)) = state.take() else {
  85            unreachable!()
  86        };
  87
  88        let buffer_ids = state
  89            .excerpts
  90            .iter()
  91            .map(|excerpt| excerpt.buffer_id)
  92            .collect::<HashSet<_>>();
  93        let buffers = project.update(cx, |project, cx| {
  94            buffer_ids
  95                .iter()
  96                .map(|id| BufferId::new(*id).map(|id| project.open_buffer_by_id(id, cx)))
  97                .collect::<Result<Vec<_>>>()
  98        });
  99
 100        Some(window.spawn(cx, async move |cx| {
 101            let mut buffers = futures::future::try_join_all(buffers?)
 102                .await
 103                .debug_assert_ok("leaders don't share views for unshared buffers")?;
 104
 105            let editor = cx.update(|window, cx| {
 106                let multibuffer = cx.new(|cx| {
 107                    let mut multibuffer;
 108                    if state.singleton && buffers.len() == 1 {
 109                        multibuffer = MultiBuffer::singleton(buffers.pop().unwrap(), cx)
 110                    } else {
 111                        multibuffer = MultiBuffer::new(project.read(cx).capability());
 112                        let mut sorted_excerpts = state.excerpts.clone();
 113                        sorted_excerpts.sort_by_key(|e| e.id);
 114                        let sorted_excerpts = sorted_excerpts.into_iter().peekable();
 115
 116                        for excerpt in sorted_excerpts {
 117                            let Ok(buffer_id) = BufferId::new(excerpt.buffer_id) else {
 118                                continue;
 119                            };
 120
 121                            let mut insert_position = ExcerptId::min();
 122                            for e in &state.excerpts {
 123                                if e.id == excerpt.id {
 124                                    break;
 125                                }
 126                                if e.id < excerpt.id {
 127                                    insert_position = ExcerptId::from_proto(e.id);
 128                                }
 129                            }
 130
 131                            let buffer =
 132                                buffers.iter().find(|b| b.read(cx).remote_id() == buffer_id);
 133
 134                            let Some(excerpt) = deserialize_excerpt_range(excerpt) else {
 135                                continue;
 136                            };
 137
 138                            let Some(buffer) = buffer else { continue };
 139
 140                            multibuffer.insert_excerpts_with_ids_after(
 141                                insert_position,
 142                                buffer.clone(),
 143                                [excerpt],
 144                                cx,
 145                            );
 146                        }
 147                    };
 148
 149                    if let Some(title) = &state.title {
 150                        multibuffer = multibuffer.with_title(title.clone())
 151                    }
 152
 153                    multibuffer
 154                });
 155
 156                cx.new(|cx| {
 157                    let mut editor =
 158                        Editor::for_multibuffer(multibuffer, Some(project.clone()), window, cx);
 159                    editor.remote_id = Some(remote_id);
 160                    editor
 161                })
 162            })?;
 163
 164            update_editor_from_message(
 165                editor.downgrade(),
 166                project,
 167                proto::update_view::Editor {
 168                    selections: state.selections,
 169                    pending_selection: state.pending_selection,
 170                    scroll_top_anchor: state.scroll_top_anchor,
 171                    scroll_x: state.scroll_x,
 172                    scroll_y: state.scroll_y,
 173                    ..Default::default()
 174                },
 175                cx,
 176            )
 177            .await?;
 178
 179            Ok(editor)
 180        }))
 181    }
 182
 183    fn set_leader_id(
 184        &mut self,
 185        leader_id: Option<CollaboratorId>,
 186        window: &mut Window,
 187        cx: &mut Context<Self>,
 188    ) {
 189        self.leader_id = leader_id;
 190        if self.leader_id.is_some() {
 191            self.buffer.update(cx, |buffer, cx| {
 192                buffer.remove_active_selections(cx);
 193            });
 194        } else if self.focus_handle.is_focused(window) {
 195            self.buffer.update(cx, |buffer, cx| {
 196                buffer.set_active_selections(
 197                    &self.selections.disjoint_anchors_arc(),
 198                    self.selections.line_mode(),
 199                    self.cursor_shape,
 200                    cx,
 201                );
 202            });
 203        }
 204        cx.notify();
 205    }
 206
 207    fn to_state_proto(&self, _: &mut Window, cx: &mut App) -> Option<proto::view::Variant> {
 208        let is_private = self
 209            .buffer
 210            .read(cx)
 211            .as_singleton()
 212            .and_then(|buffer| buffer.read(cx).file())
 213            .is_some_and(|file| file.is_private());
 214        if is_private {
 215            return None;
 216        }
 217
 218        let display_snapshot = self.display_map.update(cx, |map, cx| map.snapshot(cx));
 219        let scroll_anchor = self.scroll_manager.native_anchor(&display_snapshot, cx);
 220        let buffer = self.buffer.read(cx);
 221        let excerpts = buffer
 222            .read(cx)
 223            .excerpts()
 224            .map(|(id, buffer, range)| proto::Excerpt {
 225                id: id.to_proto(),
 226                buffer_id: buffer.remote_id().into(),
 227                context_start: Some(serialize_text_anchor(&range.context.start)),
 228                context_end: Some(serialize_text_anchor(&range.context.end)),
 229                primary_start: Some(serialize_text_anchor(&range.primary.start)),
 230                primary_end: Some(serialize_text_anchor(&range.primary.end)),
 231            })
 232            .collect();
 233        let snapshot = buffer.snapshot(cx);
 234
 235        Some(proto::view::Variant::Editor(proto::view::Editor {
 236            singleton: buffer.is_singleton(),
 237            title: buffer.explicit_title().map(ToOwned::to_owned),
 238            excerpts,
 239            scroll_top_anchor: Some(serialize_anchor(&scroll_anchor.anchor, &snapshot)),
 240            scroll_x: scroll_anchor.offset.x,
 241            scroll_y: scroll_anchor.offset.y,
 242            selections: self
 243                .selections
 244                .disjoint_anchors_arc()
 245                .iter()
 246                .map(|s| serialize_selection(s, &snapshot))
 247                .collect(),
 248            pending_selection: self
 249                .selections
 250                .pending_anchor()
 251                .as_ref()
 252                .map(|s| serialize_selection(s, &snapshot)),
 253        }))
 254    }
 255
 256    fn to_follow_event(event: &EditorEvent) -> Option<workspace::item::FollowEvent> {
 257        match event {
 258            EditorEvent::Edited { .. } => Some(FollowEvent::Unfollow),
 259            EditorEvent::SelectionsChanged { local }
 260            | EditorEvent::ScrollPositionChanged { local, .. } => {
 261                if *local {
 262                    Some(FollowEvent::Unfollow)
 263                } else {
 264                    None
 265                }
 266            }
 267            _ => None,
 268        }
 269    }
 270
 271    fn add_event_to_update_proto(
 272        &self,
 273        event: &EditorEvent,
 274        update: &mut Option<proto::update_view::Variant>,
 275        _: &mut Window,
 276        cx: &mut App,
 277    ) -> bool {
 278        let update =
 279            update.get_or_insert_with(|| proto::update_view::Variant::Editor(Default::default()));
 280
 281        match update {
 282            proto::update_view::Variant::Editor(update) => match event {
 283                EditorEvent::ExcerptsAdded {
 284                    buffer,
 285                    predecessor,
 286                    excerpts,
 287                } => {
 288                    let buffer_id = buffer.read(cx).remote_id();
 289                    let mut excerpts = excerpts.iter();
 290                    if let Some((id, range)) = excerpts.next() {
 291                        update.inserted_excerpts.push(proto::ExcerptInsertion {
 292                            previous_excerpt_id: Some(predecessor.to_proto()),
 293                            excerpt: serialize_excerpt(buffer_id, id, range),
 294                        });
 295                        update.inserted_excerpts.extend(excerpts.map(|(id, range)| {
 296                            proto::ExcerptInsertion {
 297                                previous_excerpt_id: None,
 298                                excerpt: serialize_excerpt(buffer_id, id, range),
 299                            }
 300                        }))
 301                    }
 302                    true
 303                }
 304                EditorEvent::ExcerptsRemoved { ids, .. } => {
 305                    update
 306                        .deleted_excerpts
 307                        .extend(ids.iter().copied().map(ExcerptId::to_proto));
 308                    true
 309                }
 310                EditorEvent::ScrollPositionChanged { autoscroll, .. } if !autoscroll => {
 311                    let display_snapshot = self.display_map.update(cx, |map, cx| map.snapshot(cx));
 312                    let snapshot = self.buffer.read(cx).snapshot(cx);
 313                    let scroll_anchor = self.scroll_manager.native_anchor(&display_snapshot, cx);
 314                    update.scroll_top_anchor =
 315                        Some(serialize_anchor(&scroll_anchor.anchor, &snapshot));
 316                    update.scroll_x = scroll_anchor.offset.x;
 317                    update.scroll_y = scroll_anchor.offset.y;
 318                    true
 319                }
 320                EditorEvent::SelectionsChanged { .. } => {
 321                    let snapshot = self.buffer.read(cx).snapshot(cx);
 322                    update.selections = self
 323                        .selections
 324                        .disjoint_anchors_arc()
 325                        .iter()
 326                        .map(|s| serialize_selection(s, &snapshot))
 327                        .collect();
 328                    update.pending_selection = self
 329                        .selections
 330                        .pending_anchor()
 331                        .as_ref()
 332                        .map(|s| serialize_selection(s, &snapshot));
 333                    true
 334                }
 335                _ => false,
 336            },
 337        }
 338    }
 339
 340    fn apply_update_proto(
 341        &mut self,
 342        project: &Entity<Project>,
 343        message: update_view::Variant,
 344        window: &mut Window,
 345        cx: &mut Context<Self>,
 346    ) -> Task<Result<()>> {
 347        let update_view::Variant::Editor(message) = message;
 348        let project = project.clone();
 349        cx.spawn_in(window, async move |this, cx| {
 350            update_editor_from_message(this, project, message, cx).await
 351        })
 352    }
 353
 354    fn is_project_item(&self, _window: &Window, _cx: &App) -> bool {
 355        true
 356    }
 357
 358    fn dedup(&self, existing: &Self, _: &Window, cx: &App) -> Option<Dedup> {
 359        let self_singleton = self.buffer.read(cx).as_singleton()?;
 360        let other_singleton = existing.buffer.read(cx).as_singleton()?;
 361        if self_singleton == other_singleton {
 362            Some(Dedup::KeepExisting)
 363        } else {
 364            None
 365        }
 366    }
 367
 368    fn update_agent_location(
 369        &mut self,
 370        location: language::Anchor,
 371        window: &mut Window,
 372        cx: &mut Context<Self>,
 373    ) {
 374        let buffer = self.buffer.read(cx);
 375        let buffer = buffer.read(cx);
 376        let Some(position) = buffer.as_singleton_anchor(location) else {
 377            return;
 378        };
 379        let selection = Selection {
 380            id: 0,
 381            reversed: false,
 382            start: position,
 383            end: position,
 384            goal: SelectionGoal::None,
 385        };
 386        drop(buffer);
 387        self.set_selections_from_remote(vec![selection], None, window, cx);
 388        self.request_autoscroll_remotely(Autoscroll::fit(), cx);
 389    }
 390}
 391
 392async fn update_editor_from_message(
 393    this: WeakEntity<Editor>,
 394    project: Entity<Project>,
 395    message: proto::update_view::Editor,
 396    cx: &mut AsyncWindowContext,
 397) -> Result<()> {
 398    // Open all of the buffers of which excerpts were added to the editor.
 399    let inserted_excerpt_buffer_ids = message
 400        .inserted_excerpts
 401        .iter()
 402        .filter_map(|insertion| Some(insertion.excerpt.as_ref()?.buffer_id))
 403        .collect::<HashSet<_>>();
 404    let inserted_excerpt_buffers = project.update(cx, |project, cx| {
 405        inserted_excerpt_buffer_ids
 406            .into_iter()
 407            .map(|id| BufferId::new(id).map(|id| project.open_buffer_by_id(id, cx)))
 408            .collect::<Result<Vec<_>>>()
 409    })?;
 410    let _inserted_excerpt_buffers = try_join_all(inserted_excerpt_buffers).await?;
 411
 412    // Update the editor's excerpts.
 413    this.update(cx, |editor, cx| {
 414        editor.buffer.update(cx, |multibuffer, cx| {
 415            let mut removed_excerpt_ids = message
 416                .deleted_excerpts
 417                .into_iter()
 418                .map(ExcerptId::from_proto)
 419                .collect::<Vec<_>>();
 420            removed_excerpt_ids.sort_by({
 421                let multibuffer = multibuffer.read(cx);
 422                move |a, b| a.cmp(b, &multibuffer)
 423            });
 424
 425            let mut insertions = message.inserted_excerpts.into_iter().peekable();
 426            while let Some(insertion) = insertions.next() {
 427                let Some(excerpt) = insertion.excerpt else {
 428                    continue;
 429                };
 430                let Some(previous_excerpt_id) = insertion.previous_excerpt_id else {
 431                    continue;
 432                };
 433                let buffer_id = BufferId::new(excerpt.buffer_id)?;
 434                let Some(buffer) = project.read(cx).buffer_for_id(buffer_id, cx) else {
 435                    continue;
 436                };
 437
 438                let adjacent_excerpts = iter::from_fn(|| {
 439                    let insertion = insertions.peek()?;
 440                    if insertion.previous_excerpt_id.is_none()
 441                        && insertion.excerpt.as_ref()?.buffer_id == u64::from(buffer_id)
 442                    {
 443                        insertions.next()?.excerpt
 444                    } else {
 445                        None
 446                    }
 447                });
 448
 449                multibuffer.insert_excerpts_with_ids_after(
 450                    ExcerptId::from_proto(previous_excerpt_id),
 451                    buffer,
 452                    [excerpt]
 453                        .into_iter()
 454                        .chain(adjacent_excerpts)
 455                        .filter_map(deserialize_excerpt_range),
 456                    cx,
 457                );
 458            }
 459
 460            multibuffer.remove_excerpts(removed_excerpt_ids, cx);
 461            anyhow::Ok(())
 462        })
 463    })??;
 464
 465    // Deserialize the editor state.
 466    let selections = message
 467        .selections
 468        .into_iter()
 469        .filter_map(deserialize_selection)
 470        .collect::<Vec<_>>();
 471    let pending_selection = message.pending_selection.and_then(deserialize_selection);
 472    let scroll_top_anchor = message.scroll_top_anchor.and_then(deserialize_anchor);
 473
 474    // Wait until the buffer has received all of the operations referenced by
 475    // the editor's new state.
 476    this.update(cx, |editor, cx| {
 477        editor.buffer.update(cx, |buffer, cx| {
 478            buffer.wait_for_anchors(
 479                selections
 480                    .iter()
 481                    .chain(pending_selection.as_ref())
 482                    .flat_map(|selection| [selection.start, selection.end])
 483                    .chain(scroll_top_anchor),
 484                cx,
 485            )
 486        })
 487    })?
 488    .await?;
 489
 490    // Update the editor's state.
 491    this.update_in(cx, |editor, window, cx| {
 492        if !selections.is_empty() || pending_selection.is_some() {
 493            editor.set_selections_from_remote(selections, pending_selection, window, cx);
 494            editor.request_autoscroll_remotely(Autoscroll::newest(), cx);
 495        } else if let Some(scroll_top_anchor) = scroll_top_anchor {
 496            editor.set_scroll_anchor_remote(
 497                ScrollAnchor {
 498                    anchor: scroll_top_anchor,
 499                    offset: point(message.scroll_x, message.scroll_y),
 500                },
 501                window,
 502                cx,
 503            );
 504        }
 505    })?;
 506    Ok(())
 507}
 508
 509fn serialize_excerpt(
 510    buffer_id: BufferId,
 511    id: &ExcerptId,
 512    range: &ExcerptRange<language::Anchor>,
 513) -> Option<proto::Excerpt> {
 514    Some(proto::Excerpt {
 515        id: id.to_proto(),
 516        buffer_id: buffer_id.into(),
 517        context_start: Some(serialize_text_anchor(&range.context.start)),
 518        context_end: Some(serialize_text_anchor(&range.context.end)),
 519        primary_start: Some(serialize_text_anchor(&range.primary.start)),
 520        primary_end: Some(serialize_text_anchor(&range.primary.end)),
 521    })
 522}
 523
 524fn serialize_selection(
 525    selection: &Selection<Anchor>,
 526    buffer: &MultiBufferSnapshot,
 527) -> proto::Selection {
 528    proto::Selection {
 529        id: selection.id as u64,
 530        start: Some(serialize_anchor(&selection.start, buffer)),
 531        end: Some(serialize_anchor(&selection.end, buffer)),
 532        reversed: selection.reversed,
 533    }
 534}
 535
 536fn serialize_anchor(anchor: &Anchor, buffer: &MultiBufferSnapshot) -> proto::EditorAnchor {
 537    proto::EditorAnchor {
 538        excerpt_id: buffer.latest_excerpt_id(anchor.excerpt_id).to_proto(),
 539        anchor: Some(serialize_text_anchor(&anchor.text_anchor)),
 540    }
 541}
 542
 543fn deserialize_excerpt_range(
 544    excerpt: proto::Excerpt,
 545) -> Option<(ExcerptId, ExcerptRange<language::Anchor>)> {
 546    let context = {
 547        let start = language::proto::deserialize_anchor(excerpt.context_start?)?;
 548        let end = language::proto::deserialize_anchor(excerpt.context_end?)?;
 549        start..end
 550    };
 551    let primary = excerpt
 552        .primary_start
 553        .zip(excerpt.primary_end)
 554        .and_then(|(start, end)| {
 555            let start = language::proto::deserialize_anchor(start)?;
 556            let end = language::proto::deserialize_anchor(end)?;
 557            Some(start..end)
 558        })
 559        .unwrap_or_else(|| context.clone());
 560    Some((
 561        ExcerptId::from_proto(excerpt.id),
 562        ExcerptRange { context, primary },
 563    ))
 564}
 565
 566fn deserialize_selection(selection: proto::Selection) -> Option<Selection<Anchor>> {
 567    Some(Selection {
 568        id: selection.id as usize,
 569        start: deserialize_anchor(selection.start?)?,
 570        end: deserialize_anchor(selection.end?)?,
 571        reversed: selection.reversed,
 572        goal: SelectionGoal::None,
 573    })
 574}
 575
 576fn deserialize_anchor(anchor: proto::EditorAnchor) -> Option<Anchor> {
 577    let excerpt_id = ExcerptId::from_proto(anchor.excerpt_id);
 578    Some(Anchor::in_buffer(
 579        excerpt_id,
 580        language::proto::deserialize_anchor(anchor.anchor?)?,
 581    ))
 582}
 583
 584impl Item for Editor {
 585    type Event = EditorEvent;
 586
 587    fn act_as_type<'a>(
 588        &'a self,
 589        type_id: TypeId,
 590        self_handle: &'a Entity<Self>,
 591        cx: &'a App,
 592    ) -> Option<gpui::AnyEntity> {
 593        if TypeId::of::<Self>() == type_id {
 594            Some(self_handle.clone().into())
 595        } else if TypeId::of::<MultiBuffer>() == type_id {
 596            Some(self_handle.read(cx).buffer.clone().into())
 597        } else {
 598            None
 599        }
 600    }
 601
 602    fn navigate(
 603        &mut self,
 604        data: Arc<dyn Any + Send>,
 605        window: &mut Window,
 606        cx: &mut Context<Self>,
 607    ) -> bool {
 608        if let Some(data) = data.downcast_ref::<NavigationData>() {
 609            let newest_selection = self.selections.newest::<Point>(&self.display_snapshot(cx));
 610            let buffer = self.buffer.read(cx).read(cx);
 611            let offset = if buffer.can_resolve(&data.cursor_anchor) {
 612                data.cursor_anchor.to_point(&buffer)
 613            } else {
 614                buffer.clip_point(data.cursor_position, Bias::Left)
 615            };
 616
 617            let mut scroll_anchor = data.scroll_anchor;
 618            if !buffer.can_resolve(&scroll_anchor.anchor) {
 619                scroll_anchor.anchor = buffer.anchor_before(
 620                    buffer.clip_point(Point::new(data.scroll_top_row, 0), Bias::Left),
 621                );
 622            }
 623
 624            drop(buffer);
 625
 626            if newest_selection.head() == offset {
 627                false
 628            } else {
 629                self.set_scroll_anchor(scroll_anchor, window, cx);
 630                self.change_selections(
 631                    SelectionEffects::default().nav_history(false),
 632                    window,
 633                    cx,
 634                    |s| s.select_ranges([offset..offset]),
 635                );
 636                true
 637            }
 638        } else {
 639            false
 640        }
 641    }
 642
 643    fn tab_tooltip_text(&self, cx: &App) -> Option<SharedString> {
 644        self.buffer()
 645            .read(cx)
 646            .as_singleton()
 647            .and_then(|buffer| buffer.read(cx).file())
 648            .and_then(|file| File::from_dyn(Some(file)))
 649            .map(|file| {
 650                file.worktree
 651                    .read(cx)
 652                    .absolutize(&file.path)
 653                    .compact()
 654                    .to_string_lossy()
 655                    .into_owned()
 656                    .into()
 657            })
 658    }
 659
 660    fn telemetry_event_text(&self) -> Option<&'static str> {
 661        None
 662    }
 663
 664    fn tab_content_text(&self, detail: usize, cx: &App) -> SharedString {
 665        if let Some(path) = path_for_buffer(&self.buffer, detail, true, cx) {
 666            path.to_string().into()
 667        } else {
 668            // Use the same logic as the displayed title for consistency
 669            self.buffer.read(cx).title(cx).to_string().into()
 670        }
 671    }
 672
 673    fn suggested_filename(&self, cx: &App) -> SharedString {
 674        self.buffer.read(cx).title(cx).to_string().into()
 675    }
 676
 677    fn tab_icon(&self, _: &Window, cx: &App) -> Option<Icon> {
 678        ItemSettings::get_global(cx)
 679            .file_icons
 680            .then(|| {
 681                path_for_buffer(&self.buffer, 0, true, cx)
 682                    .and_then(|path| FileIcons::get_icon(Path::new(&*path), cx))
 683            })
 684            .flatten()
 685            .map(Icon::from_path)
 686    }
 687
 688    fn tab_content(&self, params: TabContentParams, _: &Window, cx: &App) -> AnyElement {
 689        let label_color = if ItemSettings::get_global(cx).git_status {
 690            self.buffer()
 691                .read(cx)
 692                .as_singleton()
 693                .and_then(|buffer| {
 694                    let buffer = buffer.read(cx);
 695                    let path = buffer.project_path(cx)?;
 696                    let buffer_id = buffer.remote_id();
 697                    let project = self.project()?.read(cx);
 698                    let entry = project.entry_for_path(&path, cx)?;
 699                    let (repo, repo_path) = project
 700                        .git_store()
 701                        .read(cx)
 702                        .repository_and_path_for_buffer_id(buffer_id, cx)?;
 703                    let status = repo.read(cx).status_for_path(&repo_path)?.status;
 704
 705                    Some(entry_git_aware_label_color(
 706                        status.summary(),
 707                        entry.is_ignored,
 708                        params.selected,
 709                    ))
 710                })
 711                .unwrap_or_else(|| entry_label_color(params.selected))
 712        } else {
 713            entry_label_color(params.selected)
 714        };
 715
 716        let description = params.detail.and_then(|detail| {
 717            let path = path_for_buffer(&self.buffer, detail, false, cx)?;
 718            let description = path.trim();
 719
 720            if description.is_empty() {
 721                return None;
 722            }
 723
 724            Some(util::truncate_and_trailoff(description, MAX_TAB_TITLE_LEN))
 725        });
 726
 727        // Whether the file was saved in the past but is now deleted.
 728        let was_deleted: bool = self
 729            .buffer()
 730            .read(cx)
 731            .as_singleton()
 732            .and_then(|buffer| buffer.read(cx).file())
 733            .is_some_and(|file| file.disk_state().is_deleted());
 734
 735        h_flex()
 736            .gap_2()
 737            .child(
 738                Label::new(self.title(cx).to_string())
 739                    .color(label_color)
 740                    .when(params.preview, |this| this.italic())
 741                    .when(was_deleted, |this| this.strikethrough()),
 742            )
 743            .when_some(description, |this, description| {
 744                this.child(
 745                    Label::new(description)
 746                        .size(LabelSize::XSmall)
 747                        .color(Color::Muted),
 748                )
 749            })
 750            .into_any_element()
 751    }
 752
 753    fn for_each_project_item(
 754        &self,
 755        cx: &App,
 756        f: &mut dyn FnMut(EntityId, &dyn project::ProjectItem),
 757    ) {
 758        self.buffer
 759            .read(cx)
 760            .for_each_buffer(&mut |buffer| f(buffer.entity_id(), buffer.read(cx)));
 761    }
 762
 763    fn buffer_kind(&self, cx: &App) -> ItemBufferKind {
 764        match self.buffer.read(cx).is_singleton() {
 765            true => ItemBufferKind::Singleton,
 766            false => ItemBufferKind::Multibuffer,
 767        }
 768    }
 769
 770    fn can_save_as(&self, cx: &App) -> bool {
 771        self.buffer.read(cx).is_singleton()
 772    }
 773
 774    fn can_split(&self) -> bool {
 775        true
 776    }
 777
 778    fn clone_on_split(
 779        &self,
 780        _workspace_id: Option<WorkspaceId>,
 781        window: &mut Window,
 782        cx: &mut Context<Self>,
 783    ) -> Task<Option<Entity<Editor>>>
 784    where
 785        Self: Sized,
 786    {
 787        Task::ready(Some(cx.new(|cx| self.clone(window, cx))))
 788    }
 789
 790    fn set_nav_history(
 791        &mut self,
 792        history: ItemNavHistory,
 793        _window: &mut Window,
 794        _: &mut Context<Self>,
 795    ) {
 796        self.nav_history = Some(history);
 797    }
 798
 799    fn on_removed(&self, cx: &mut Context<Self>) {
 800        self.report_editor_event(ReportEditorEvent::Closed, None, cx);
 801    }
 802
 803    fn deactivated(&mut self, _: &mut Window, cx: &mut Context<Self>) {
 804        let selection = self.selections.newest_anchor();
 805        self.push_to_nav_history(selection.head(), None, true, false, cx);
 806    }
 807
 808    fn workspace_deactivated(&mut self, _: &mut Window, cx: &mut Context<Self>) {
 809        self.hide_hovered_link(cx);
 810    }
 811
 812    fn is_dirty(&self, cx: &App) -> bool {
 813        self.buffer().read(cx).read(cx).is_dirty()
 814    }
 815
 816    fn capability(&self, cx: &App) -> Capability {
 817        self.capability(cx)
 818    }
 819
 820    // Note: this mirrors the logic in `Editor::toggle_read_only`, but is reachable
 821    // without relying on focus-based action dispatch.
 822    fn toggle_read_only(&mut self, window: &mut Window, cx: &mut Context<Self>) {
 823        if let Some(buffer) = self.buffer.read(cx).as_singleton() {
 824            buffer.update(cx, |buffer, cx| {
 825                buffer.set_capability(
 826                    match buffer.capability() {
 827                        Capability::ReadWrite => Capability::Read,
 828                        Capability::Read => Capability::ReadWrite,
 829                        Capability::ReadOnly => Capability::ReadOnly,
 830                    },
 831                    cx,
 832                );
 833            });
 834        }
 835        cx.notify();
 836        window.refresh();
 837    }
 838
 839    fn has_deleted_file(&self, cx: &App) -> bool {
 840        self.buffer().read(cx).read(cx).has_deleted_file()
 841    }
 842
 843    fn has_conflict(&self, cx: &App) -> bool {
 844        self.buffer().read(cx).read(cx).has_conflict()
 845    }
 846
 847    fn can_save(&self, cx: &App) -> bool {
 848        let buffer = &self.buffer().read(cx);
 849        if let Some(buffer) = buffer.as_singleton() {
 850            buffer.read(cx).project_path(cx).is_some()
 851        } else {
 852            true
 853        }
 854    }
 855
 856    fn save(
 857        &mut self,
 858        options: SaveOptions,
 859        project: Entity<Project>,
 860        window: &mut Window,
 861        cx: &mut Context<Self>,
 862    ) -> Task<Result<()>> {
 863        // Add meta data tracking # of auto saves
 864        if options.autosave {
 865            self.report_editor_event(ReportEditorEvent::Saved { auto_saved: true }, None, cx);
 866        } else {
 867            self.report_editor_event(ReportEditorEvent::Saved { auto_saved: false }, None, cx);
 868        }
 869
 870        let buffers = self.buffer().clone().read(cx).all_buffers();
 871        let buffers = buffers
 872            .into_iter()
 873            .map(|handle| handle.read(cx).base_buffer().unwrap_or(handle.clone()))
 874            .collect::<HashSet<_>>();
 875
 876        let buffers_to_save = if self.buffer.read(cx).is_singleton() && !options.autosave {
 877            buffers
 878        } else {
 879            buffers
 880                .into_iter()
 881                .filter(|buffer| buffer.read(cx).is_dirty())
 882                .collect()
 883        };
 884
 885        cx.spawn_in(window, async move |this, cx| {
 886            if options.format {
 887                this.update_in(cx, |editor, window, cx| {
 888                    editor.perform_format(
 889                        project.clone(),
 890                        FormatTrigger::Save,
 891                        FormatTarget::Buffers(buffers_to_save.clone()),
 892                        window,
 893                        cx,
 894                    )
 895                })?
 896                .await?;
 897            }
 898
 899            if !buffers_to_save.is_empty() {
 900                project
 901                    .update(cx, |project, cx| {
 902                        project.save_buffers(buffers_to_save.clone(), cx)
 903                    })
 904                    .await?;
 905            }
 906
 907            Ok(())
 908        })
 909    }
 910
 911    fn save_as(
 912        &mut self,
 913        project: Entity<Project>,
 914        path: ProjectPath,
 915        _: &mut Window,
 916        cx: &mut Context<Self>,
 917    ) -> Task<Result<()>> {
 918        let buffer = self
 919            .buffer()
 920            .read(cx)
 921            .as_singleton()
 922            .expect("cannot call save_as on an excerpt list");
 923
 924        let file_extension = path.path.extension().map(|a| a.to_string());
 925        self.report_editor_event(
 926            ReportEditorEvent::Saved { auto_saved: false },
 927            file_extension,
 928            cx,
 929        );
 930
 931        project.update(cx, |project, cx| project.save_buffer_as(buffer, path, cx))
 932    }
 933
 934    fn reload(
 935        &mut self,
 936        project: Entity<Project>,
 937        window: &mut Window,
 938        cx: &mut Context<Self>,
 939    ) -> Task<Result<()>> {
 940        let buffer = self.buffer().clone();
 941        let buffers = self.buffer.read(cx).all_buffers();
 942        let reload_buffers =
 943            project.update(cx, |project, cx| project.reload_buffers(buffers, true, cx));
 944        cx.spawn_in(window, async move |this, cx| {
 945            let transaction = reload_buffers.log_err().await;
 946            this.update(cx, |editor, cx| {
 947                editor.request_autoscroll(Autoscroll::fit(), cx)
 948            })?;
 949            buffer.update(cx, |buffer, cx| {
 950                if let Some(transaction) = transaction
 951                    && !buffer.is_singleton()
 952                {
 953                    buffer.push_transaction(&transaction.0, cx);
 954                }
 955            });
 956            Ok(())
 957        })
 958    }
 959
 960    fn as_searchable(
 961        &self,
 962        handle: &Entity<Self>,
 963        _: &App,
 964    ) -> Option<Box<dyn SearchableItemHandle>> {
 965        Some(Box::new(handle.clone()))
 966    }
 967
 968    fn pixel_position_of_cursor(&self, _: &App) -> Option<gpui::Point<Pixels>> {
 969        self.pixel_position_of_newest_cursor
 970    }
 971
 972    fn breadcrumb_location(&self, cx: &App) -> ToolbarItemLocation {
 973        if self.show_breadcrumbs && self.buffer().read(cx).is_singleton() {
 974            ToolbarItemLocation::PrimaryLeft
 975        } else {
 976            ToolbarItemLocation::Hidden
 977        }
 978    }
 979
 980    // In a non-singleton case, the breadcrumbs are actually shown on sticky file headers of the multibuffer.
 981    fn breadcrumbs(&self, cx: &App) -> Option<Vec<BreadcrumbText>> {
 982        if self.buffer.read(cx).is_singleton() {
 983            self.breadcrumbs_inner(cx)
 984        } else {
 985            None
 986        }
 987    }
 988
 989    fn added_to_workspace(
 990        &mut self,
 991        workspace: &mut Workspace,
 992        _window: &mut Window,
 993        cx: &mut Context<Self>,
 994    ) {
 995        self.workspace = Some((workspace.weak_handle(), workspace.database_id()));
 996        if let Some(workspace) = &workspace.weak_handle().upgrade() {
 997            cx.subscribe(workspace, |editor, _, event: &workspace::Event, _cx| {
 998                if let workspace::Event::ModalOpened = event {
 999                    editor.mouse_context_menu.take();
1000                    editor.inline_blame_popover.take();
1001                }
1002            })
1003            .detach();
1004        }
1005    }
1006
1007    fn to_item_events(event: &EditorEvent, f: &mut dyn FnMut(ItemEvent)) {
1008        match event {
1009            EditorEvent::Saved | EditorEvent::TitleChanged => {
1010                f(ItemEvent::UpdateTab);
1011                f(ItemEvent::UpdateBreadcrumbs);
1012            }
1013
1014            EditorEvent::Reparsed(_) => {
1015                f(ItemEvent::UpdateBreadcrumbs);
1016            }
1017
1018            EditorEvent::SelectionsChanged { local } if *local => {
1019                f(ItemEvent::UpdateBreadcrumbs);
1020            }
1021
1022            EditorEvent::BreadcrumbsChanged => {
1023                f(ItemEvent::UpdateBreadcrumbs);
1024            }
1025
1026            EditorEvent::DirtyChanged => {
1027                f(ItemEvent::UpdateTab);
1028            }
1029
1030            EditorEvent::BufferEdited => {
1031                f(ItemEvent::Edit);
1032                f(ItemEvent::UpdateBreadcrumbs);
1033            }
1034
1035            EditorEvent::ExcerptsAdded { .. } | EditorEvent::ExcerptsRemoved { .. } => {
1036                f(ItemEvent::Edit);
1037            }
1038
1039            _ => {}
1040        }
1041    }
1042
1043    fn tab_extra_context_menu_actions(
1044        &self,
1045        _window: &mut Window,
1046        cx: &mut Context<Self>,
1047    ) -> Vec<(SharedString, Box<dyn gpui::Action>)> {
1048        let mut actions = Vec::new();
1049
1050        let is_markdown = self
1051            .buffer()
1052            .read(cx)
1053            .as_singleton()
1054            .and_then(|buffer| buffer.read(cx).language())
1055            .is_some_and(|language| language.name().as_ref() == "Markdown");
1056
1057        let is_svg = self
1058            .buffer()
1059            .read(cx)
1060            .as_singleton()
1061            .and_then(|buffer| buffer.read(cx).file())
1062            .is_some_and(|file| {
1063                std::path::Path::new(file.file_name(cx))
1064                    .extension()
1065                    .is_some_and(|ext| ext.eq_ignore_ascii_case("svg"))
1066            });
1067
1068        if is_markdown {
1069            actions.push((
1070                "Open Markdown Preview".into(),
1071                Box::new(OpenMarkdownPreview) as Box<dyn gpui::Action>,
1072            ));
1073        }
1074
1075        if is_svg {
1076            actions.push((
1077                "Open SVG Preview".into(),
1078                Box::new(OpenSvgPreview) as Box<dyn gpui::Action>,
1079            ));
1080        }
1081
1082        actions
1083    }
1084
1085    fn preserve_preview(&self, cx: &App) -> bool {
1086        self.buffer.read(cx).preserve_preview(cx)
1087    }
1088}
1089
1090impl SerializableItem for Editor {
1091    fn serialized_item_kind() -> &'static str {
1092        "Editor"
1093    }
1094
1095    fn cleanup(
1096        workspace_id: WorkspaceId,
1097        alive_items: Vec<ItemId>,
1098        _window: &mut Window,
1099        cx: &mut App,
1100    ) -> Task<Result<()>> {
1101        workspace::delete_unloaded_items(alive_items, workspace_id, "editors", &DB, cx)
1102    }
1103
1104    fn deserialize(
1105        project: Entity<Project>,
1106        workspace: WeakEntity<Workspace>,
1107        workspace_id: workspace::WorkspaceId,
1108        item_id: ItemId,
1109        window: &mut Window,
1110        cx: &mut App,
1111    ) -> Task<Result<Entity<Self>>> {
1112        let serialized_editor = match DB
1113            .get_serialized_editor(item_id, workspace_id)
1114            .context("Failed to query editor state")
1115        {
1116            Ok(Some(serialized_editor)) => {
1117                if ProjectSettings::get_global(cx)
1118                    .session
1119                    .restore_unsaved_buffers
1120                {
1121                    serialized_editor
1122                } else {
1123                    SerializedEditor {
1124                        abs_path: serialized_editor.abs_path,
1125                        contents: None,
1126                        language: None,
1127                        mtime: None,
1128                    }
1129                }
1130            }
1131            Ok(None) => {
1132                return Task::ready(Err(anyhow!(
1133                    "Unable to deserialize editor: No entry in database for item_id: {item_id} and workspace_id {workspace_id:?}"
1134                )));
1135            }
1136            Err(error) => {
1137                return Task::ready(Err(error));
1138            }
1139        };
1140        log::debug!(
1141            "Deserialized editor {item_id:?} in workspace {workspace_id:?}, {serialized_editor:?}"
1142        );
1143
1144        match serialized_editor {
1145            SerializedEditor {
1146                abs_path: None,
1147                contents: Some(contents),
1148                language,
1149                ..
1150            } => window.spawn(cx, {
1151                let project = project.clone();
1152                async move |cx| {
1153                    let language_registry =
1154                        project.read_with(cx, |project, _| project.languages().clone());
1155
1156                    let language = if let Some(language_name) = language {
1157                        // We don't fail here, because we'd rather not set the language if the name changed
1158                        // than fail to restore the buffer.
1159                        language_registry
1160                            .language_for_name(&language_name)
1161                            .await
1162                            .ok()
1163                    } else {
1164                        None
1165                    };
1166
1167                    // First create the empty buffer
1168                    let buffer = project
1169                        .update(cx, |project, cx| project.create_buffer(language, true, cx))
1170                        .await
1171                        .context("Failed to create buffer while deserializing editor")?;
1172
1173                    // Then set the text so that the dirty bit is set correctly
1174                    buffer.update(cx, |buffer, cx| {
1175                        buffer.set_language_registry(language_registry);
1176                        buffer.set_text(contents, cx);
1177                        if let Some(entry) = buffer.peek_undo_stack() {
1178                            buffer.forget_transaction(entry.transaction_id());
1179                        }
1180                    });
1181
1182                    cx.update(|window, cx| {
1183                        cx.new(|cx| {
1184                            let mut editor = Editor::for_buffer(buffer, Some(project), window, cx);
1185
1186                            editor.read_metadata_from_db(item_id, workspace_id, window, cx);
1187                            editor
1188                        })
1189                    })
1190                }
1191            }),
1192            SerializedEditor {
1193                abs_path: Some(abs_path),
1194                contents,
1195                mtime,
1196                ..
1197            } => {
1198                let opened_buffer = project.update(cx, |project, cx| {
1199                    let (worktree, path) = project.find_worktree(&abs_path, cx)?;
1200                    let project_path = ProjectPath {
1201                        worktree_id: worktree.read(cx).id(),
1202                        path: path,
1203                    };
1204                    Some(project.open_path(project_path, cx))
1205                });
1206
1207                match opened_buffer {
1208                    Some(opened_buffer) => window.spawn(cx, async move |cx| {
1209                        let (_, buffer) = opened_buffer
1210                            .await
1211                            .context("Failed to open path in project")?;
1212
1213                        if let Some(contents) = contents {
1214                            buffer.update(cx, |buffer, cx| {
1215                                restore_serialized_buffer_contents(buffer, contents, mtime, cx);
1216                            });
1217                        }
1218
1219                        cx.update(|window, cx| {
1220                            cx.new(|cx| {
1221                                let mut editor =
1222                                    Editor::for_buffer(buffer, Some(project), window, cx);
1223
1224                                editor.read_metadata_from_db(item_id, workspace_id, window, cx);
1225                                editor
1226                            })
1227                        })
1228                    }),
1229                    None => {
1230                        // File is not in any worktree (e.g., opened as a standalone file)
1231                        // We need to open it via workspace and then restore dirty contents
1232                        window.spawn(cx, async move |cx| {
1233                            let open_by_abs_path =
1234                                workspace.update_in(cx, |workspace, window, cx| {
1235                                    workspace.open_abs_path(
1236                                        abs_path.clone(),
1237                                        OpenOptions {
1238                                            visible: Some(OpenVisible::None),
1239                                            ..Default::default()
1240                                        },
1241                                        window,
1242                                        cx,
1243                                    )
1244                                })?;
1245                            let editor =
1246                                open_by_abs_path.await?.downcast::<Editor>().with_context(
1247                                    || format!("path {abs_path:?} cannot be opened as an Editor"),
1248                                )?;
1249
1250                            if let Some(contents) = contents {
1251                                editor.update_in(cx, |editor, _window, cx| {
1252                                    if let Some(buffer) = editor.buffer().read(cx).as_singleton() {
1253                                        buffer.update(cx, |buffer, cx| {
1254                                            restore_serialized_buffer_contents(
1255                                                buffer, contents, mtime, cx,
1256                                            );
1257                                        });
1258                                    }
1259                                })?;
1260                            }
1261
1262                            editor.update_in(cx, |editor, window, cx| {
1263                                editor.read_metadata_from_db(item_id, workspace_id, window, cx);
1264                            })?;
1265                            Ok(editor)
1266                        })
1267                    }
1268                }
1269            }
1270            SerializedEditor {
1271                abs_path: None,
1272                contents: None,
1273                ..
1274            } => window.spawn(cx, async move |cx| {
1275                let buffer = project
1276                    .update(cx, |project, cx| project.create_buffer(None, true, cx))
1277                    .await
1278                    .context("Failed to create buffer")?;
1279
1280                cx.update(|window, cx| {
1281                    cx.new(|cx| {
1282                        let mut editor = Editor::for_buffer(buffer, Some(project), window, cx);
1283
1284                        editor.read_metadata_from_db(item_id, workspace_id, window, cx);
1285                        editor
1286                    })
1287                })
1288            }),
1289        }
1290    }
1291
1292    fn serialize(
1293        &mut self,
1294        workspace: &mut Workspace,
1295        item_id: ItemId,
1296        closing: bool,
1297        window: &mut Window,
1298        cx: &mut Context<Self>,
1299    ) -> Option<Task<Result<()>>> {
1300        let buffer_serialization = self.buffer_serialization?;
1301        let project = self.project.clone()?;
1302
1303        let serialize_dirty_buffers = match buffer_serialization {
1304            // Always serialize dirty buffers, including for worktree-less windows.
1305            // This enables hot-exit functionality for empty windows and single files.
1306            BufferSerialization::All => true,
1307            BufferSerialization::NonDirtyBuffers => false,
1308        };
1309
1310        if closing && !serialize_dirty_buffers {
1311            return None;
1312        }
1313
1314        let workspace_id = workspace.database_id()?;
1315
1316        let buffer = self.buffer().read(cx).as_singleton()?;
1317
1318        let abs_path = buffer.read(cx).file().and_then(|file| {
1319            let worktree_id = file.worktree_id(cx);
1320            project
1321                .read(cx)
1322                .worktree_for_id(worktree_id, cx)
1323                .map(|worktree| worktree.read(cx).absolutize(file.path()))
1324                .or_else(|| {
1325                    let full_path = file.full_path(cx);
1326                    let project_path = project.read(cx).find_project_path(&full_path, cx)?;
1327                    project.read(cx).absolute_path(&project_path, cx)
1328                })
1329        });
1330
1331        let is_dirty = buffer.read(cx).is_dirty();
1332        let mtime = buffer.read(cx).saved_mtime();
1333
1334        let snapshot = buffer.read(cx).snapshot();
1335
1336        Some(cx.spawn_in(window, async move |_this, cx| {
1337            cx.background_spawn(async move {
1338                let (contents, language) = if serialize_dirty_buffers && is_dirty {
1339                    let contents = snapshot.text();
1340                    let language = snapshot.language().map(|lang| lang.name().to_string());
1341                    (Some(contents), language)
1342                } else {
1343                    (None, None)
1344                };
1345
1346                let editor = SerializedEditor {
1347                    abs_path,
1348                    contents,
1349                    language,
1350                    mtime,
1351                };
1352                log::debug!("Serializing editor {item_id:?} in workspace {workspace_id:?}");
1353                DB.save_serialized_editor(item_id, workspace_id, editor)
1354                    .await
1355                    .context("failed to save serialized editor")
1356            })
1357            .await
1358            .context("failed to save contents of buffer")?;
1359
1360            Ok(())
1361        }))
1362    }
1363
1364    fn should_serialize(&self, event: &Self::Event) -> bool {
1365        self.should_serialize_buffer()
1366            && matches!(
1367                event,
1368                EditorEvent::Saved | EditorEvent::DirtyChanged | EditorEvent::BufferEdited
1369            )
1370    }
1371}
1372
1373#[derive(Debug, Default)]
1374struct EditorRestorationData {
1375    entries: HashMap<PathBuf, RestorationData>,
1376}
1377
1378#[derive(Default, Debug)]
1379pub struct RestorationData {
1380    pub scroll_position: (BufferRow, gpui::Point<ScrollOffset>),
1381    pub folds: Vec<Range<Point>>,
1382    pub selections: Vec<Range<Point>>,
1383}
1384
1385impl ProjectItem for Editor {
1386    type Item = Buffer;
1387
1388    fn project_item_kind() -> Option<ProjectItemKind> {
1389        Some(ProjectItemKind("Editor"))
1390    }
1391
1392    fn for_project_item(
1393        project: Entity<Project>,
1394        pane: Option<&Pane>,
1395        buffer: Entity<Buffer>,
1396        window: &mut Window,
1397        cx: &mut Context<Self>,
1398    ) -> Self {
1399        let mut editor = Self::for_buffer(buffer.clone(), Some(project), window, cx);
1400        if let Some((excerpt_id, _, snapshot)) =
1401            editor.buffer().read(cx).snapshot(cx).as_singleton()
1402            && WorkspaceSettings::get(None, cx).restore_on_file_reopen
1403            && let Some(restoration_data) = Self::project_item_kind()
1404                .and_then(|kind| pane.as_ref()?.project_item_restoration_data.get(&kind))
1405                .and_then(|data| data.downcast_ref::<EditorRestorationData>())
1406                .and_then(|data| {
1407                    let file = project::File::from_dyn(buffer.read(cx).file())?;
1408                    data.entries.get(&file.abs_path(cx))
1409                })
1410        {
1411            editor.fold_ranges(
1412                clip_ranges(&restoration_data.folds, snapshot),
1413                false,
1414                window,
1415                cx,
1416            );
1417            if !restoration_data.selections.is_empty() {
1418                editor.change_selections(SelectionEffects::no_scroll(), window, cx, |s| {
1419                    s.select_ranges(clip_ranges(&restoration_data.selections, snapshot));
1420                });
1421            }
1422            let (top_row, offset) = restoration_data.scroll_position;
1423            let anchor =
1424                Anchor::in_buffer(excerpt_id, snapshot.anchor_before(Point::new(top_row, 0)));
1425            editor.set_scroll_anchor(ScrollAnchor { anchor, offset }, window, cx);
1426        }
1427
1428        editor
1429    }
1430
1431    fn for_broken_project_item(
1432        abs_path: &Path,
1433        is_local: bool,
1434        e: &anyhow::Error,
1435        window: &mut Window,
1436        cx: &mut App,
1437    ) -> Option<InvalidItemView> {
1438        Some(InvalidItemView::new(abs_path, is_local, e, window, cx))
1439    }
1440}
1441
1442fn clip_ranges<'a>(
1443    original: impl IntoIterator<Item = &'a Range<Point>> + 'a,
1444    snapshot: &'a BufferSnapshot,
1445) -> Vec<Range<Point>> {
1446    original
1447        .into_iter()
1448        .map(|range| {
1449            snapshot.clip_point(range.start, Bias::Left)
1450                ..snapshot.clip_point(range.end, Bias::Right)
1451        })
1452        .collect()
1453}
1454
1455impl EventEmitter<SearchEvent> for Editor {}
1456
1457impl Editor {
1458    pub fn update_restoration_data(
1459        &self,
1460        cx: &mut Context<Self>,
1461        write: impl for<'a> FnOnce(&'a mut RestorationData) + 'static,
1462    ) {
1463        if self.mode.is_minimap() || !WorkspaceSettings::get(None, cx).restore_on_file_reopen {
1464            return;
1465        }
1466
1467        let editor = cx.entity();
1468        cx.defer(move |cx| {
1469            editor.update(cx, |editor, cx| {
1470                let kind = Editor::project_item_kind()?;
1471                let pane = editor.workspace()?.read(cx).pane_for(&cx.entity())?;
1472                let buffer = editor.buffer().read(cx).as_singleton()?;
1473                let file_abs_path = project::File::from_dyn(buffer.read(cx).file())?.abs_path(cx);
1474                pane.update(cx, |pane, _| {
1475                    let data = pane
1476                        .project_item_restoration_data
1477                        .entry(kind)
1478                        .or_insert_with(|| Box::new(EditorRestorationData::default()) as Box<_>);
1479                    let data = match data.downcast_mut::<EditorRestorationData>() {
1480                        Some(data) => data,
1481                        None => {
1482                            *data = Box::new(EditorRestorationData::default());
1483                            data.downcast_mut::<EditorRestorationData>()
1484                                .expect("just written the type downcasted to")
1485                        }
1486                    };
1487
1488                    let data = data.entries.entry(file_abs_path).or_default();
1489                    write(data);
1490                    Some(())
1491                })
1492            });
1493        });
1494    }
1495}
1496
1497impl SearchableItem for Editor {
1498    type Match = Range<Anchor>;
1499
1500    fn get_matches(&self, _window: &mut Window, _: &mut App) -> (Vec<Range<Anchor>>, SearchToken) {
1501        (
1502            self.background_highlights
1503                .get(&HighlightKey::BufferSearchHighlights)
1504                .map_or(Vec::new(), |(_color, ranges)| {
1505                    ranges.iter().cloned().collect()
1506                }),
1507            SearchToken::default(),
1508        )
1509    }
1510
1511    fn clear_matches(&mut self, _: &mut Window, cx: &mut Context<Self>) {
1512        if self
1513            .clear_background_highlights(HighlightKey::BufferSearchHighlights, cx)
1514            .is_some()
1515        {
1516            cx.emit(SearchEvent::MatchesInvalidated);
1517        }
1518    }
1519
1520    fn update_matches(
1521        &mut self,
1522        matches: &[Range<Anchor>],
1523        active_match_index: Option<usize>,
1524        _token: SearchToken,
1525        _: &mut Window,
1526        cx: &mut Context<Self>,
1527    ) {
1528        let existing_range = self
1529            .background_highlights
1530            .get(&HighlightKey::BufferSearchHighlights)
1531            .map(|(_, range)| range.as_ref());
1532        let updated = existing_range != Some(matches);
1533        self.highlight_background(
1534            HighlightKey::BufferSearchHighlights,
1535            matches,
1536            move |index, theme| {
1537                if active_match_index == Some(*index) {
1538                    theme.colors().search_active_match_background
1539                } else {
1540                    theme.colors().search_match_background
1541                }
1542            },
1543            cx,
1544        );
1545        if updated {
1546            cx.emit(SearchEvent::MatchesInvalidated);
1547        }
1548    }
1549
1550    fn has_filtered_search_ranges(&mut self) -> bool {
1551        self.has_background_highlights(HighlightKey::SearchWithinRange)
1552    }
1553
1554    fn toggle_filtered_search_ranges(
1555        &mut self,
1556        enabled: Option<FilteredSearchRange>,
1557        _: &mut Window,
1558        cx: &mut Context<Self>,
1559    ) {
1560        if self.has_filtered_search_ranges() {
1561            self.previous_search_ranges = self
1562                .clear_background_highlights(HighlightKey::SearchWithinRange, cx)
1563                .map(|(_, ranges)| ranges)
1564        }
1565
1566        if let Some(range) = enabled {
1567            let ranges = self.selections.disjoint_anchor_ranges().collect::<Vec<_>>();
1568
1569            if ranges.iter().any(|s| s.start != s.end) {
1570                self.set_search_within_ranges(&ranges, cx);
1571            } else if let Some(previous_search_ranges) = self.previous_search_ranges.take()
1572                && range != FilteredSearchRange::Selection
1573            {
1574                self.set_search_within_ranges(&previous_search_ranges, cx);
1575            }
1576        }
1577    }
1578
1579    fn supported_options(&self) -> SearchOptions {
1580        if self.in_project_search {
1581            SearchOptions {
1582                case: true,
1583                word: true,
1584                regex: true,
1585                replacement: false,
1586                selection: false,
1587                find_in_results: true,
1588            }
1589        } else {
1590            SearchOptions {
1591                case: true,
1592                word: true,
1593                regex: true,
1594                replacement: true,
1595                selection: true,
1596                find_in_results: false,
1597            }
1598        }
1599    }
1600
1601    fn query_suggestion(&mut self, window: &mut Window, cx: &mut Context<Self>) -> String {
1602        let setting = EditorSettings::get_global(cx).seed_search_query_from_cursor;
1603        let snapshot = self.snapshot(window, cx);
1604        let selection = self.selections.newest_adjusted(&snapshot.display_snapshot);
1605        let buffer_snapshot = snapshot.buffer_snapshot();
1606
1607        match setting {
1608            SeedQuerySetting::Never => String::new(),
1609            SeedQuerySetting::Selection | SeedQuerySetting::Always if !selection.is_empty() => {
1610                let text: String = buffer_snapshot
1611                    .text_for_range(selection.start..selection.end)
1612                    .collect();
1613                if text.contains('\n') {
1614                    String::new()
1615                } else {
1616                    text
1617                }
1618            }
1619            SeedQuerySetting::Selection => String::new(),
1620            SeedQuerySetting::Always => {
1621                let (range, kind) = buffer_snapshot
1622                    .surrounding_word(selection.start, Some(CharScopeContext::Completion));
1623                if kind == Some(CharKind::Word) {
1624                    let text: String = buffer_snapshot.text_for_range(range).collect();
1625                    if !text.trim().is_empty() {
1626                        return text;
1627                    }
1628                }
1629                String::new()
1630            }
1631        }
1632    }
1633
1634    fn activate_match(
1635        &mut self,
1636        index: usize,
1637        matches: &[Range<Anchor>],
1638        _token: SearchToken,
1639        window: &mut Window,
1640        cx: &mut Context<Self>,
1641    ) {
1642        self.unfold_ranges(&[matches[index].clone()], false, true, cx);
1643        let range = self.range_for_match(&matches[index]);
1644        let autoscroll = if EditorSettings::get_global(cx).search.center_on_match {
1645            Autoscroll::center()
1646        } else {
1647            Autoscroll::fit()
1648        };
1649        self.change_selections(SelectionEffects::scroll(autoscroll), window, cx, |s| {
1650            s.select_ranges([range]);
1651        })
1652    }
1653
1654    fn select_matches(
1655        &mut self,
1656        matches: &[Self::Match],
1657        _token: SearchToken,
1658        window: &mut Window,
1659        cx: &mut Context<Self>,
1660    ) {
1661        self.unfold_ranges(matches, false, false, cx);
1662        self.change_selections(SelectionEffects::no_scroll(), window, cx, |s| {
1663            s.select_ranges(matches.iter().cloned())
1664        });
1665    }
1666    fn replace(
1667        &mut self,
1668        identifier: &Self::Match,
1669        query: &SearchQuery,
1670        _token: SearchToken,
1671        window: &mut Window,
1672        cx: &mut Context<Self>,
1673    ) {
1674        let text = self.buffer.read(cx);
1675        let text = text.snapshot(cx);
1676        let text = text.text_for_range(identifier.clone()).collect::<Vec<_>>();
1677        let text: Cow<_> = if text.len() == 1 {
1678            text.first().cloned().unwrap().into()
1679        } else {
1680            let joined_chunks = text.join("");
1681            joined_chunks.into()
1682        };
1683
1684        if let Some(replacement) = query.replacement_for(&text) {
1685            self.transact(window, cx, |this, _, cx| {
1686                this.edit([(identifier.clone(), Arc::from(&*replacement))], cx);
1687            });
1688        }
1689    }
1690    fn replace_all(
1691        &mut self,
1692        matches: &mut dyn Iterator<Item = &Self::Match>,
1693        query: &SearchQuery,
1694        _token: SearchToken,
1695        window: &mut Window,
1696        cx: &mut Context<Self>,
1697    ) {
1698        let text = self.buffer.read(cx);
1699        let text = text.snapshot(cx);
1700        let mut edits = vec![];
1701
1702        // A regex might have replacement variables so we cannot apply
1703        // the same replacement to all matches
1704        if query.is_regex() {
1705            edits = matches
1706                .filter_map(|m| {
1707                    let text = text.text_for_range(m.clone()).collect::<Vec<_>>();
1708
1709                    let text: Cow<_> = if text.len() == 1 {
1710                        text.first().cloned().unwrap().into()
1711                    } else {
1712                        let joined_chunks = text.join("");
1713                        joined_chunks.into()
1714                    };
1715
1716                    query
1717                        .replacement_for(&text)
1718                        .map(|replacement| (m.clone(), Arc::from(&*replacement)))
1719                })
1720                .collect();
1721        } else if let Some(replacement) = query.replacement().map(Arc::<str>::from) {
1722            edits = matches.map(|m| (m.clone(), replacement.clone())).collect();
1723        }
1724
1725        if !edits.is_empty() {
1726            self.transact(window, cx, |this, _, cx| {
1727                this.edit(edits, cx);
1728            });
1729        }
1730    }
1731    fn match_index_for_direction(
1732        &mut self,
1733        matches: &[Range<Anchor>],
1734        current_index: usize,
1735        direction: Direction,
1736        count: usize,
1737        _token: SearchToken,
1738        _: &mut Window,
1739        cx: &mut Context<Self>,
1740    ) -> usize {
1741        let buffer = self.buffer().read(cx).snapshot(cx);
1742        let current_index_position = if self.selections.disjoint_anchors_arc().len() == 1 {
1743            self.selections.newest_anchor().head()
1744        } else {
1745            matches[current_index].start
1746        };
1747
1748        let mut count = count % matches.len();
1749        if count == 0 {
1750            return current_index;
1751        }
1752        match direction {
1753            Direction::Next => {
1754                if matches[current_index]
1755                    .start
1756                    .cmp(&current_index_position, &buffer)
1757                    .is_gt()
1758                {
1759                    count -= 1
1760                }
1761
1762                (current_index + count) % matches.len()
1763            }
1764            Direction::Prev => {
1765                if matches[current_index]
1766                    .end
1767                    .cmp(&current_index_position, &buffer)
1768                    .is_lt()
1769                {
1770                    count -= 1;
1771                }
1772
1773                if current_index >= count {
1774                    current_index - count
1775                } else {
1776                    matches.len() - (count - current_index)
1777                }
1778            }
1779        }
1780    }
1781
1782    fn find_matches(
1783        &mut self,
1784        query: Arc<project::search::SearchQuery>,
1785        _: &mut Window,
1786        cx: &mut Context<Self>,
1787    ) -> Task<Vec<Range<Anchor>>> {
1788        let buffer = self.buffer().read(cx).snapshot(cx);
1789        let search_within_ranges = self
1790            .background_highlights
1791            .get(&HighlightKey::SearchWithinRange)
1792            .map_or(vec![], |(_color, ranges)| {
1793                ranges.iter().cloned().collect::<Vec<_>>()
1794            });
1795
1796        cx.background_spawn(async move {
1797            let mut ranges = Vec::new();
1798
1799            let search_within_ranges = if search_within_ranges.is_empty() {
1800                vec![buffer.anchor_before(MultiBufferOffset(0))..buffer.anchor_after(buffer.len())]
1801            } else {
1802                search_within_ranges
1803            };
1804
1805            for range in search_within_ranges {
1806                for (search_buffer, search_range, excerpt_id, deleted_hunk_anchor) in
1807                    buffer.range_to_buffer_ranges_with_deleted_hunks(range)
1808                {
1809                    ranges.extend(
1810                        query
1811                            .search(
1812                                search_buffer,
1813                                Some(search_range.start.0..search_range.end.0),
1814                            )
1815                            .await
1816                            .into_iter()
1817                            .map(|match_range| {
1818                                if let Some(deleted_hunk_anchor) = deleted_hunk_anchor {
1819                                    let start = search_buffer
1820                                        .anchor_after(search_range.start + match_range.start);
1821                                    let end = search_buffer
1822                                        .anchor_before(search_range.start + match_range.end);
1823                                    deleted_hunk_anchor.with_diff_base_anchor(start)
1824                                        ..deleted_hunk_anchor.with_diff_base_anchor(end)
1825                                } else {
1826                                    let start = search_buffer
1827                                        .anchor_after(search_range.start + match_range.start);
1828                                    let end = search_buffer
1829                                        .anchor_before(search_range.start + match_range.end);
1830                                    Anchor::range_in_buffer(excerpt_id, start..end)
1831                                }
1832                            }),
1833                    );
1834                }
1835            }
1836
1837            ranges
1838        })
1839    }
1840
1841    fn active_match_index(
1842        &mut self,
1843        direction: Direction,
1844        matches: &[Range<Anchor>],
1845        _token: SearchToken,
1846        _: &mut Window,
1847        cx: &mut Context<Self>,
1848    ) -> Option<usize> {
1849        active_match_index(
1850            direction,
1851            matches,
1852            &self.selections.newest_anchor().head(),
1853            &self.buffer().read(cx).snapshot(cx),
1854        )
1855    }
1856
1857    fn search_bar_visibility_changed(&mut self, _: bool, _: &mut Window, _: &mut Context<Self>) {
1858        self.expect_bounds_change = self.last_bounds;
1859    }
1860
1861    fn set_search_is_case_sensitive(
1862        &mut self,
1863        case_sensitive: Option<bool>,
1864        _cx: &mut Context<Self>,
1865    ) {
1866        self.select_next_is_case_sensitive = case_sensitive;
1867    }
1868}
1869
1870pub fn active_match_index(
1871    direction: Direction,
1872    ranges: &[Range<Anchor>],
1873    cursor: &Anchor,
1874    buffer: &MultiBufferSnapshot,
1875) -> Option<usize> {
1876    if ranges.is_empty() {
1877        None
1878    } else {
1879        let r = ranges.binary_search_by(|probe| {
1880            if probe.end.cmp(cursor, buffer).is_lt() {
1881                Ordering::Less
1882            } else if probe.start.cmp(cursor, buffer).is_gt() {
1883                Ordering::Greater
1884            } else {
1885                Ordering::Equal
1886            }
1887        });
1888        match direction {
1889            Direction::Prev => match r {
1890                Ok(i) => Some(i),
1891                Err(i) => Some(i.saturating_sub(1)),
1892            },
1893            Direction::Next => match r {
1894                Ok(i) | Err(i) => Some(cmp::min(i, ranges.len() - 1)),
1895            },
1896        }
1897    }
1898}
1899
1900pub fn entry_label_color(selected: bool) -> Color {
1901    if selected {
1902        Color::Default
1903    } else {
1904        Color::Muted
1905    }
1906}
1907
1908pub fn entry_diagnostic_aware_icon_name_and_color(
1909    diagnostic_severity: Option<DiagnosticSeverity>,
1910) -> Option<(IconName, Color)> {
1911    match diagnostic_severity {
1912        Some(DiagnosticSeverity::ERROR) => Some((IconName::Close, Color::Error)),
1913        Some(DiagnosticSeverity::WARNING) => Some((IconName::Triangle, Color::Warning)),
1914        _ => None,
1915    }
1916}
1917
1918pub fn entry_diagnostic_aware_icon_decoration_and_color(
1919    diagnostic_severity: Option<DiagnosticSeverity>,
1920) -> Option<(IconDecorationKind, Color)> {
1921    match diagnostic_severity {
1922        Some(DiagnosticSeverity::ERROR) => Some((IconDecorationKind::X, Color::Error)),
1923        Some(DiagnosticSeverity::WARNING) => Some((IconDecorationKind::Triangle, Color::Warning)),
1924        _ => None,
1925    }
1926}
1927
1928pub fn entry_git_aware_label_color(git_status: GitSummary, ignored: bool, selected: bool) -> Color {
1929    let tracked = git_status.index + git_status.worktree;
1930    if git_status.conflict > 0 {
1931        Color::Conflict
1932    } else if tracked.modified > 0 {
1933        Color::Modified
1934    } else if tracked.added > 0 || git_status.untracked > 0 {
1935        Color::Created
1936    } else if ignored {
1937        Color::Ignored
1938    } else {
1939        entry_label_color(selected)
1940    }
1941}
1942
1943fn path_for_buffer<'a>(
1944    buffer: &Entity<MultiBuffer>,
1945    height: usize,
1946    include_filename: bool,
1947    cx: &'a App,
1948) -> Option<Cow<'a, str>> {
1949    let file = buffer.read(cx).as_singleton()?.read(cx).file()?;
1950    path_for_file(file, height, include_filename, cx)
1951}
1952
1953fn path_for_file<'a>(
1954    file: &'a Arc<dyn language::File>,
1955    mut height: usize,
1956    include_filename: bool,
1957    cx: &'a App,
1958) -> Option<Cow<'a, str>> {
1959    if project::File::from_dyn(Some(file)).is_none() {
1960        return None;
1961    }
1962
1963    let file = file.as_ref();
1964    // Ensure we always render at least the filename.
1965    height += 1;
1966
1967    let mut prefix = file.path().as_ref();
1968    while height > 0 {
1969        if let Some(parent) = prefix.parent() {
1970            prefix = parent;
1971            height -= 1;
1972        } else {
1973            break;
1974        }
1975    }
1976
1977    // The full_path method allocates, so avoid calling it if height is zero.
1978    if height > 0 {
1979        let mut full_path = file.full_path(cx);
1980        if !include_filename {
1981            if !full_path.pop() {
1982                return None;
1983            }
1984        }
1985        Some(full_path.to_string_lossy().into_owned().into())
1986    } else {
1987        let mut path = file.path().strip_prefix(prefix).ok()?;
1988        if !include_filename {
1989            path = path.parent()?;
1990        }
1991        Some(path.display(file.path_style(cx)))
1992    }
1993}
1994
1995/// Restores serialized buffer contents by overwriting the buffer with saved text.
1996/// This is somewhat wasteful since we load the whole buffer from disk then overwrite it,
1997/// but keeps implementation simple as we don't need to persist all metadata from loading
1998/// (git diff base, etc.).
1999fn restore_serialized_buffer_contents(
2000    buffer: &mut Buffer,
2001    contents: String,
2002    mtime: Option<MTime>,
2003    cx: &mut Context<Buffer>,
2004) {
2005    // If we did restore an mtime, store it on the buffer so that
2006    // the next edit will mark the buffer as dirty/conflicted.
2007    if mtime.is_some() {
2008        buffer.did_reload(buffer.version(), buffer.line_ending(), mtime, cx);
2009    }
2010    buffer.set_text(contents, cx);
2011    if let Some(entry) = buffer.peek_undo_stack() {
2012        buffer.forget_transaction(entry.transaction_id());
2013    }
2014}
2015
2016#[cfg(test)]
2017mod tests {
2018    use crate::editor_tests::init_test;
2019    use fs::Fs;
2020    use workspace::MultiWorkspace;
2021
2022    use super::*;
2023    use fs::MTime;
2024    use gpui::{App, VisualTestContext};
2025    use language::TestFile;
2026    use project::FakeFs;
2027    use std::path::{Path, PathBuf};
2028    use util::{path, rel_path::RelPath};
2029
2030    #[gpui::test]
2031    fn test_path_for_file(cx: &mut App) {
2032        let file: Arc<dyn language::File> = Arc::new(TestFile {
2033            path: RelPath::empty().into(),
2034            root_name: String::new(),
2035            local_root: None,
2036        });
2037        assert_eq!(path_for_file(&file, 0, false, cx), None);
2038    }
2039
2040    async fn deserialize_editor(
2041        item_id: ItemId,
2042        workspace_id: WorkspaceId,
2043        workspace: Entity<Workspace>,
2044        project: Entity<Project>,
2045        cx: &mut VisualTestContext,
2046    ) -> Entity<Editor> {
2047        workspace
2048            .update_in(cx, |workspace, window, cx| {
2049                let pane = workspace.active_pane();
2050                pane.update(cx, |_, cx| {
2051                    Editor::deserialize(
2052                        project.clone(),
2053                        workspace.weak_handle(),
2054                        workspace_id,
2055                        item_id,
2056                        window,
2057                        cx,
2058                    )
2059                })
2060            })
2061            .await
2062            .unwrap()
2063    }
2064
2065    #[gpui::test]
2066    async fn test_deserialize(cx: &mut gpui::TestAppContext) {
2067        init_test(cx, |_| {});
2068
2069        let fs = FakeFs::new(cx.executor());
2070        fs.insert_file(path!("/file.rs"), Default::default()).await;
2071
2072        // Test case 1: Deserialize with path and contents
2073        {
2074            let project = Project::test(fs.clone(), [path!("/file.rs").as_ref()], cx).await;
2075            let (multi_workspace, cx) = cx.add_window_view(|window, cx| {
2076                MultiWorkspace::test_new(project.clone(), window, cx)
2077            });
2078            let workspace = multi_workspace.read_with(cx, |mw, _| mw.workspace().clone());
2079            let workspace_id = workspace::WORKSPACE_DB.next_id().await.unwrap();
2080            let item_id = 1234 as ItemId;
2081            let mtime = fs
2082                .metadata(Path::new(path!("/file.rs")))
2083                .await
2084                .unwrap()
2085                .unwrap()
2086                .mtime;
2087
2088            let serialized_editor = SerializedEditor {
2089                abs_path: Some(PathBuf::from(path!("/file.rs"))),
2090                contents: Some("fn main() {}".to_string()),
2091                language: Some("Rust".to_string()),
2092                mtime: Some(mtime),
2093            };
2094
2095            DB.save_serialized_editor(item_id, workspace_id, serialized_editor.clone())
2096                .await
2097                .unwrap();
2098
2099            let deserialized =
2100                deserialize_editor(item_id, workspace_id, workspace, project, cx).await;
2101
2102            deserialized.update(cx, |editor, cx| {
2103                assert_eq!(editor.text(cx), "fn main() {}");
2104                assert!(editor.is_dirty(cx));
2105                assert!(!editor.has_conflict(cx));
2106                let buffer = editor.buffer().read(cx).as_singleton().unwrap().read(cx);
2107                assert!(buffer.file().is_some());
2108            });
2109        }
2110
2111        // Test case 2: Deserialize with only path
2112        {
2113            let project = Project::test(fs.clone(), [path!("/file.rs").as_ref()], cx).await;
2114            let (multi_workspace, cx) = cx.add_window_view(|window, cx| {
2115                MultiWorkspace::test_new(project.clone(), window, cx)
2116            });
2117            let workspace = multi_workspace.read_with(cx, |mw, _| mw.workspace().clone());
2118
2119            let workspace_id = workspace::WORKSPACE_DB.next_id().await.unwrap();
2120
2121            let item_id = 5678 as ItemId;
2122            let serialized_editor = SerializedEditor {
2123                abs_path: Some(PathBuf::from(path!("/file.rs"))),
2124                contents: None,
2125                language: None,
2126                mtime: None,
2127            };
2128
2129            DB.save_serialized_editor(item_id, workspace_id, serialized_editor)
2130                .await
2131                .unwrap();
2132
2133            let deserialized =
2134                deserialize_editor(item_id, workspace_id, workspace, project, cx).await;
2135
2136            deserialized.update(cx, |editor, cx| {
2137                assert_eq!(editor.text(cx), ""); // The file should be empty as per our initial setup
2138                assert!(!editor.is_dirty(cx));
2139                assert!(!editor.has_conflict(cx));
2140
2141                let buffer = editor.buffer().read(cx).as_singleton().unwrap().read(cx);
2142                assert!(buffer.file().is_some());
2143            });
2144        }
2145
2146        // Test case 3: Deserialize with no path (untitled buffer, with content and language)
2147        {
2148            let project = Project::test(fs.clone(), [path!("/file.rs").as_ref()], cx).await;
2149            // Add Rust to the language, so that we can restore the language of the buffer
2150            project.read_with(cx, |project, _| {
2151                project.languages().add(languages::rust_lang())
2152            });
2153
2154            let (multi_workspace, cx) = cx.add_window_view(|window, cx| {
2155                MultiWorkspace::test_new(project.clone(), window, cx)
2156            });
2157            let workspace = multi_workspace.read_with(cx, |mw, _| mw.workspace().clone());
2158
2159            let workspace_id = workspace::WORKSPACE_DB.next_id().await.unwrap();
2160
2161            let item_id = 9012 as ItemId;
2162            let serialized_editor = SerializedEditor {
2163                abs_path: None,
2164                contents: Some("hello".to_string()),
2165                language: Some("Rust".to_string()),
2166                mtime: None,
2167            };
2168
2169            DB.save_serialized_editor(item_id, workspace_id, serialized_editor)
2170                .await
2171                .unwrap();
2172
2173            let deserialized =
2174                deserialize_editor(item_id, workspace_id, workspace, project, cx).await;
2175
2176            deserialized.update(cx, |editor, cx| {
2177                assert_eq!(editor.text(cx), "hello");
2178                assert!(editor.is_dirty(cx)); // The editor should be dirty for an untitled buffer
2179
2180                let buffer = editor.buffer().read(cx).as_singleton().unwrap().read(cx);
2181                assert_eq!(
2182                    buffer.language().map(|lang| lang.name()),
2183                    Some("Rust".into())
2184                ); // Language should be set to Rust
2185                assert!(buffer.file().is_none()); // The buffer should not have an associated file
2186            });
2187        }
2188
2189        // Test case 4: Deserialize with path, content, and old mtime
2190        {
2191            let project = Project::test(fs.clone(), [path!("/file.rs").as_ref()], cx).await;
2192            let (multi_workspace, cx) = cx.add_window_view(|window, cx| {
2193                MultiWorkspace::test_new(project.clone(), window, cx)
2194            });
2195            let workspace = multi_workspace.read_with(cx, |mw, _| mw.workspace().clone());
2196
2197            let workspace_id = workspace::WORKSPACE_DB.next_id().await.unwrap();
2198
2199            let item_id = 9345 as ItemId;
2200            let old_mtime = MTime::from_seconds_and_nanos(0, 50);
2201            let serialized_editor = SerializedEditor {
2202                abs_path: Some(PathBuf::from(path!("/file.rs"))),
2203                contents: Some("fn main() {}".to_string()),
2204                language: Some("Rust".to_string()),
2205                mtime: Some(old_mtime),
2206            };
2207
2208            DB.save_serialized_editor(item_id, workspace_id, serialized_editor)
2209                .await
2210                .unwrap();
2211
2212            let deserialized =
2213                deserialize_editor(item_id, workspace_id, workspace, project, cx).await;
2214
2215            deserialized.update(cx, |editor, cx| {
2216                assert_eq!(editor.text(cx), "fn main() {}");
2217                assert!(editor.has_conflict(cx)); // The editor should have a conflict
2218            });
2219        }
2220
2221        // Test case 5: Deserialize with no path, no content, no language, and no old mtime (new, empty, unsaved buffer)
2222        {
2223            let project = Project::test(fs.clone(), [path!("/file.rs").as_ref()], cx).await;
2224            let (multi_workspace, cx) = cx.add_window_view(|window, cx| {
2225                MultiWorkspace::test_new(project.clone(), window, cx)
2226            });
2227            let workspace = multi_workspace.read_with(cx, |mw, _| mw.workspace().clone());
2228
2229            let workspace_id = workspace::WORKSPACE_DB.next_id().await.unwrap();
2230
2231            let item_id = 10000 as ItemId;
2232            let serialized_editor = SerializedEditor {
2233                abs_path: None,
2234                contents: None,
2235                language: None,
2236                mtime: None,
2237            };
2238
2239            DB.save_serialized_editor(item_id, workspace_id, serialized_editor)
2240                .await
2241                .unwrap();
2242
2243            let deserialized =
2244                deserialize_editor(item_id, workspace_id, workspace, project, cx).await;
2245
2246            deserialized.update(cx, |editor, cx| {
2247                assert_eq!(editor.text(cx), "");
2248                assert!(!editor.is_dirty(cx));
2249                assert!(!editor.has_conflict(cx));
2250
2251                let buffer = editor.buffer().read(cx).as_singleton().unwrap().read(cx);
2252                assert!(buffer.file().is_none());
2253            });
2254        }
2255
2256        // Test case 6: Deserialize with path and contents in an empty workspace (no worktree)
2257        // This tests the hot-exit scenario where a file is opened in an empty workspace
2258        // and has unsaved changes that should be restored.
2259        {
2260            let fs = FakeFs::new(cx.executor());
2261            fs.insert_file(path!("/standalone.rs"), "original content".into())
2262                .await;
2263
2264            // Create an empty project with no worktrees
2265            let project = Project::test(fs.clone(), [], cx).await;
2266            let (multi_workspace, cx) = cx.add_window_view(|window, cx| {
2267                MultiWorkspace::test_new(project.clone(), window, cx)
2268            });
2269            let workspace = multi_workspace.read_with(cx, |mw, _| mw.workspace().clone());
2270
2271            let workspace_id = workspace::WORKSPACE_DB.next_id().await.unwrap();
2272            let item_id = 11000 as ItemId;
2273
2274            let mtime = fs
2275                .metadata(Path::new(path!("/standalone.rs")))
2276                .await
2277                .unwrap()
2278                .unwrap()
2279                .mtime;
2280
2281            // Simulate serialized state: file with unsaved changes
2282            let serialized_editor = SerializedEditor {
2283                abs_path: Some(PathBuf::from(path!("/standalone.rs"))),
2284                contents: Some("modified content".to_string()),
2285                language: Some("Rust".to_string()),
2286                mtime: Some(mtime),
2287            };
2288
2289            DB.save_serialized_editor(item_id, workspace_id, serialized_editor)
2290                .await
2291                .unwrap();
2292
2293            let deserialized =
2294                deserialize_editor(item_id, workspace_id, workspace, project, cx).await;
2295
2296            deserialized.update(cx, |editor, cx| {
2297                // The editor should have the serialized contents, not the disk contents
2298                assert_eq!(editor.text(cx), "modified content");
2299                assert!(editor.is_dirty(cx));
2300                assert!(!editor.has_conflict(cx));
2301
2302                let buffer = editor.buffer().read(cx).as_singleton().unwrap().read(cx);
2303                assert!(buffer.file().is_some());
2304            });
2305        }
2306    }
2307}