Revert "Merge pull request #4771 from Byron/git2-to-gix"

This reverts commit 47b6d41, reversing
changes made to b2cdc37.

Cargo.toml

@@ -90,8 +90,3 @@ codegen-units = 1 # Compile crates one after another so the compiler can optimiz
 lto = true        # Enables link to optimizations
 opt-level = "s"   # Optimize for binary size
 debug = true      # Enable debug symbols, for profiling
-
-[profile.bench]
-codegen-units = 256
-lto = false
-opt-level = 3

DEVELOPMENT.md

@@ -132,29 +132,6 @@ The app writes logs into:
 1. `stdout` in development mode
 2. The Tauri [logs](https://tauri.app/v1/api/js/path/#platform-specific) directory
 
-One can get performance log when launching the application locally as follows:
-
-```bash
-GITBUTLER_PERFORMANCE_LOG=1 LOG_LEVEL=debug pnpm tauri dev
-```
-
-For more realistic performance logging, use local release builds with `--release`.
-
-```bash
-GITBUTLER_PERFORMANCE_LOG=1 LOG_LEVEL=debug pnpm tauri dev --release
-```
-
-Since release builds are configured for public releases, they are very slow to compile.
-Speed them up by sourcing the following file.
-
-```bash
-export CARGO_PROFILE_RELEASE_DEBUG=0
-export CARGO_PROFILE_RELEASE_INCREMENTAL=false
-export CARGO_PROFILE_RELEASE_LTO=false
-export CARGO_PROFILE_RELEASE_CODEGEN_UNITS=256
-export CARGO_PROFILE_RELEASE_OPT_LEVEL=2
-```
-
 ### Tokio
 
 We are also collecting tokio's runtime tracing information that could be viewed using [tokio-console](https://github.com/tokio-rs/console#tokio-console-prototypes):

crates/gitbutler-branch-actions/src/actions.rs

@@ -1,22 +1,8 @@
-use super::r#virtual as branch;
-use crate::branch::get_uncommited_files_raw;
-use crate::{
-    base::{
-        get_base_branch_data, set_base_branch, set_target_push_remote, update_base_branch,
-        BaseBranch,
-    },
-    branch::get_uncommited_files,
-    branch_manager::BranchManagerExt,
-    file::RemoteBranchFile,
-    remote::{get_branch_data, list_remote_branches, RemoteBranch, RemoteBranchData},
-    VirtualBranchesExt,
-};
 use anyhow::{Context, Result};
 use gitbutler_branch::{
     BranchCreateRequest, BranchId, BranchOwnershipClaims, BranchUpdateRequest, ChangeReference,
 };
 use gitbutler_command_context::CommandContext;
-use gitbutler_diff::DiffByPathMap;
 use gitbutler_operating_modes::assure_open_workspace_mode;
 use gitbutler_oplog::{
     entry::{OperationKind, SnapshotDetails},
@@ -27,6 +13,19 @@ use gitbutler_reference::{ReferenceName, Refname, RemoteRefname};
 use gitbutler_repo::{credentials::Helper, RepoActionsExt, RepositoryExt};
 use tracing::instrument;
 
+use super::r#virtual as branch;
+use crate::{
+    base::{
+        get_base_branch_data, set_base_branch, set_target_push_remote, update_base_branch,
+        BaseBranch,
+    },
+    branch::get_uncommited_files,
+    branch_manager::BranchManagerExt,
+    file::RemoteBranchFile,
+    remote::{get_branch_data, list_remote_branches, RemoteBranch, RemoteBranchData},
+    VirtualBranchesExt,
+};
+
 #[derive(Clone, Copy, Default)]
 pub struct VirtualBranchActions;
 
@@ -82,24 +81,6 @@ impl VirtualBranchActions {
             .map_err(Into::into)
     }
 
-    pub fn list_virtual_branches_cached(
-        &self,
-        project: &Project,
-        worktree_changes: Option<DiffByPathMap>,
-    ) -> Result<(Vec<branch::VirtualBranch>, Vec<gitbutler_diff::FileDiff>)> {
-        let ctx = open_with_verify(project)?;
-
-        assure_open_workspace_mode(&ctx)
-            .context("Listing virtual branches requires open workspace mode")?;
-
-        branch::list_virtual_branches_cached(
-            &ctx,
-            project.exclusive_worktree_access().write_permission(),
-            worktree_changes,
-        )
-        .map_err(Into::into)
-    }
-
     pub fn create_virtual_branch(
         &self,
         project: &Project,
@@ -588,16 +569,10 @@ impl VirtualBranchActions {
 
     pub fn get_uncommited_files(&self, project: &Project) -> Result<Vec<RemoteBranchFile>> {
         let context = CommandContext::open(project)?;
-        let guard = project.exclusive_worktree_access();
-        get_uncommited_files(&context, guard.read_permission())
-    }
 
-    /// Like [`get_uncommited_files()`], but returns a type that can be re-used with
-    /// [`crate::list_virtual_branches()`].
-    pub fn get_uncommited_files_reusable(&self, project: &Project) -> Result<DiffByPathMap> {
-        let context = CommandContext::open(project)?;
         let guard = project.exclusive_worktree_access();
-        get_uncommited_files_raw(&context, guard.read_permission())
+
+        get_uncommited_files(&context, guard.read_permission())
     }
 }
 

crates/gitbutler-branch-actions/src/branch.rs

@@ -5,11 +5,9 @@ use core::fmt;
 use gitbutler_branch::{
     Branch as GitButlerBranch, BranchId, BranchIdentity, ReferenceExtGix, Target,
 };
-use gitbutler_command_context::CommandContext;
-use gitbutler_diff::DiffByPathMap;
+use gitbutler_command_context::{CommandContext, GixRepositoryExt};
 use gitbutler_project::access::WorktreeReadPermission;
 use gitbutler_reference::normalize_branch_name;
-use gitbutler_repo::{GixRepositoryExt, RepositoryExt};
 use gitbutler_serde::BStringForFrontend;
 use gix::object::tree::diff::Action;
 use gix::prelude::ObjectIdExt;
@@ -24,21 +22,19 @@ use std::{
     vec,
 };
 
-pub(crate) fn get_uncommited_files_raw(
-    context: &CommandContext,
-    _permission: &WorktreeReadPermission,
-) -> Result<DiffByPathMap> {
-    let repository = context.repository();
-    let head_commit = repository.head_commit()?;
-    gitbutler_diff::workdir(repository, &head_commit.id())
-        .context("Failed to list uncommited files")
-}
-
 pub(crate) fn get_uncommited_files(
     context: &CommandContext,
     _permission: &WorktreeReadPermission,
 ) -> Result<Vec<RemoteBranchFile>> {
-    let files = get_uncommited_files_raw(context, _permission)?
+    let repository = context.repository();
+    let head_commit = repository
+        .head()
+        .context("Failed to get head")?
+        .peel_to_commit()
+        .context("Failed to get head commit")?;
+
+    let files = gitbutler_diff::workdir(repository, &head_commit.id())
+        .context("Failed to list uncommited files")?
         .into_iter()
         .map(|(path, file)| {
             let binary = file.hunks.iter().any(|h| h.binary);

crates/gitbutler-branch-actions/src/branch_manager/branch_creation.rs

@@ -454,7 +454,7 @@ impl BranchManager<'_> {
             vb_state.set_branch(branch.clone())?;
         }
 
-        let wd_tree = self.ctx.repository().create_wd_tree()?;
+        let wd_tree = self.ctx.repository().get_wd_tree()?;
 
         let branch_tree = repo
             .find_tree(branch.tree)

crates/gitbutler-branch-actions/src/integration.rs

@@ -12,22 +12,16 @@ use gitbutler_commit::commit_ext::CommitExt;
 use gitbutler_error::error::Marker;
 use gitbutler_project::access::WorktreeWritePermission;
 use gitbutler_repo::{LogUntil, RepoActionsExt, RepositoryExt};
-use tracing::instrument;
 
 use crate::{branch_manager::BranchManagerExt, conflicts, VirtualBranchesExt};
 
 const WORKSPACE_HEAD: &str = "Workspace Head";
 const GITBUTLER_INTEGRATION_COMMIT_TITLE: &str = "GitButler Integration Commit";
 
-/// Creates and returns a merge commit of all active branch heads.
-///
-/// This is the base against which we diff the working directory to understand
-/// what files have been modified.
-///
-/// This should be used to update the `gitbutler/workspace` ref with, which is usually
-/// done from [`update_gitbutler_integration()`], after any of its input changes.
-/// This is namely the conflicting state, or any head of the virtual branches.
-#[instrument(level = tracing::Level::DEBUG, skip(ctx))]
+// Creates and returns a merge commit of all active branch heads.
+//
+// This is the base against which we diff the working directory to understand
+// what files have been modified.
 pub(crate) fn get_workspace_head(ctx: &CommandContext) -> Result<git2::Oid> {
     let vb_state = ctx.project().virtual_branches();
     let target = vb_state

crates/gitbutler-branch-actions/src/status.rs

@@ -1,12 +1,5 @@
 use std::{collections::HashMap, path::PathBuf, vec};
 
-use crate::integration::get_workspace_head;
-use crate::{
-    conflicts::RepoConflictsExt,
-    file::{virtual_hunks_into_virtual_files, VirtualBranchFile},
-    hunk::{file_hunks_from_diffs, HunkLock, VirtualBranchHunk},
-    BranchManagerExt, VirtualBranchesExt,
-};
 use anyhow::{bail, Context, Result};
 use git2::Tree;
 use gitbutler_branch::{
@@ -17,7 +10,14 @@ use gitbutler_command_context::CommandContext;
 use gitbutler_diff::{diff_files_into_hunks, GitHunk, Hunk, HunkHash};
 use gitbutler_operating_modes::assure_open_workspace_mode;
 use gitbutler_project::access::WorktreeWritePermission;
-use tracing::instrument;
+
+use crate::{
+    conflicts::RepoConflictsExt,
+    file::{virtual_hunks_into_virtual_files, VirtualBranchFile},
+    hunk::{file_hunks_from_diffs, HunkLock, VirtualBranchHunk},
+    integration::get_workspace_head,
+    BranchManagerExt, VirtualBranchesExt,
+};
 
 /// Represents the uncommitted status of the applied virtual branches in the workspace.
 pub struct VirtualBranchesStatus {
@@ -27,38 +27,21 @@ pub struct VirtualBranchesStatus {
     pub skipped_files: Vec<gitbutler_diff::FileDiff>,
 }
 
-pub fn get_applied_status(
-    ctx: &CommandContext,
-    perm: Option<&mut WorktreeWritePermission>,
-) -> Result<VirtualBranchesStatus> {
-    get_applied_status_cached(ctx, perm, None)
-}
-
 /// Returns branches and their associated file changes, in addition to a list
 /// of skipped files.
-/// `worktree_changes` are all changed files against the current `HEAD^{tree}` and index
-/// against the current working tree directory, and it's used to avoid double-computing
-/// this expensive information.
 // TODO(kv): make this side effect free
-#[instrument(level = tracing::Level::DEBUG, skip(ctx, perm, worktree_changes))]
-pub fn get_applied_status_cached(
+pub fn get_applied_status(
     ctx: &CommandContext,
     perm: Option<&mut WorktreeWritePermission>,
-    worktree_changes: Option<gitbutler_diff::DiffByPathMap>,
 ) -> Result<VirtualBranchesStatus> {
     assure_open_workspace_mode(ctx).context("ng applied status requires open workspace mode")?;
+    let integration_commit = get_workspace_head(ctx)?;
     let mut virtual_branches = ctx
         .project()
         .virtual_branches()
         .list_branches_in_workspace()?;
-    let base_file_diffs = worktree_changes.map(Ok).unwrap_or_else(|| {
-        // TODO(ST): Ideally, we can avoid calling `get_workspace_head()` as everyone who modifies
-        //           any of its inputs will update the intragration commit right away.
-        //           It's for another day though - right now the integration commit may be slightly stale.
-        let integration_commit_id = get_workspace_head(ctx)?;
-        gitbutler_diff::workdir(ctx.repository(), &integration_commit_id.to_owned())
-            .context("failed to diff workdir")
-    })?;
+    let base_file_diffs = gitbutler_diff::workdir(ctx.repository(), &integration_commit.to_owned())
+        .context("failed to diff workdir")?;
 
     let mut skipped_files: Vec<gitbutler_diff::FileDiff> = Vec::new();
     for file_diff in base_file_diffs.values() {