diff --git a/Cargo.lock b/Cargo.lock index 30dab906fb..374135cae2 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1668,6 +1668,7 @@ dependencies = [ "gix", "glob", "hex", + "indexmap", "insta", "itertools 0.11.0", "maplit", diff --git a/lib/Cargo.toml b/lib/Cargo.toml index 9f5d65a4e0..f83d80759f 100644 --- a/lib/Cargo.toml +++ b/lib/Cargo.toml @@ -33,6 +33,7 @@ git2 = { workspace = true } gix = { workspace = true } glob = { workspace = true } hex = { workspace = true } +indexmap = {workspace = true} itertools = { workspace = true } maplit = { workspace = true } once_cell = { workspace = true } diff --git a/lib/src/rewrite.rs b/lib/src/rewrite.rs index af9e05c019..a78bddf6c6 100644 --- a/lib/src/rewrite.rs +++ b/lib/src/rewrite.rs @@ -18,6 +18,7 @@ use std::collections::{HashMap, HashSet}; use std::sync::Arc; use futures::StreamExt; +use indexmap::IndexSet; use itertools::Itertools; use pollster::FutureExt; use tracing::instrument; @@ -379,34 +380,45 @@ impl<'settings, 'repo> DescendantRebaser<'settings, 'repo> { &self.rebased } + /// Panics if `parent_mapping` contains cycles fn new_parents(&self, old_ids: &[CommitId]) -> Vec { - // This should be a set, but performance of a vec is much better since we expect - // 99% of commits to have <= 2 parents. - let mut new_ids = vec![]; - let mut add_parent = |id: &CommitId| { - // This can trigger if we abandon an empty commit, as both the empty commit and - // its parent are succeeded by the same commit. - if !new_ids.contains(id) { - new_ids.push(id.clone()); - } - }; - for old_id in old_ids { - if let Some(new_parent_ids) = self.parent_mapping.get(old_id) { - for new_parent_id in new_parent_ids { - // The new parent may itself have been rebased earlier in the process - if let Some(newer_parent_id) = self.rebased.get(new_parent_id) { - add_parent(newer_parent_id); - } else { - add_parent(new_parent_id); + let mut new_ids: Vec = old_ids.into(); + let mut iterations = 0; + loop { + let mut made_replacements = false; + // TODO(ilyagr): (Maybe?) optimize common case of replacements all + // being singletons + let previousy_new_ids = new_ids.split_off(0); + for id in previousy_new_ids.into_iter() { + match self.parent_mapping.get(&id) { + None => new_ids.push(id), + Some(replacements) => { + made_replacements = true; + assert!(!replacements.is_empty()); + new_ids.extend(replacements.iter().cloned()) } - } - } else if let Some(new_parent_id) = self.rebased.get(old_id) { - add_parent(new_parent_id); - } else { - add_parent(old_id); - }; + }; + } + if !made_replacements { + break; + } + iterations += 1; + assert!( + iterations <= self.parent_mapping.len(), + "cycle detected in the parent mapping" + ); + } + match new_ids.as_slice() { + // The first two cases are an optimization for the common case of commits with <=2 + // parents + [_singleton] => new_ids, + [a, b] if a != b => new_ids, + _ => { + // De-duplicate ids while preserving the order + let new_ids_set: IndexSet = new_ids.into_iter().collect(); + new_ids_set.into_iter().collect() + } } - new_ids } fn ref_target_update(old_id: CommitId, new_ids: Vec) -> (RefTarget, RefTarget) { @@ -540,8 +552,18 @@ impl<'settings, 'repo> DescendantRebaser<'settings, 'repo> { &new_parents, &self.options, )?; - self.rebased - .insert(old_commit_id.clone(), new_commit.id().clone()); + assert_eq!( + self.rebased + .insert(old_commit_id.clone(), new_commit.id().clone()), + None, + "Trying to rebase the same commit in two different ways", + ); + assert_eq!( + self.parent_mapping + .insert(old_commit_id.clone(), vec![new_commit.id().clone()]), + None, + "Trying to rebase the same commit in two different ways", + ); self.update_references(old_commit_id, vec![new_commit.id().clone()], true)?; return Ok(Some(RebasedDescendant { old_commit, diff --git a/lib/tests/test_rewrite.rs b/lib/tests/test_rewrite.rs index bbd6718714..d4c362babf 100644 --- a/lib/tests/test_rewrite.rs +++ b/lib/tests/test_rewrite.rs @@ -647,13 +647,14 @@ fn test_rebase_descendants_multiple_sideways() { } #[test] +#[should_panic(expected = "cycle detected")] fn test_rebase_descendants_multiple_swap() { let settings = testutils::user_settings(); let test_repo = TestRepo::init(); let repo = &test_repo.repo; // Commit B was replaced by commit D. Commit D was replaced by commit B. - // Commit C and commit E should swap places. + // This results in an infinite loop and a panic // // C E // B D @@ -663,9 +664,9 @@ fn test_rebase_descendants_multiple_swap() { let mut graph_builder = CommitGraphBuilder::new(&settings, tx.mut_repo()); let commit_a = graph_builder.initial_commit(); let commit_b = graph_builder.commit_with_parents(&[&commit_a]); - let commit_c = graph_builder.commit_with_parents(&[&commit_b]); + let _commit_c = graph_builder.commit_with_parents(&[&commit_b]); let commit_d = graph_builder.commit_with_parents(&[&commit_a]); - let commit_e = graph_builder.commit_with_parents(&[&commit_d]); + let _commit_e = graph_builder.commit_with_parents(&[&commit_d]); let mut rebaser = DescendantRebaser::new( &settings, @@ -676,18 +677,7 @@ fn test_rebase_descendants_multiple_swap() { }, hashset! {}, ); - let new_commit_c = assert_rebased(rebaser.rebase_next().unwrap(), &commit_c, &[&commit_d]); - let new_commit_e = assert_rebased(rebaser.rebase_next().unwrap(), &commit_e, &[&commit_b]); - assert!(rebaser.rebase_next().unwrap().is_none()); - assert_eq!(rebaser.rebased().len(), 2); - - assert_eq!( - *tx.mut_repo().view().heads(), - hashset! { - new_commit_c.id().clone(), - new_commit_e.id().clone() - } - ); + let _ = rebaser.rebase_next(); // Panics because of the cycle } #[test]