cybercyst/jj
1
0
Fork 0
mirror of https://github.com/martinvonz/jj.git synced 2025-05-06 07:52:50 +00:00
Code Issues Packages Projects Releases Wiki Activity

copy-tracking: plumb CopyRecordMap through diff method

Browse Source
This commit is contained in:
Matt Kulukundis 2024-08-02 12:48:07 -04:00 committed by Matt Fowles Kulukundis
parent 6bae5eaf9d
commit 34b0f87584
12 changed files with 75 additions and 40 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
cli/src/commands/fix.rs
View File

@ -172,7 +172,8 @@ pub(crate) fn cmd_fix(
// Also fix any new paths that were changed in this commit. // Also fix any new paths that were changed in this commit.
let tree = commit.tree()?; let tree = commit.tree()?;
let parent_tree = commit.parent_tree(tx.repo())?; let parent_tree = commit.parent_tree(tx.repo())?;
let mut diff_stream = parent_tree.diff_stream(&tree, &matcher); let copy_records = Default::default();
let mut diff_stream = parent_tree.diff_stream(&tree, &matcher, &copy_records);
async { async {
while let Some(TreeDiffEntry { while let Some(TreeDiffEntry {
source: _, // TODO handle copy tracking source: _, // TODO handle copy tracking

7
cli/src/commit_templater.rs
View File

@ -19,7 +19,7 @@ use std::io;
use std::rc::Rc; use std::rc::Rc;
use itertools::Itertools as _; use itertools::Itertools as _;
use jj_lib::backend::{BackendResult, ChangeId, CommitId}; use jj_lib::backend::{BackendResult, ChangeId, CommitId, CopyRecords};
use jj_lib::commit::Commit; use jj_lib::commit::Commit;
use jj_lib::extensions_map::ExtensionsMap; use jj_lib::extensions_map::ExtensionsMap;
use jj_lib::fileset::{self, FilesetExpression}; use jj_lib::fileset::{self, FilesetExpression};
@ -1278,6 +1278,7 @@ pub struct TreeDiff {
from_tree: MergedTree, from_tree: MergedTree,
to_tree: MergedTree, to_tree: MergedTree,
matcher: Rc<dyn Matcher>, matcher: Rc<dyn Matcher>,
copy_records: CopyRecords,
} }
impl TreeDiff { impl TreeDiff {
@ -1290,11 +1291,13 @@ impl TreeDiff {
from_tree: commit.parent_tree(repo)?, from_tree: commit.parent_tree(repo)?,
to_tree: commit.tree()?, to_tree: commit.tree()?,
matcher, matcher,
copy_records: Default::default(),
}) })
} }
fn diff_stream(&self) -> TreeDiffStream<'_> { fn diff_stream(&self) -> TreeDiffStream<'_> {
self.from_tree.diff_stream(&self.to_tree, &*self.matcher) self.from_tree
.diff_stream(&self.to_tree, &*self.matcher, &self.copy_records)
} }
fn into_formatted<F, E>(self, show: F) -> TreeDiffFormatted<F> fn into_formatted<F, E>(self, show: F) -> TreeDiffFormatted<F>

26
cli/src/diff_util.rs
View File

@ -240,6 +240,7 @@ impl<'a> DiffRenderer<'a> {
} }
/// Generates diff between `from_tree` and `to_tree`. /// Generates diff between `from_tree` and `to_tree`.
#[allow(clippy::too_many_arguments)]
pub fn show_diff( pub fn show_diff(
&self, &self,
ui: &Ui, // TODO: remove Ui dependency if possible ui: &Ui, // TODO: remove Ui dependency if possible
@ -263,6 +264,7 @@ impl<'a> DiffRenderer<'a> {
}) })
} }
#[allow(clippy::too_many_arguments)]
fn show_diff_inner( fn show_diff_inner(
&self, &self,
ui: &Ui, ui: &Ui,
@ -278,33 +280,41 @@ impl<'a> DiffRenderer<'a> {
for format in &self.formats { for format in &self.formats {
match format { match format {
DiffFormat::Summary => { DiffFormat::Summary => {
let tree_diff = from_tree.diff_stream(to_tree, matcher); let no_copy_tracking = Default::default();
let tree_diff = from_tree.diff_stream(to_tree, matcher, &no_copy_tracking);
show_diff_summary(formatter, tree_diff, path_converter)?; show_diff_summary(formatter, tree_diff, path_converter)?;
} }
DiffFormat::Stat => { DiffFormat::Stat => {
let tree_diff = from_tree.diff_stream(to_tree, matcher); let no_copy_tracking = Default::default();
let tree_diff = from_tree.diff_stream(to_tree, matcher, &no_copy_tracking);
show_diff_stat(formatter, store, tree_diff, path_converter, width)?; show_diff_stat(formatter, store, tree_diff, path_converter, width)?;
} }
DiffFormat::Types => { DiffFormat::Types => {
let tree_diff = from_tree.diff_stream(to_tree, matcher); let no_copy_tracking = Default::default();
let tree_diff = from_tree.diff_stream(to_tree, matcher, &no_copy_tracking);
show_types(formatter, tree_diff, path_converter)?; show_types(formatter, tree_diff, path_converter)?;
} }
DiffFormat::NameOnly => { DiffFormat::NameOnly => {
let tree_diff = from_tree.diff_stream(to_tree, matcher); let no_copy_tracking = Default::default();
let tree_diff = from_tree.diff_stream(to_tree, matcher, &no_copy_tracking);
show_names(formatter, tree_diff, path_converter)?; show_names(formatter, tree_diff, path_converter)?;
} }
DiffFormat::Git { context } => { DiffFormat::Git { context } => {
let tree_diff = from_tree.diff_stream(to_tree, matcher); let no_copy_tracking = Default::default();
let tree_diff = from_tree.diff_stream(to_tree, matcher, &no_copy_tracking);
show_git_diff(formatter, store, tree_diff, *context)?; show_git_diff(formatter, store, tree_diff, *context)?;
} }
DiffFormat::ColorWords { context } => { DiffFormat::ColorWords { context } => {
let tree_diff = from_tree.diff_stream(to_tree, matcher); let no_copy_tracking = Default::default();
let tree_diff = from_tree.diff_stream(to_tree, matcher, &no_copy_tracking);
show_color_words_diff(formatter, store, tree_diff, path_converter, *context)?; show_color_words_diff(formatter, store, tree_diff, path_converter, *context)?;
} }
DiffFormat::Tool(tool) => { DiffFormat::Tool(tool) => {
match tool.diff_invocation_mode { match tool.diff_invocation_mode {
DiffToolMode::FileByFile => { DiffToolMode::FileByFile => {
let tree_diff = from_tree.diff_stream(to_tree, matcher); let no_copy_tracking = Default::default();
let tree_diff =
from_tree.diff_stream(to_tree, matcher, &no_copy_tracking);
show_file_by_file_diff( show_file_by_file_diff(
ui, ui,
formatter, formatter,
@ -1052,7 +1062,7 @@ pub fn show_git_diff(
{ {
let path_string = path.as_internal_file_string(); let path_string = path.as_internal_file_string();
let (left_value, right_value) = diff?; let (left_value, right_value) = diff?;
let left_part = git_digf_part(&path, left_value)?; let left_part = git_diff_part(&path, left_value)?;
let right_part = git_diff_part(&path, right_value)?; let right_part = git_diff_part(&path, right_value)?;
formatter.with_label("file_header", |formatter| { formatter.with_label("file_header", |formatter| {
writeln!(formatter, "diff --git a/{path_string} b/{path_string}")?; writeln!(formatter, "diff --git a/{path_string} b/{path_string}")?;

2
cli/src/merge_tools/builtin.rs
View File

@ -495,7 +495,7 @@ pub fn edit_diff_builtin(
) -> Result<MergedTreeId, BuiltinToolError> { ) -> Result<MergedTreeId, BuiltinToolError> {
let store = left_tree.store().clone(); let store = left_tree.store().clone();
let changed_files: Vec<_> = left_tree let changed_files: Vec<_> = left_tree
.diff_stream(right_tree, matcher) .diff_stream(right_tree, matcher, &Default::default())
.map( .map(
|TreeDiffEntry { |TreeDiffEntry {
source: _, // TODO handle copy tracking source: _, // TODO handle copy tracking

2
cli/src/merge_tools/diff_working_copies.rs
View File

@ -131,7 +131,7 @@ pub(crate) fn check_out_trees(
output_is: Option<DiffSide>, output_is: Option<DiffSide>,
) -> Result<DiffWorkingCopies, DiffCheckoutError> { ) -> Result<DiffWorkingCopies, DiffCheckoutError> {
let changed_files: Vec<_> = left_tree let changed_files: Vec<_> = left_tree
.diff_stream(right_tree, matcher) .diff_stream(right_tree, matcher, &Default::default())
.map(|TreeDiffEntry { target, .. }| target) .map(|TreeDiffEntry { target, .. }| target)
.collect() .collect()
.block_on(); .block_on();

6
lib/src/default_index/revset_engine.rs
View File

@ -1148,7 +1148,8 @@ fn has_diff_from_parent(
let from_tree = let from_tree =
rewrite::merge_commit_trees_no_resolve_without_repo(store, &index, &parents)?.resolve()?; rewrite::merge_commit_trees_no_resolve_without_repo(store, &index, &parents)?.resolve()?;
let to_tree = commit.tree()?; let to_tree = commit.tree()?;
let mut tree_diff = from_tree.diff_stream(&to_tree, matcher); let copy_records = Default::default();
let mut tree_diff = from_tree.diff_stream(&to_tree, matcher, &copy_records);
async { async {
match tree_diff.next().await { match tree_diff.next().await {
Some(TreeDiffEntry { value: Ok(_), .. }) => Ok(true), Some(TreeDiffEntry { value: Ok(_), .. }) => Ok(true),
@ -1168,11 +1169,12 @@ fn matches_diff_from_parent(
text_pattern: &StringPattern, text_pattern: &StringPattern,
files_matcher: &dyn Matcher, files_matcher: &dyn Matcher,
) -> BackendResult<bool> { ) -> BackendResult<bool> {
let copy_records = Default::default();
let parents: Vec<_> = commit.parents().try_collect()?; let parents: Vec<_> = commit.parents().try_collect()?;
let from_tree = let from_tree =
rewrite::merge_commit_trees_no_resolve_without_repo(store, &index, &parents)?.resolve()?; rewrite::merge_commit_trees_no_resolve_without_repo(store, &index, &parents)?.resolve()?;
let to_tree = commit.tree()?; let to_tree = commit.tree()?;
let tree_diff = from_tree.diff_stream(&to_tree, files_matcher); let tree_diff = from_tree.diff_stream(&to_tree, files_matcher, &copy_records);
// Conflicts are compared in materialized form. Alternatively, conflict // Conflicts are compared in materialized form. Alternatively, conflict
// pairs can be compared one by one. #4062 // pairs can be compared one by one. #4062
let mut diff_stream = materialized_diff_stream(store, tree_diff); let mut diff_stream = materialized_diff_stream(store, tree_diff);

6
lib/src/local_working_copy.rs
View File

@ -1340,6 +1340,7 @@ impl TreeState {
new_tree: &MergedTree, new_tree: &MergedTree,
matcher: &dyn Matcher, matcher: &dyn Matcher,
) -> Result<CheckoutStats, CheckoutError> { ) -> Result<CheckoutStats, CheckoutError> {
let copy_records = Default::default();
// TODO: maybe it's better not include the skipped counts in the "intended" // TODO: maybe it's better not include the skipped counts in the "intended"
// counts // counts
let mut stats = CheckoutStats { let mut stats = CheckoutStats {
@ -1352,7 +1353,7 @@ impl TreeState {
let mut deleted_files = HashSet::new(); let mut deleted_files = HashSet::new();
let mut diff_stream = Box::pin( let mut diff_stream = Box::pin(
old_tree old_tree
.diff_stream(new_tree, matcher) .diff_stream(new_tree, matcher, &copy_records)
.map( .map(
|TreeDiffEntry { |TreeDiffEntry {
source: _, // TODO handle copy tracking source: _, // TODO handle copy tracking
@ -1451,9 +1452,10 @@ impl TreeState {
})?; })?;
let matcher = self.sparse_matcher(); let matcher = self.sparse_matcher();
let copy_records = Default::default();
let mut changed_file_states = Vec::new(); let mut changed_file_states = Vec::new();
let mut deleted_files = HashSet::new(); let mut deleted_files = HashSet::new();
let mut diff_stream = old_tree.diff_stream(new_tree, matcher.as_ref()); let mut diff_stream = old_tree.diff_stream(new_tree, matcher.as_ref(), &copy_records);
while let Some(TreeDiffEntry { while let Some(TreeDiffEntry {
source: _, // TODO handle copy tracking source: _, // TODO handle copy tracking
target: path, target: path,

13
lib/src/merged_tree.rs
View File

@ -29,7 +29,7 @@ use futures::{Stream, TryStreamExt};
use itertools::{EitherOrBoth, Itertools}; use itertools::{EitherOrBoth, Itertools};
use crate::backend; use crate::backend;
use crate::backend::{BackendResult, MergedTreeId, TreeId, TreeValue}; use crate::backend::{BackendResult, CopyRecords, MergedTreeId, TreeId, TreeValue};
use crate::matchers::{EverythingMatcher, Matcher}; use crate::matchers::{EverythingMatcher, Matcher};
use crate::merge::{Merge, MergeBuilder, MergedTreeValue}; use crate::merge::{Merge, MergeBuilder, MergedTreeValue};
use crate::repo_path::{RepoPath, RepoPathBuf, RepoPathComponent}; use crate::repo_path::{RepoPath, RepoPathBuf, RepoPathComponent};
@ -283,6 +283,7 @@ impl MergedTree {
&self, &self,
other: &MergedTree, other: &MergedTree,
matcher: &'matcher dyn Matcher, matcher: &'matcher dyn Matcher,
copy_records: &'matcher CopyRecords,
) -> TreeDiffStream<'matcher> { ) -> TreeDiffStream<'matcher> {
let concurrency = self.store().concurrency(); let concurrency = self.store().concurrency();
if concurrency <= 1 { if concurrency <= 1 {
@ -290,12 +291,14 @@ impl MergedTree {
&self.trees, &self.trees,
&other.trees, &other.trees,
matcher, matcher,
copy_records,
))) )))
} else { } else {
Box::pin(TreeDiffStreamImpl::new( Box::pin(TreeDiffStreamImpl::new(
self.clone(), self.clone(),
other.clone(), other.clone(),
matcher, matcher,
copy_records,
concurrency, concurrency,
)) ))
} }
@ -627,7 +630,12 @@ enum TreeDiffItem {
impl<'matcher> TreeDiffIterator<'matcher> { impl<'matcher> TreeDiffIterator<'matcher> {
/// Creates a iterator over the differences between two trees. Generally /// Creates a iterator over the differences between two trees. Generally
/// prefer `MergedTree::diff()` of calling this directly. /// prefer `MergedTree::diff()` of calling this directly.
pub fn new(trees1: &Merge<Tree>, trees2: &Merge<Tree>, matcher: &'matcher dyn Matcher) -> Self { pub fn new(
trees1: &Merge<Tree>,
trees2: &Merge<Tree>,
matcher: &'matcher dyn Matcher,
_copy_records: &'matcher CopyRecords,
) -> Self {
assert!(Arc::ptr_eq(trees1.first().store(), trees2.first().store())); assert!(Arc::ptr_eq(trees1.first().store(), trees2.first().store()));
let root_dir = RepoPath::root(); let root_dir = RepoPath::root();
let mut stack = Vec::new(); let mut stack = Vec::new();
@ -857,6 +865,7 @@ impl<'matcher> TreeDiffStreamImpl<'matcher> {
tree1: MergedTree, tree1: MergedTree,
tree2: MergedTree, tree2: MergedTree,
matcher: &'matcher dyn Matcher, matcher: &'matcher dyn Matcher,
_copy_records: &'matcher CopyRecords,
max_concurrent_reads: usize, max_concurrent_reads: usize,
) -> Self { ) -> Self {
let mut stream = Self { let mut stream = Self {

3
lib/src/rewrite.rs
View File

@ -86,8 +86,9 @@ pub fn restore_tree(
// TODO: We should be able to not traverse deeper in the diff if the matcher // TODO: We should be able to not traverse deeper in the diff if the matcher
// matches an entire subtree. // matches an entire subtree.
let mut tree_builder = MergedTreeBuilder::new(destination.id().clone()); let mut tree_builder = MergedTreeBuilder::new(destination.id().clone());
let copy_records = Default::default();
async { async {
let mut diff_stream = source.diff_stream(destination, matcher); let mut diff_stream = source.diff_stream(destination, matcher, &copy_records);
while let Some(TreeDiffEntry { while let Some(TreeDiffEntry {
source: _, // TODO handle copy tracking source: _, // TODO handle copy tracking
target: repo_path, target: repo_path,

2
lib/tests/test_commit_builder.rs
View File

@ -26,7 +26,7 @@ use testutils::{assert_rebased_onto, create_tree, CommitGraphBuilder, TestRepo,
fn diff_paths(from_tree: &MergedTree, to_tree: &MergedTree) -> Vec<RepoPathBuf> { fn diff_paths(from_tree: &MergedTree, to_tree: &MergedTree) -> Vec<RepoPathBuf> {
from_tree from_tree
.diff_stream(to_tree, &EverythingMatcher) .diff_stream(to_tree, &EverythingMatcher, &Default::default())
.map(|diff| { .map(|diff| {
let _ = diff.value.unwrap(); let _ = diff.value.unwrap();
diff.target diff.target

4
lib/tests/test_local_working_copy_sparse.rs
View File

@ -197,7 +197,7 @@ fn test_sparse_commit() {
// tree. // tree.
let modified_tree = test_workspace.snapshot().unwrap(); let modified_tree = test_workspace.snapshot().unwrap();
let diff: Vec<_> = tree let diff: Vec<_> = tree
.diff_stream(&modified_tree, &EverythingMatcher) .diff_stream(&modified_tree, &EverythingMatcher, &Default::default())
.collect() .collect()
.block_on(); .block_on();
assert_eq!(diff.len(), 1); assert_eq!(diff.len(), 1);
@ -219,7 +219,7 @@ fn test_sparse_commit() {
// updated in the tree. // updated in the tree.
let modified_tree = test_workspace.snapshot().unwrap(); let modified_tree = test_workspace.snapshot().unwrap();
let diff: Vec<_> = tree let diff: Vec<_> = tree
.diff_stream(&modified_tree, &EverythingMatcher) .diff_stream(&modified_tree, &EverythingMatcher, &Default::default())
.collect() .collect()
.block_on(); .block_on();
assert_eq!(diff.len(), 2); assert_eq!(diff.len(), 2);

31
lib/tests/test_merged_tree.rs
View File

@ -40,12 +40,19 @@ fn diff_entry_tuple(diff: TreeDiffEntry) -> (RepoPathBuf, (MergedTreeValue, Merg
} }
fn diff_stream_equals_iter(tree1: &MergedTree, tree2: &MergedTree, matcher: &dyn Matcher) { fn diff_stream_equals_iter(tree1: &MergedTree, tree2: &MergedTree, matcher: &dyn Matcher) {
let iter_diff: Vec<_> = TreeDiffIterator::new(tree1.as_merge(), tree2.as_merge(), matcher) let copy_records = Default::default();
let iter_diff: Vec<_> =
TreeDiffIterator::new(tree1.as_merge(), tree2.as_merge(), matcher, &copy_records)
.map(diff_entry_tuple) .map(diff_entry_tuple)
.collect(); .collect();
let max_concurrent_reads = 10; let max_concurrent_reads = 10;
let stream_diff: Vec<_> = let stream_diff: Vec<_> = TreeDiffStreamImpl::new(
TreeDiffStreamImpl::new(tree1.clone(), tree2.clone(), matcher, max_concurrent_reads) tree1.clone(),
tree2.clone(),
matcher,
&copy_records,
max_concurrent_reads,
)
.map(diff_entry_tuple) .map(diff_entry_tuple)
.collect() .collect()
.block_on(); .block_on();
@ -752,7 +759,7 @@ fn test_diff_resolved() {
let after_merged = MergedTree::new(Merge::resolved(after.clone())); let after_merged = MergedTree::new(Merge::resolved(after.clone()));
let diff: Vec<_> = before_merged let diff: Vec<_> = before_merged
.diff_stream(&after_merged, &EverythingMatcher) .diff_stream(&after_merged, &EverythingMatcher, &Default::default())
.map(diff_entry_tuple) .map(diff_entry_tuple)
.collect() .collect()
.block_on(); .block_on();
@ -862,7 +869,7 @@ fn test_diff_conflicted() {
// Test the forwards diff // Test the forwards diff
let actual_diff: Vec<_> = left_merged let actual_diff: Vec<_> = left_merged
.diff_stream(&right_merged, &EverythingMatcher) .diff_stream(&right_merged, &EverythingMatcher, &Default::default())
.map(diff_entry_tuple) .map(diff_entry_tuple)
.collect() .collect()
.block_on(); .block_on();
@ -882,7 +889,7 @@ fn test_diff_conflicted() {
diff_stream_equals_iter(&left_merged, &right_merged, &EverythingMatcher); diff_stream_equals_iter(&left_merged, &right_merged, &EverythingMatcher);
// Test the reverse diff // Test the reverse diff
let actual_diff: Vec<_> = right_merged let actual_diff: Vec<_> = right_merged
.diff_stream(&left_merged, &EverythingMatcher) .diff_stream(&left_merged, &EverythingMatcher, &Default::default())
.map(diff_entry_tuple) .map(diff_entry_tuple)
.collect() .collect()
.block_on(); .block_on();
@ -1000,7 +1007,7 @@ fn test_diff_dir_file() {
// Test the forwards diff // Test the forwards diff
{ {
let actual_diff: Vec<_> = left_merged let actual_diff: Vec<_> = left_merged
.diff_stream(&right_merged, &EverythingMatcher) .diff_stream(&right_merged, &EverythingMatcher, &Default::default())
.map(diff_entry_tuple) .map(diff_entry_tuple)
.collect() .collect()
.block_on(); .block_on();
@ -1045,7 +1052,7 @@ fn test_diff_dir_file() {
// Test the reverse diff // Test the reverse diff
{ {
let actual_diff: Vec<_> = right_merged let actual_diff: Vec<_> = right_merged
.diff_stream(&left_merged, &EverythingMatcher) .diff_stream(&left_merged, &EverythingMatcher, &Default::default())
.map(diff_entry_tuple) .map(diff_entry_tuple)
.collect() .collect()
.block_on(); .block_on();
@ -1091,7 +1098,7 @@ fn test_diff_dir_file() {
{ {
let matcher = FilesMatcher::new([&path1]); let matcher = FilesMatcher::new([&path1]);
let actual_diff: Vec<_> = left_merged let actual_diff: Vec<_> = left_merged
.diff_stream(&right_merged, &matcher) .diff_stream(&right_merged, &matcher, &Default::default())
.map(diff_entry_tuple) .map(diff_entry_tuple)
.collect() .collect()
.block_on(); .block_on();
@ -1107,7 +1114,7 @@ fn test_diff_dir_file() {
{ {
let matcher = FilesMatcher::new([path1.join(file)]); let matcher = FilesMatcher::new([path1.join(file)]);
let actual_diff: Vec<_> = left_merged let actual_diff: Vec<_> = left_merged
.diff_stream(&right_merged, &matcher) .diff_stream(&right_merged, &matcher, &Default::default())
.map(diff_entry_tuple) .map(diff_entry_tuple)
.collect() .collect()
.block_on(); .block_on();
@ -1126,7 +1133,7 @@ fn test_diff_dir_file() {
{ {
let matcher = PrefixMatcher::new([&path1]); let matcher = PrefixMatcher::new([&path1]);
let actual_diff: Vec<_> = left_merged let actual_diff: Vec<_> = left_merged
.diff_stream(&right_merged, &matcher) .diff_stream(&right_merged, &matcher, &Default::default())
.map(diff_entry_tuple) .map(diff_entry_tuple)
.collect() .collect()
.block_on(); .block_on();
@ -1148,7 +1155,7 @@ fn test_diff_dir_file() {
{ {
let matcher = FilesMatcher::new([&path6]); let matcher = FilesMatcher::new([&path6]);
let actual_diff: Vec<_> = left_merged let actual_diff: Vec<_> = left_merged
.diff_stream(&right_merged, &matcher) .diff_stream(&right_merged, &matcher, &Default::default())
.map(diff_entry_tuple) .map(diff_entry_tuple)
.collect() .collect()
.block_on(); .block_on();