thanks clippy

Author: Byron

crates/but-graph/src/init/mod.rs

@@ -357,10 +357,7 @@ impl Graph {
             let target = ws_meta.target_ref.as_ref().and_then(|trn| {
                 let tid = try_refname_to_id(repo, trn.as_ref())
                     .map_err(|err| {
-                        tracing::warn!(
-                            "Ignoring non-existing target branch {trn}: {err}",
-                            trn = trn.as_bstr()
-                        );
+                        tracing::warn!("Ignoring non-existing target branch {trn}: {err}");
                         err
                     })
                     .ok()??;

crates/but-graph/src/init/walk.rs

@@ -624,15 +624,13 @@ pub fn obtain_workspace_infos<T: RefMetadata>(
     for (rn, data) in workspaces {
         if rn.category() != Some(Category::LocalBranch) {
             tracing::warn!(
-                "Skipped workspace at ref {} as workspaces can only ever be on normal branches",
-                rn.as_bstr()
+                "Skipped workspace at ref {rn} as workspaces can only ever be on normal branches",
             );
             continue;
         }
         if target_refs.contains(&rn) {
             tracing::warn!(
-                "Skipped workspace at ref {} as it was also a target ref for another workspace (or for itself)",
-                rn.as_bstr()
+                "Skipped workspace at ref {rn} as it was also a target ref for another workspace (or for itself)",
             );
             continue;
         }
@@ -642,16 +640,13 @@ pub fn obtain_workspace_infos<T: RefMetadata>(
             .filter(|trn| trn.category() != Some(Category::RemoteBranch))
         {
             tracing::warn!(
-                "Skipped workspace at ref {} as its target reference {target} was not a remote tracking branch",
-                rn.as_bstr(),
-                target = invalid_target_ref.as_bstr(),
+                "Skipped workspace at ref {rn} as its target reference {invalid_target_ref} was not a remote tracking branch",
             );
             continue;
         }
         let Some(ws_tip) = try_refname_to_id(repo, rn.as_ref())? else {
             tracing::warn!(
-                "Ignoring stale workspace ref '{ws_ref}', which didn't exist in Git but still had workspace data",
-                ws_ref = rn.as_bstr()
+                "Ignoring stale workspace ref '{rn}', which didn't exist in Git but still had workspace data",
             );
             continue;
         };

crates/but-graph/src/projection/workspace.rs

@@ -1060,8 +1060,7 @@ impl Workspace<'_> {
             }
             if !found_segment {
                 tracing::error!(
-                    "BUG: Couldn't find local segment with remote tracking ref '{rn}' - remote commits for it seem to be missing",
-                    rn = remote_tracking_ref_name.as_bstr()
+                    "BUG: Couldn't find local segment with remote tracking ref '{remote_tracking_ref_name}' - remote commits for it seem to be missing",
                 );
             }
         }

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

@@ -208,11 +208,7 @@ impl std::fmt::Debug for Outcome {
                     Some(edits) => edits
                         .last()
                         .map(|edit| {
-                            format!(
-                                "Update {} to {:?}",
-                                edit.name.as_bstr(),
-                                edit.change.new_value()
-                            )
+                            format!("Update {} to {:?}", edit.name, edit.change.new_value())
                         })
                         .unwrap_or_default(),
                 },

crates/but-workspace/src/branch_details.rs

@@ -168,7 +168,7 @@ pub fn branch_details_v3(
             .last()
             .map(|id| id.detach())
             .unwrap_or_else(|| {
-            tracing::warn!("No merge-base found between {name} and the integration branch {integration_branch_name}", name = name.as_bstr());
+            tracing::warn!("No merge-base found between {name} and the integration branch {integration_branch_name}");
                 // default to the tip just like the code previously did, resulting in no information
                 // TODO: we should probably indicate that there is no merge-base instead of just glossing over it.
                 branch_id.detach()

crates/but-workspace/src/ui/ref_info.rs

@@ -46,16 +46,10 @@ impl RemoteTrackingReference {
         remote_names: &gix::remote::Names,
     ) -> anyhow::Result<Self> {
         let (category, short_name) = ref_name.category_and_short_name().with_context(|| {
-            format!(
-                "Failed to categorize presume remote reference '{}'",
-                ref_name.as_bstr()
-            )
+            format!("Failed to categorize presume remote reference '{ref_name}'")
         })?;
         if category != Category::RemoteBranch {
-            bail!(
-                "Expected '{}' to be a remote tracking branch, but was {category:?}",
-                ref_name.as_bstr()
-            );
+            bail!("Expected '{ref_name}' to be a remote tracking branch, but was {category:?}");
         }
         let (longest_remote, short_name) = remote_names
             .iter()
@@ -76,10 +70,7 @@ impl RemoteTrackingReference {
                 "Failed to find remote branch's corresponding remote"
             ))
             .with_context(|| {
-                format!(
-                    "Remote reference '{}' couldn't be matched with any known remote",
-                    ref_name.as_bstr()
-                )
+                format!("Remote reference '{ref_name}' couldn't be matched with any known remote")
             })?;
 
         Ok(RemoteTrackingReference {

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

@@ -323,9 +323,9 @@ fn branch_group_to_branch(
     let head_commit = if let Some(vbranch) = virtual_branch {
         Some(vbranch.head_oid(repo)?)
     } else if let Some(mut branch) = local_branches.into_iter().next() {
-        branch.peel_to_id_in_place_packed(packed).ok()
+        branch.peel_to_id_packed(packed).ok()
     } else if let Some(mut branch) = remote_branches.into_iter().next() {
-        branch.peel_to_id_in_place_packed(packed).ok()
+        branch.peel_to_id_packed(packed).ok()
     } else {
         None
     }