git: Compute and synchronize diffs from HEAD

crates/collab/src/rpc.rs

@@ -309,7 +309,8 @@ impl Server {
             .add_request_handler(forward_read_only_project_request::<proto::ResolveInlayHint>)
             .add_request_handler(forward_read_only_project_request::<proto::OpenBufferByPath>)
             .add_request_handler(forward_read_only_project_request::<proto::GitBranches>)
-            .add_request_handler(forward_read_only_project_request::<proto::GetStagedText>)
+            .add_request_handler(forward_read_only_project_request::<proto::OpenUnstagedChanges>)
+            .add_request_handler(forward_read_only_project_request::<proto::OpenUncommittedChanges>)
             .add_request_handler(
                 forward_mutating_project_request::<proto::RegisterBufferWithLanguageServers>,
             )
@@ -348,7 +349,7 @@ impl Server {
             .add_message_handler(broadcast_project_message_from_host::<proto::UpdateBufferFile>)
             .add_message_handler(broadcast_project_message_from_host::<proto::BufferReloaded>)
             .add_message_handler(broadcast_project_message_from_host::<proto::BufferSaved>)
-            .add_message_handler(broadcast_project_message_from_host::<proto::UpdateDiffBase>)
+            .add_message_handler(broadcast_project_message_from_host::<proto::UpdateDiffBases>)
             .add_request_handler(get_users)
             .add_request_handler(fuzzy_search_users)
             .add_request_handler(request_contact)

crates/collab/src/tests/editor_tests.rs

@@ -1991,10 +1991,9 @@ async fn test_git_blame_is_forwarded(cx_a: &mut TestAppContext, cx_b: &mut TestA
         .collect(),
         remote_url: Some("[email protected]:zed-industries/zed.git".to_string()),
     };
-    client_a.fs().set_blame_for_repo(
-        Path::new("/my-repo/.git"),
-        vec![(Path::new("file.txt"), blame)],
-    );
+    client_a
+        .fs()
+        .set_blame_for_repo(Path::new("/my-repo/.git"), vec![("file.txt".into(), blame)]);
 
     let (project_a, worktree_id) = client_a.build_local_project("/my-repo", cx_a).await;
     let project_id = active_call_a

crates/collab/src/tests/integration_tests.rs

@@ -2558,29 +2558,47 @@ async fn test_git_diff_base_change(
 
     let project_remote = client_b.join_remote_project(project_id, cx_b).await;
 
-    let diff_base = "
+    let staged_text = "
         one
         three
     "
     .unindent();
 
-    let new_diff_base = "
+    let committed_text = "
+        one
+        TWO
+        three
+    "
+    .unindent();
+
+    let new_committed_text = "
+        one
+        TWO_HUNDRED
+        three
+    "
+    .unindent();
+
+    let new_staged_text = "
         one
         two
     "
     .unindent();
 
     client_a.fs().set_index_for_repo(
         Path::new("/dir/.git"),
-        &[(Path::new("a.txt"), diff_base.clone())],
+        &[("a.txt".into(), staged_text.clone())],
+    );
+    client_a.fs().set_head_for_repo(
+        Path::new("/dir/.git"),
+        &[("a.txt".into(), committed_text.clone())],
     );
 
     // Create the buffer
     let buffer_local_a = project_local
         .update(cx_a, |p, cx| p.open_buffer((worktree_id, "a.txt"), cx))
         .await
         .unwrap();
-    let change_set_local_a = project_local
+    let local_unstaged_changes_a = project_local
         .update(cx_a, |p, cx| {
             p.open_unstaged_changes(buffer_local_a.clone(), cx)
         })
@@ -2589,16 +2607,16 @@ async fn test_git_diff_base_change(
 
     // Wait for it to catch up to the new diff
     executor.run_until_parked();
-    change_set_local_a.read_with(cx_a, |change_set, cx| {
+    local_unstaged_changes_a.read_with(cx_a, |change_set, cx| {
         let buffer = buffer_local_a.read(cx);
         assert_eq!(
             change_set.base_text_string().as_deref(),
-            Some(diff_base.as_str())
+            Some(staged_text.as_str())
         );
         git::diff::assert_hunks(
             change_set.diff_to_buffer.hunks_in_row_range(0..4, buffer),
             buffer,
-            &diff_base,
+            &change_set.base_text_string().unwrap(),
             &[(1..2, "", "two\n")],
         );
     });
@@ -2608,7 +2626,7 @@ async fn test_git_diff_base_change(
         .update(cx_b, |p, cx| p.open_buffer((worktree_id, "a.txt"), cx))
         .await
         .unwrap();
-    let change_set_remote_a = project_remote
+    let remote_unstaged_changes_a = project_remote
         .update(cx_b, |p, cx| {
             p.open_unstaged_changes(buffer_remote_a.clone(), cx)
         })
@@ -2617,80 +2635,120 @@ async fn test_git_diff_base_change(
 
     // Wait remote buffer to catch up to the new diff
     executor.run_until_parked();
-    change_set_remote_a.read_with(cx_b, |change_set, cx| {
+    remote_unstaged_changes_a.read_with(cx_b, |change_set, cx| {
         let buffer = buffer_remote_a.read(cx);
         assert_eq!(
             change_set.base_text_string().as_deref(),
-            Some(diff_base.as_str())
+            Some(staged_text.as_str())
         );
         git::diff::assert_hunks(
             change_set.diff_to_buffer.hunks_in_row_range(0..4, buffer),
             buffer,
-            &diff_base,
+            &change_set.base_text_string().unwrap(),
             &[(1..2, "", "two\n")],
         );
     });
 
-    // Update the staged text of the open buffer
+    // Open uncommitted changes on the guest, without opening them on the host first
+    let remote_uncommitted_changes_a = project_remote
+        .update(cx_b, |p, cx| {
+            p.open_uncommitted_changes(buffer_remote_a.clone(), cx)
+        })
+        .await
+        .unwrap();
+    executor.run_until_parked();
+    remote_uncommitted_changes_a.read_with(cx_b, |change_set, cx| {
+        let buffer = buffer_remote_a.read(cx);
+        assert_eq!(
+            change_set.base_text_string().as_deref(),
+            Some(committed_text.as_str())
+        );
+        git::diff::assert_hunks(
+            change_set.diff_to_buffer.hunks_in_row_range(0..4, buffer),
+            buffer,
+            &change_set.base_text_string().unwrap(),
+            &[(1..2, "TWO\n", "two\n")],
+        );
+    });
+
+    // Update the index text of the open buffer
     client_a.fs().set_index_for_repo(
         Path::new("/dir/.git"),
-        &[(Path::new("a.txt"), new_diff_base.clone())],
+        &[("a.txt".into(), new_staged_text.clone())],
+    );
+    client_a.fs().set_head_for_repo(
+        Path::new("/dir/.git"),
+        &[("a.txt".into(), new_committed_text.clone())],
     );
 
     // Wait for buffer_local_a to receive it
     executor.run_until_parked();
-    change_set_local_a.read_with(cx_a, |change_set, cx| {
+    local_unstaged_changes_a.read_with(cx_a, |change_set, cx| {
         let buffer = buffer_local_a.read(cx);
         assert_eq!(
             change_set.base_text_string().as_deref(),
-            Some(new_diff_base.as_str())
+            Some(new_staged_text.as_str())
         );
         git::diff::assert_hunks(
             change_set.diff_to_buffer.hunks_in_row_range(0..4, buffer),
             buffer,
-            &new_diff_base,
+            &change_set.base_text_string().unwrap(),
             &[(2..3, "", "three\n")],
         );
     });
 
-    change_set_remote_a.read_with(cx_b, |change_set, cx| {
+    remote_unstaged_changes_a.read_with(cx_b, |change_set, cx| {
         let buffer = buffer_remote_a.read(cx);
         assert_eq!(
             change_set.base_text_string().as_deref(),
-            Some(new_diff_base.as_str())
+            Some(new_staged_text.as_str())
         );
         git::diff::assert_hunks(
             change_set.diff_to_buffer.hunks_in_row_range(0..4, buffer),
             buffer,
-            &new_diff_base,
+            &change_set.base_text_string().unwrap(),
             &[(2..3, "", "three\n")],
         );
     });
 
+    remote_uncommitted_changes_a.read_with(cx_b, |change_set, cx| {
+        let buffer = buffer_remote_a.read(cx);
+        assert_eq!(
+            change_set.base_text_string().as_deref(),
+            Some(new_committed_text.as_str())
+        );
+        git::diff::assert_hunks(
+            change_set.diff_to_buffer.hunks_in_row_range(0..4, buffer),
+            buffer,
+            &change_set.base_text_string().unwrap(),
+            &[(1..2, "TWO_HUNDRED\n", "two\n")],
+        );
+    });
+
     // Nested git dir
-    let diff_base = "
+    let staged_text = "
         one
         three
     "
     .unindent();
 
-    let new_diff_base = "
+    let new_staged_text = "
         one
         two
     "
     .unindent();
 
     client_a.fs().set_index_for_repo(
         Path::new("/dir/sub/.git"),
-        &[(Path::new("b.txt"), diff_base.clone())],
+        &[("b.txt".into(), staged_text.clone())],
     );
 
     // Create the buffer
     let buffer_local_b = project_local
         .update(cx_a, |p, cx| p.open_buffer((worktree_id, "sub/b.txt"), cx))
         .await
         .unwrap();
-    let change_set_local_b = project_local
+    let local_unstaged_changes_b = project_local
         .update(cx_a, |p, cx| {
             p.open_unstaged_changes(buffer_local_b.clone(), cx)
         })
@@ -2699,16 +2757,16 @@ async fn test_git_diff_base_change(
 
     // Wait for it to catch up to the new diff
     executor.run_until_parked();
-    change_set_local_b.read_with(cx_a, |change_set, cx| {
+    local_unstaged_changes_b.read_with(cx_a, |change_set, cx| {
         let buffer = buffer_local_b.read(cx);
         assert_eq!(
             change_set.base_text_string().as_deref(),
-            Some(diff_base.as_str())
+            Some(staged_text.as_str())
         );
         git::diff::assert_hunks(
             change_set.diff_to_buffer.hunks_in_row_range(0..4, buffer),
             buffer,
-            &diff_base,
+            &change_set.base_text_string().unwrap(),
             &[(1..2, "", "two\n")],
         );
     });
@@ -2718,60 +2776,60 @@ async fn test_git_diff_base_change(
         .update(cx_b, |p, cx| p.open_buffer((worktree_id, "sub/b.txt"), cx))
         .await
         .unwrap();
-    let change_set_remote_b = project_remote
+    let remote_unstaged_changes_b = project_remote
         .update(cx_b, |p, cx| {
             p.open_unstaged_changes(buffer_remote_b.clone(), cx)
         })
         .await
         .unwrap();
 
     executor.run_until_parked();
-    change_set_remote_b.read_with(cx_b, |change_set, cx| {
+    remote_unstaged_changes_b.read_with(cx_b, |change_set, cx| {
         let buffer = buffer_remote_b.read(cx);
         assert_eq!(
             change_set.base_text_string().as_deref(),
-            Some(diff_base.as_str())
+            Some(staged_text.as_str())
         );
         git::diff::assert_hunks(
             change_set.diff_to_buffer.hunks_in_row_range(0..4, buffer),
             buffer,
-            &diff_base,
+            &staged_text,
             &[(1..2, "", "two\n")],
         );
     });
 
-    // Update the staged text
+    // Updatet the staged text
     client_a.fs().set_index_for_repo(
         Path::new("/dir/sub/.git"),
-        &[(Path::new("b.txt"), new_diff_base.clone())],
+        &[("b.txt".into(), new_staged_text.clone())],
     );
 
     // Wait for buffer_local_b to receive it
     executor.run_until_parked();
-    change_set_local_b.read_with(cx_a, |change_set, cx| {
+    local_unstaged_changes_b.read_with(cx_a, |change_set, cx| {
         let buffer = buffer_local_b.read(cx);
         assert_eq!(
             change_set.base_text_string().as_deref(),
-            Some(new_diff_base.as_str())
+            Some(new_staged_text.as_str())
         );
         git::diff::assert_hunks(
             change_set.diff_to_buffer.hunks_in_row_range(0..4, buffer),
             buffer,
-            &new_diff_base,
+            &new_staged_text,
             &[(2..3, "", "three\n")],
         );
     });
 
-    change_set_remote_b.read_with(cx_b, |change_set, cx| {
+    remote_unstaged_changes_b.read_with(cx_b, |change_set, cx| {
         let buffer = buffer_remote_b.read(cx);
         assert_eq!(
             change_set.base_text_string().as_deref(),
-            Some(new_diff_base.as_str())
+            Some(new_staged_text.as_str())
         );
         git::diff::assert_hunks(
             change_set.diff_to_buffer.hunks_in_row_range(0..4, buffer),
             buffer,
-            &new_diff_base,
+            &new_staged_text,
             &[(2..3, "", "three\n")],
         );
     });

crates/collab/src/tests/random_project_collaboration_tests.rs

@@ -953,8 +953,8 @@ impl RandomizedTest for ProjectCollaborationTest {
 
                     let dot_git_dir = repo_path.join(".git");
                     let contents = contents
-                        .iter()
-                        .map(|(path, contents)| (path.as_path(), contents.clone()))
+                        .into_iter()
+                        .map(|(path, contents)| (path.into(), contents))
                         .collect::<Vec<_>>();
                     if client.fs().metadata(&dot_git_dir).await?.is_none() {
                         client.fs().create_dir(&dot_git_dir).await?;
@@ -1339,7 +1339,7 @@ impl RandomizedTest for ProjectCollaborationTest {
                         project
                             .buffer_store()
                             .read(cx)
-                            .get_unstaged_changes(host_buffer.read(cx).remote_id())
+                            .get_unstaged_changes(host_buffer.read(cx).remote_id(), cx)
                             .unwrap()
                             .read(cx)
                             .base_text_string()
@@ -1348,7 +1348,7 @@ impl RandomizedTest for ProjectCollaborationTest {
                         project
                             .buffer_store()
                             .read(cx)
-                            .get_unstaged_changes(guest_buffer.read(cx).remote_id())
+                            .get_unstaged_changes(guest_buffer.read(cx).remote_id(), cx)
                             .unwrap()
                             .read(cx)
                             .base_text_string()

crates/diagnostics/src/items.rs

@@ -157,7 +157,7 @@ impl DiagnosticIndicator {
             (buffer, cursor_position)
         });
         let new_diagnostic = buffer
-            .diagnostics_in_range::<_, usize>(cursor_position..cursor_position)
+            .diagnostics_in_range::<usize>(cursor_position..cursor_position)
             .filter(|entry| !entry.range.is_empty())
             .min_by_key(|entry| (entry.diagnostic.severity, entry.range.len()))
             .map(|entry| entry.diagnostic);

crates/editor/src/display_map/wrap_map.rs

@@ -979,6 +979,7 @@ impl<'a> Iterator for WrapRows<'a> {
 
         Some(if soft_wrapped {
             RowInfo {
+                buffer_id: None,
                 buffer_row: None,
                 multibuffer_row: None,
                 diff_status,