Make new safe_checkout available behind the v3 feature toggle.

This also makes the `v3` toggle re-usable, and it can mean many things
as we make progress, changing scope over time.

Author: Byron

apps/desktop/src/lib/config/appSettingsV2.ts

@@ -158,6 +158,8 @@ export type TelemetrySettings = {
 };
 
 export type FeatureFlags = {
+	/** Enable everything next-gen */
+	v3: boolean;
 	/** Enable the usage of the V3 workspace API */
 	ws3: boolean;
 	/** Enable the usage of GitButler Acitions. */

apps/desktop/src/routes/+layout.svelte

@@ -124,6 +124,10 @@
 		'w s 3': () => {
 			settingsService.updateFeatureFlags({ ws3: !$settingsStore?.featureFlags.ws3 });
 		},
+		// Toggle next-gen (v3)
+		'v 3': () => {
+			settingsService.updateFeatureFlags({ v3: !$settingsStore?.featureFlags.v3 });
+		},
 		// Show commit graph visualization
 		'd o t': async () => {
 			const projectId = page.params.projectId;

crates/but-settings/assets/defaults.jsonc

@@ -18,7 +18,7 @@
 		"oauthClientId": "cd51880daa675d9e6452"
 	},
 	"featureFlags": {
-		// Enables the v3 design, as well as the purgatory mode (no uncommitted diff ownership assignments).
+		// Enables the v3 safe checkout, apply and unapply.
 		"v3": false,
 		/// Enable the usage of V3 workspace APIs.
 		"ws3": false,

crates/but-settings/src/api.rs

@@ -15,6 +15,7 @@ pub struct TelemetryUpdate {
 #[serde(rename_all = "camelCase")]
 /// Update request for [`crate::app_settings::FeatureFlags`].
 pub struct FeatureFlagsUpdate {
+    pub v3: Option<bool>,
     pub ws3: Option<bool>,
     pub actions: Option<bool>,
     pub butbot: Option<bool>,
@@ -65,6 +66,7 @@ impl AppSettingsWithDiskSync {
     pub fn update_feature_flags(
         &self,
         FeatureFlagsUpdate {
+            v3,
             ws3,
             actions,
             butbot,
@@ -73,6 +75,9 @@ impl AppSettingsWithDiskSync {
         }: FeatureFlagsUpdate,
     ) -> Result<()> {
         let mut settings = self.get_mut_enforce_save()?;
+        if let Some(v3) = v3 {
+            settings.feature_flags.v3 = v3;
+        }
         if let Some(ws3) = ws3 {
             settings.feature_flags.ws3 = ws3;
         }

crates/but-settings/src/app_settings.rs

@@ -26,6 +26,11 @@ pub struct FeatureFlags {
     /// Enable the usage of V3 workspace APIs.
     #[serde(default = "default_true")]
     pub ws3: bool,
+    /// Turn on the set of v3 functions currently being roled out:
+    /// - safe checkout
+    /// - apply
+    /// - unapply
+    pub v3: bool,
     /// Enable undo/redo support.
     ///
     /// ### Progression for implementation

crates/but-testing/src/command/mod.rs

@@ -334,6 +334,7 @@ pub mod stacks {
         let app_settings = AppSettings {
             feature_flags: but_settings::app_settings::FeatureFlags {
                 ws3,
+                v3: false,
                 undo: false,
                 actions: false,
                 butbot: false,

crates/but-workspace/src/branch/checkout/function.rs

@@ -7,6 +7,7 @@ use gix::objs::TreeRefIter;
 use gix::prelude::ObjectIdExt as _;
 use gix::refs::Target;
 use gix::refs::transaction::{Change, LogChange, PreviousValue, RefEdit, RefLog};
+use tracing::instrument;
 
 /// Given the `current_head_id^{tree}` for the tree that matches what `HEAD` points to, perform all file operations necessary
 /// to turn the *worktree* of `repo` into `new_head_id^{tree}`. Note that the current *worktree* is assumed to be at the state of
@@ -15,7 +16,7 @@ use gix::refs::transaction::{Change, LogChange, PreviousValue, RefEdit, RefLog};
 /// Note that we don't care if the worktree actually matches the `new_head_id^{tree}`, we only care about the operations from
 /// `current_head_id^{tree}` to be performed, and if there are none, we will do nothing.
 ///
-/// If `new_head_id` is a commit, we will also set `HEAD` (or the ref it points to if symbolic) to the `new_head_id`.
+/// If `new_head_id` is a *commit*, we will also set `HEAD` (or the ref it points to if symbolic) to the `new_head_id`.
 /// We will also update the `.git/index` to match the `new_head_id^{tree}`.
 /// Note that the value for [`UncommitedWorktreeChanges`] is critical to determine what happens if a change would be overwritten.
 ///
@@ -27,6 +28,7 @@ use gix::refs::transaction::{Change, LogChange, PreviousValue, RefEdit, RefLog};
 /// To keep it simpler, we don't do rename tracking, so deletions and additions are always treated separately.
 /// If this changes, then the source sid of a rename could also cause conflicts, maybe? It's a bit unclear what it would mean
 /// in practice, but I guess that we bring deleted files back instead of conflicting.
+#[instrument(skip(repo), err(Debug))]
 pub fn safe_checkout(
     current_head_id: gix::ObjectId,
     new_head_id: gix::ObjectId,

crates/but-workspace/src/branch/checkout/mod.rs

@@ -8,6 +8,7 @@ pub enum UncommitedWorktreeChanges {
     /// Place the files that would be altered, AND at least one conflicts when brought back, into a snapshot based
     /// on the current `HEAD`, and overwrite them.
     /// Note that uncommitted changes that aren't affected will just be left as is.
+    // TODO: Add a ref-name with which to associate the snapshot commit for safekeeping, but needs UI support.
     KeepConflictingInSnapshotAndOverwrite,
 }
 

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

@@ -7,10 +7,11 @@ use crate::{
     VirtualBranchesExt,
 };
 use anyhow::{anyhow, Context, Result};
+use but_workspace::branch::checkout::UncommitedWorktreeChanges;
 use gitbutler_branch::GITBUTLER_WORKSPACE_REFERENCE;
 use gitbutler_command_context::CommandContext;
 use gitbutler_error::error::Marker;
-use gitbutler_oxidize::ObjectIdExt;
+use gitbutler_oxidize::{ObjectIdExt, OidExt};
 use gitbutler_project::FetchResult;
 use gitbutler_reference::{Refname, RemoteRefname};
 use gitbutler_repo::{
@@ -53,24 +54,40 @@ pub fn get_base_branch_data(ctx: &CommandContext) -> Result<BaseBranch> {
     Ok(base)
 }
 
+#[instrument(skip(ctx), err(Debug))]
 fn go_back_to_integration(ctx: &CommandContext, default_target: &Target) -> Result<BaseBranch> {
     let gix_repo = ctx.gix_repo_for_merging()?;
-    let (mut outcome, conflict_kind) =
-        but_workspace::merge_worktree_with_workspace(ctx, &gix_repo)?;
-
-    if outcome.has_unresolved_conflicts(conflict_kind) {
-        return Err(anyhow!("Conflicts while going back to gitbutler/workspace"))
-            .context(Marker::ProjectConflict);
-    }
+    if ctx.app_settings().feature_flags.v3 {
+        let workspace_commit_to_checkout = but_workspace::head(ctx)?;
+        let tree_to_checkout_to_avoid_ref_update = gix_repo
+            .find_commit(workspace_commit_to_checkout.to_gix())?
+            .tree_id()?;
+        but_workspace::branch::safe_checkout(
+            gix_repo.head_id()?.detach(),
+            tree_to_checkout_to_avoid_ref_update.detach(),
+            &gix_repo,
+            but_workspace::branch::checkout::Options {
+                uncommitted_changes: UncommitedWorktreeChanges::KeepAndAbortOnConflict,
+            },
+        )?;
+    } else {
+        let (mut outcome, conflict_kind) =
+            but_workspace::merge_worktree_with_workspace(ctx, &gix_repo)?;
+
+        if outcome.has_unresolved_conflicts(conflict_kind) {
+            return Err(anyhow!("Conflicts while going back to gitbutler/workspace"))
+                .context(Marker::ProjectConflict);
+        }
 
-    let final_tree_id = outcome.tree.write()?.detach();
+        let final_tree_id = outcome.tree.write()?.detach();
 
-    let repo = ctx.repo();
-    let final_tree = repo.find_tree(final_tree_id.to_git2())?;
-    repo.checkout_tree_builder(&final_tree)
-        .force()
-        .checkout()
-        .context("failed to checkout tree")?;
+        let repo = ctx.repo();
+        let final_tree = repo.find_tree(final_tree_id.to_git2())?;
+        repo.checkout_tree_builder(&final_tree)
+            .force()
+            .checkout()
+            .context("failed to checkout tree")?;
+    }
 
     let base = target_to_base_branch(ctx, default_target)?;
     let vb_state = VirtualBranchesHandle::new(ctx.project().gb_dir());