From b593e552b8c80a4fe9452d4ca473e4ce7f64f9ae Mon Sep 17 00:00:00 2001 From: Martin von Zweigbergk Date: Wed, 9 Jun 2021 13:57:48 -0700 Subject: [PATCH] cleanup: remove some Vec<_> annotations, mostly by using collect_vec() --- Cargo.lock | 17 +++++++++-- Cargo.toml | 1 + lib/Cargo.toml | 1 + lib/src/dag_walk.rs | 7 ++--- lib/src/evolution.rs | 20 +++++++------ lib/src/git.rs | 3 +- lib/src/git_store.rs | 11 +++---- lib/src/gitignore.rs | 3 +- lib/src/index.rs | 29 +++++++++--------- lib/src/index_store.rs | 3 +- lib/src/op_heads_store.rs | 5 ++-- lib/src/repo_path.rs | 6 ++-- lib/src/revset.rs | 39 +++++++++++++------------ lib/src/rewrite.rs | 11 +++++-- lib/src/testutils.rs | 6 +++- lib/tests/test_evolution.rs | 3 +- lib/tests/test_merge_trees.rs | 9 +++--- lib/tests/test_revset_graph_iterator.rs | 25 ++++++++-------- lib/tests/test_working_copy.rs | 9 +++--- src/commands.rs | 9 +++--- src/templater.rs | 13 +++++---- 21 files changed, 136 insertions(+), 94 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 843b8a63e..d83607d5a 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -241,7 +241,7 @@ dependencies = [ "clap", "criterion-plot", "csv", - "itertools", + "itertools 0.9.0", "lazy_static", "num-traits 0.2.12", "oorandom", @@ -263,7 +263,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e022feadec601fba1649cfa83586381a4ad31c6bf3a9ab7d408118b05dd9889d" dependencies = [ "cast", - "itertools", + "itertools 0.9.0", ] [[package]] @@ -516,6 +516,15 @@ dependencies = [ "either", ] +[[package]] +name = "itertools" +version = "0.10.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "69ddb889f9d0d08a67338271fa9b62996bc788c7796a5c18cf057420aaed5eaf" +dependencies = [ + "either", +] + [[package]] name = "itoa" version = "0.4.6" @@ -554,6 +563,7 @@ dependencies = [ "git2", "hex", "indoc", + "itertools 0.10.1", "jujutsu-lib", "pest", "pest_derive", @@ -582,6 +592,7 @@ dependencies = [ "dirs", "git2", "hex", + "itertools 0.10.1", "maplit", "num_cpus", "pest", @@ -1596,6 +1607,6 @@ checksum = "ec24a9273d24437afb8e71b16f3d9a5d569193cccdb7896213b59f552f387674" dependencies = [ "cc", "glob", - "itertools", + "itertools 0.9.0", "libc", ] diff --git a/Cargo.toml b/Cargo.toml index 0f105d475..6c4579230 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -30,6 +30,7 @@ dirs = "3.0.1" git2 = "0.13.14" hex = "0.4.2" indoc = "1.0.3" +itertools = "0.10.1" jujutsu-lib = { version = "=0.2.0", path = "lib"} pest = "2.1.3" pest_derive = "2.1.0" diff --git a/lib/Cargo.toml b/lib/Cargo.toml index 07ce4cb78..2d70f8d57 100644 --- a/lib/Cargo.toml +++ b/lib/Cargo.toml @@ -25,6 +25,7 @@ config = "0.10.1" dirs = "3.0.1" git2 = "0.13.14" hex = "0.4.2" +itertools = "0.10.1" maplit = "1.0.2" pest = "2.1.3" pest_derive = "2.1.0" diff --git a/lib/src/dag_walk.rs b/lib/src/dag_walk.rs index 930aebdf3..25e2ca33d 100644 --- a/lib/src/dag_walk.rs +++ b/lib/src/dag_walk.rs @@ -83,7 +83,7 @@ where let mut emitted = HashSet::new(); let mut result = vec![]; - let mut start_nodes: Vec<_> = start.into_iter().collect(); + let mut start_nodes: Vec = start.into_iter().collect(); start_nodes.reverse(); for start_node in start_nodes { @@ -384,14 +384,13 @@ mod tests { 'e' => vec!['b'], 'F' => vec!['C', 'e'], }; - let expected: HashSet = vec!['D', 'F'].into_iter().collect(); let actual = heads( vec!['A', 'C', 'D', 'F'], &|node| neighbors[node].clone(), &|node| *node, ); - assert_eq!(actual, expected); + assert_eq!(actual, hashset!['D', 'F']); // Check with a different order in the start set let actual = heads( @@ -399,6 +398,6 @@ mod tests { &|node| neighbors[node].clone(), &|node| *node, ); - assert_eq!(actual, expected); + assert_eq!(actual, hashset!['D', 'F']); } } diff --git a/lib/src/evolution.rs b/lib/src/evolution.rs index 82a6d2434..377cc5f93 100644 --- a/lib/src/evolution.rs +++ b/lib/src/evolution.rs @@ -15,6 +15,8 @@ use std::collections::{HashMap, HashSet}; use std::sync::Arc; +use itertools::Itertools; + use crate::commit::Commit; use crate::commit_builder::CommitBuilder; use crate::dag_walk::{bfs, closest_common_node, leaves}; @@ -49,7 +51,7 @@ impl State { let view = repo.view(); let index = repo.index(); let mut state = State::default(); - let head_ids: Vec<_> = view.heads().iter().cloned().collect(); + let head_ids = view.heads().iter().cloned().collect_vec(); let mut change_to_commits = HashMap::new(); for head_id in &head_ids { state.children.insert(head_id.clone(), HashSet::new()); @@ -95,7 +97,7 @@ impl State { .insert(change_id, non_obsoletes); } // Find orphans by walking to the children of obsolete commits - let mut work: Vec = state.obsolete_commits.iter().cloned().collect(); + let mut work = state.obsolete_commits.iter().cloned().collect_vec(); work.extend(state.pruned_commits.iter().cloned()); while !work.is_empty() { let commit_id = work.pop().unwrap(); @@ -313,11 +315,11 @@ impl State { } // Filter out candidates that are ancestors of other candidates. - let all_candidates: Vec = repo + let all_candidates = repo .index() .heads(all_candidates.iter()) .into_iter() - .collect(); + .collect_vec(); for candidate in all_candidates { // TODO: Make this not recursive @@ -507,14 +509,14 @@ pub struct DivergenceResolver<'settings> { impl<'settings> DivergenceResolver<'settings> { pub fn new(user_settings: &'settings UserSettings, mut_repo: &MutableRepo) -> Self { // TODO: Put them in some defined order - let divergent_changes: Vec<_> = mut_repo + let divergent_changes = mut_repo .evolution() .state .non_obsoletes_by_changeid .values() .filter(|non_obsoletes| non_obsoletes.len() > 1) .cloned() - .collect(); + .collect_vec(); DivergenceResolver { user_settings, remaining_changes: divergent_changes, @@ -552,12 +554,12 @@ pub struct OrphanResolver<'settings> { impl<'settings> OrphanResolver<'settings> { pub fn new(user_settings: &'settings UserSettings, mut_repo: &MutableRepo) -> Self { - let mut orphans_topo_order: Vec<_> = mut_repo + let mut orphans_topo_order = mut_repo .index() .topo_order(mut_repo.evolution().state.orphan_commits.iter()) .iter() .map(|entry| entry.position()) - .collect(); + .collect_vec(); // Reverse so we can pop then efficiently later orphans_topo_order.reverse(); OrphanResolver { @@ -610,7 +612,7 @@ fn evolve_divergent_change( commits: &HashSet, ) -> DivergenceResolution { // Resolve divergence pair-wise, starting with the two oldest commits. - let mut commits: Vec = commits.iter().cloned().collect(); + let mut commits = commits.iter().cloned().collect_vec(); commits.sort_by(|a: &Commit, b: &Commit| a.committer().timestamp.cmp(&b.committer().timestamp)); commits.reverse(); diff --git a/lib/src/git.rs b/lib/src/git.rs index 2a2a31653..572543a2b 100644 --- a/lib/src/git.rs +++ b/lib/src/git.rs @@ -12,6 +12,7 @@ // See the License for the specific language governing permissions and // limitations under the License. +use itertools::Itertools; use thiserror::Error; use crate::commit::Commit; @@ -31,7 +32,7 @@ pub fn import_refs( ) -> Result<(), GitImportError> { let store = mut_repo.store().clone(); let git_refs = git_repo.references()?; - let existing_git_refs: Vec<_> = mut_repo.view().git_refs().keys().cloned().collect(); + let existing_git_refs = mut_repo.view().git_refs().keys().cloned().collect_vec(); // TODO: Store the id of the previous import and read it back here, so we can // merge the views instead of overwriting. for existing_git_ref in existing_git_refs { diff --git a/lib/src/git_store.rs b/lib/src/git_store.rs index 8a90eb67d..8b9a23c54 100644 --- a/lib/src/git_store.rs +++ b/lib/src/git_store.rs @@ -21,6 +21,7 @@ use std::time::Duration; use backoff::{ExponentialBackoff, Operation}; use git2::Oid; +use itertools::Itertools; use protobuf::Message; use uuid::Uuid; @@ -333,10 +334,10 @@ impl Store for GitStore { .map(|b| b.reverse_bits()) .collect(), ); - let parents: Vec<_> = commit + let parents = commit .parent_ids() .map(|oid| CommitId(oid.as_bytes().to_vec())) - .collect(); + .collect_vec(); let tree_id = TreeId(commit.tree_id().as_bytes().to_vec()); let description = commit.message().unwrap_or("").to_owned(); let author = signature_from_git(commit.author()); @@ -379,7 +380,7 @@ impl Store for GitStore { locked_repo.find_commit(Oid::from_bytes(parent_id.0.as_slice())?)?; parents.push(parent_git_commit); } - let parent_refs: Vec<_> = parents.iter().collect(); + let parent_refs = parents.iter().collect_vec(); let git_id = locked_repo.commit( Some(&create_no_gc_ref()), &author, @@ -642,11 +643,11 @@ mod tests { is_pruned: false, }; let commit_id = store.write_commit(&commit).unwrap(); - let git_refs: Vec<_> = git_repo + let git_refs = git_repo .references_glob("refs/jj/keep/*") .unwrap() .map(|git_ref| git_ref.unwrap().target().unwrap()) - .collect(); + .collect_vec(); assert_eq!(git_refs, vec![Oid::from_bytes(&commit_id.0).unwrap()]); } diff --git a/lib/src/gitignore.rs b/lib/src/gitignore.rs index f7da4aba5..592d60b84 100644 --- a/lib/src/gitignore.rs +++ b/lib/src/gitignore.rs @@ -14,6 +14,7 @@ use std::sync::Arc; +use itertools::Itertools; use regex::{escape as regex_escape, Regex}; pub enum GitIgnoreParseError {} @@ -87,7 +88,7 @@ impl GitIgnoreLine { regex.insert_str(0, "(^|/)"); } - let components: Vec<_> = input.split('/').collect(); + let components = input.split('/').collect_vec(); for (i, component) in components.iter().enumerate() { if *component == "**" { if i == components.len() - 1 { diff --git a/lib/src/index.rs b/lib/src/index.rs index e212c0fc8..a7b46758f 100644 --- a/lib/src/index.rs +++ b/lib/src/index.rs @@ -27,6 +27,7 @@ use std::sync::Arc; use blake2::{Blake2b, Digest}; use byteorder::{LittleEndian, ReadBytesExt, WriteBytesExt}; +use itertools::Itertools; use tempfile::NamedTempFile; use crate::commit::Commit; @@ -419,16 +420,16 @@ impl MutableIndex { let other = CompositeIndex(other_segment); for pos in other_segment.segment_num_parent_commits()..other.num_commits() { let entry = other.entry_by_pos(IndexPosition(pos)); - let parent_ids: Vec<_> = entry + let parent_ids = entry .parents() .iter() .map(|entry| entry.commit_id()) - .collect(); - let predecessor_ids: Vec<_> = entry + .collect_vec(); + let predecessor_ids = entry .predecessors() .iter() .map(|entry| entry.commit_id()) - .collect(); + .collect_vec(); self.add_commit_data( entry.commit_id(), entry.change_id(), @@ -843,14 +844,14 @@ impl<'a> CompositeIndex<'a> { } pub fn common_ancestors(&self, set1: &[CommitId], set2: &[CommitId]) -> Vec { - let pos1: Vec<_> = set1 + let pos1 = set1 .iter() .map(|id| self.commit_id_to_pos(id).unwrap()) - .collect(); - let pos2: Vec<_> = set2 + .collect_vec(); + let pos2 = set2 .iter() .map(|id| self.commit_id_to_pos(id).unwrap()) - .collect(); + .collect_vec(); self.common_ancestors_pos(&pos1, &pos2) .iter() .map(|pos| self.entry_by_pos(*pos).commit_id()) @@ -965,13 +966,15 @@ impl<'a> CompositeIndex<'a> { &self, input: impl IntoIterator, ) -> Vec> { - let mut entries_by_generation: Vec<_> = input + let mut entries_by_generation = input .into_iter() .map(|id| IndexEntryByPosition(self.entry_by_id(id).unwrap())) - .collect(); + .collect_vec(); entries_by_generation.sort(); - let entries: Vec<_> = entries_by_generation.into_iter().map(|key| key.0).collect(); - entries + entries_by_generation + .into_iter() + .map(|key| key.0) + .collect_vec() } } @@ -2303,7 +2306,7 @@ mod tests { index .walk_revs(wanted, unwanted) .map(|entry| entry.commit_id()) - .collect::>() + .collect_vec() }; // No wanted commits diff --git a/lib/src/index_store.rs b/lib/src/index_store.rs index 56c45761b..11c9a9bee 100644 --- a/lib/src/index_store.rs +++ b/lib/src/index_store.rs @@ -19,6 +19,7 @@ use std::io::{Read, Write}; use std::path::PathBuf; use std::sync::Arc; +use itertools::Itertools; use tempfile::NamedTempFile; use crate::commit::Commit; @@ -126,7 +127,7 @@ impl IndexStore { } } - let mut heads: Vec = new_heads.into_iter().collect(); + let mut heads = new_heads.into_iter().collect_vec(); heads.sort(); let commits = topo_order_earlier_first(store, heads, maybe_parent_file); diff --git a/lib/src/op_heads_store.rs b/lib/src/op_heads_store.rs index a136439a6..508296d4d 100644 --- a/lib/src/op_heads_store.rs +++ b/lib/src/op_heads_store.rs @@ -16,6 +16,7 @@ use std::collections::HashSet; use std::path::PathBuf; use std::sync::Arc; +use itertools::Itertools; use thiserror::Error; use crate::lock::FileLock; @@ -141,13 +142,13 @@ impl OpHeadsStore { return Ok(Operation::new(op_store.clone(), op_head_id, op_head)); } - let op_heads: Vec<_> = op_head_ids + let op_heads = op_head_ids .iter() .map(|op_id: &OperationId| { let data = op_store.read_operation(op_id).unwrap(); Operation::new(op_store.clone(), op_id.clone(), data) }) - .collect(); + .collect_vec(); let mut op_heads = self.handle_ancestor_ops(op_heads); // Return without creating a merge operation diff --git a/lib/src/repo_path.rs b/lib/src/repo_path.rs index ba5df1648..196459426 100644 --- a/lib/src/repo_path.rs +++ b/lib/src/repo_path.rs @@ -15,6 +15,8 @@ use std::fmt::{Debug, Error, Formatter}; use std::path::{Path, PathBuf}; +use itertools::Itertools; + #[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Debug, Hash)] pub struct RepoPathComponent { value: String, @@ -86,11 +88,11 @@ impl RepoPath { /// The full string form used internally, not for presenting to users (where /// we may want to use the platform's separator). pub fn to_internal_file_string(&self) -> String { - let strings: Vec = self + let strings = self .components .iter() .map(|component| component.value.clone()) - .collect(); + .collect_vec(); strings.join("/") } diff --git a/lib/src/revset.rs b/lib/src/revset.rs index ca39f2c1f..dab860309 100644 --- a/lib/src/revset.rs +++ b/lib/src/revset.rs @@ -18,6 +18,7 @@ use std::iter::Peekable; use std::ops::Range; use std::rc::Rc; +use itertools::Itertools; use pest::iterators::Pairs; use pest::Parser; use thiserror::Error; @@ -837,18 +838,20 @@ pub fn evaluate_expression<'repo>( RevsetExpression::Symbol(symbol) => { let commit_ids = resolve_symbol(repo, &symbol)?; let index = repo.index(); - let mut index_entries: Vec<_> = commit_ids + let mut index_entries = commit_ids .iter() .map(|id| index.entry_by_id(id).unwrap()) - .collect(); + .collect_vec(); index_entries.sort_by_key(|b| Reverse(b.position())); Ok(Box::new(EagerRevset { index_entries })) } RevsetExpression::Parents(base_expression) => { // TODO: Make this lazy let base_set = base_expression.evaluate(repo)?; - let mut parent_entries: Vec<_> = - base_set.iter().flat_map(|entry| entry.parents()).collect(); + let mut parent_entries = base_set + .iter() + .flat_map(|entry| entry.parents()) + .collect_vec(); parent_entries.sort_by_key(|b| Reverse(b.position())); parent_entries.dedup(); Ok(Box::new(EagerRevset { @@ -871,9 +874,9 @@ pub fn evaluate_expression<'repo>( .evaluate(repo), RevsetExpression::Range { roots, heads } => { let root_set = roots.evaluate(repo)?; - let root_ids: Vec<_> = root_set.iter().map(|entry| entry.commit_id()).collect(); + let root_ids = root_set.iter().map(|entry| entry.commit_id()).collect_vec(); let head_set = heads.evaluate(repo)?; - let head_ids: Vec<_> = head_set.iter().map(|entry| entry.commit_id()).collect(); + let head_ids = head_set.iter().map(|entry| entry.commit_id()).collect_vec(); let walk = repo.index().walk_revs(&head_ids, &root_ids); Ok(Box::new(RevWalkRevset { walk })) } @@ -885,7 +888,7 @@ pub fn evaluate_expression<'repo>( let candidate_set = RevsetExpression::Ancestors(heads.clone()).evaluate(repo)?; let mut reachable: HashSet<_> = root_set.iter().map(|entry| entry.position()).collect(); let mut result = vec![]; - let candidates: Vec<_> = candidate_set.iter().collect(); + let candidates = candidate_set.iter().collect_vec(); for candidate in candidates.into_iter().rev() { if reachable.contains(&candidate.position()) || candidate @@ -905,10 +908,10 @@ pub fn evaluate_expression<'repo>( RevsetExpression::AllHeads => { let index = repo.index(); let heads = repo.view().heads(); - let mut index_entries: Vec<_> = heads + let mut index_entries = heads .iter() .map(|id| index.entry_by_id(id).unwrap()) - .collect(); + .collect_vec(); index_entries.sort_by_key(|b| Reverse(b.position())); Ok(Box::new(EagerRevset { index_entries })) } @@ -930,21 +933,21 @@ pub fn evaluate_expression<'repo>( RevsetExpression::PublicHeads => { let index = repo.index(); let heads = repo.view().public_heads(); - let mut index_entries: Vec<_> = heads + let mut index_entries = heads .iter() .map(|id| index.entry_by_id(id).unwrap()) - .collect(); + .collect_vec(); index_entries.sort_by_key(|b| Reverse(b.position())); Ok(Box::new(EagerRevset { index_entries })) } RevsetExpression::GitRefs => { let index = repo.index(); - let mut index_entries: Vec<_> = repo + let mut index_entries = repo .view() .git_refs() .values() .map(|id| index.entry_by_id(id).unwrap()) - .collect(); + .collect_vec(); index_entries.sort_by_key(|b| Reverse(b.position())); index_entries.dedup(); Ok(Box::new(EagerRevset { index_entries })) @@ -987,7 +990,7 @@ fn non_obsolete_heads<'revset, 'repo: 'revset>( heads: Box + 'repo>, ) -> Box + 'revset> { let mut commit_ids = HashSet::new(); - let mut work: Vec<_> = heads.iter().collect(); + let mut work = heads.iter().collect_vec(); let evolution = repo.evolution(); while !work.is_empty() { let index_entry = work.pop().unwrap(); @@ -1005,10 +1008,10 @@ fn non_obsolete_heads<'revset, 'repo: 'revset>( } let index = repo.index(); let commit_ids = index.heads(&commit_ids); - let mut index_entries: Vec<_> = commit_ids + let mut index_entries = commit_ids .iter() .map(|id| index.entry_by_id(id).unwrap()) - .collect(); + .collect_vec(); index_entries.sort_by_key(|b| Reverse(b.position())); Box::new(EagerRevset { index_entries }) } @@ -1018,10 +1021,10 @@ pub fn revset_for_commits<'revset, 'repo: 'revset>( commits: &[&Commit], ) -> Box + 'revset> { let index = repo.index(); - let mut index_entries: Vec<_> = commits + let mut index_entries = commits .iter() .map(|commit| index.entry_by_id(commit.id()).unwrap()) - .collect(); + .collect_vec(); index_entries.sort_by_key(|b| Reverse(b.position())); Box::new(EagerRevset { index_entries }) } diff --git a/lib/src/rewrite.rs b/lib/src/rewrite.rs index 23a6307c7..becfbe5dd 100644 --- a/lib/src/rewrite.rs +++ b/lib/src/rewrite.rs @@ -12,6 +12,8 @@ // See the License for the specific language governing permissions and // limitations under the License. +use itertools::Itertools; + use crate::commit::Commit; use crate::commit_builder::CommitBuilder; use crate::repo::{MutableRepo, RepoRef}; @@ -28,13 +30,16 @@ pub fn merge_commit_trees(repo: RepoRef, commits: &[Commit]) -> Tree { } else { let index = repo.index(); let mut new_tree = commits[0].tree(); - let commit_ids: Vec<_> = commits.iter().map(|commit| commit.id().clone()).collect(); + let commit_ids = commits + .iter() + .map(|commit| commit.id().clone()) + .collect_vec(); for (i, other_commit) in commits.iter().enumerate().skip(1) { let ancestor_ids = index.common_ancestors(&commit_ids[0..i], &[commit_ids[i].clone()]); - let ancestors: Vec<_> = ancestor_ids + let ancestors = ancestor_ids .iter() .map(|id| store.get_commit(id).unwrap()) - .collect(); + .collect_vec(); let ancestor_tree = merge_commit_trees(repo, &ancestors); let new_tree_id = merge_trees(&new_tree, &ancestor_tree, &other_commit.tree()).unwrap(); new_tree = store.get_tree(&RepoPath::root(), &new_tree_id).unwrap(); diff --git a/lib/src/testutils.rs b/lib/src/testutils.rs index 790fe2429..22748202a 100644 --- a/lib/src/testutils.rs +++ b/lib/src/testutils.rs @@ -17,6 +17,7 @@ use std::fs::OpenOptions; use std::io::Write; use std::sync::Arc; +use itertools::Itertools; use tempfile::TempDir; use crate::commit::Commit; @@ -150,7 +151,10 @@ impl<'settings, 'repo> CommitGraphBuilder<'settings, 'repo> { } pub fn commit_with_parents(&mut self, parents: &[&Commit]) -> Commit { - let parent_ids: Vec<_> = parents.iter().map(|commit| commit.id().clone()).collect(); + let parent_ids = parents + .iter() + .map(|commit| commit.id().clone()) + .collect_vec(); create_random_commit(self.settings, self.mut_repo.base_repo().as_ref()) .set_parents(parent_ids) .write_to_repo(self.mut_repo) diff --git a/lib/tests/test_evolution.rs b/lib/tests/test_evolution.rs index 8105ec488..aab450ae3 100644 --- a/lib/tests/test_evolution.rs +++ b/lib/tests/test_evolution.rs @@ -14,6 +14,7 @@ #![feature(assert_matches)] +use itertools::Itertools; use jujutsu_lib::commit::Commit; use jujutsu_lib::commit_builder::CommitBuilder; use jujutsu_lib::evolution::{ @@ -722,7 +723,7 @@ fn test_evolve_divergent(use_git: bool) { assert_eq!(resolved.predecessors(), &[commit6, commit4]); let tree = resolved.tree(); - let entries: Vec<_> = tree.entries().collect(); + let entries = tree.entries().collect_vec(); assert_eq!(entries.len(), 4); assert_eq!( tree.value(&RepoPathComponent::from("A")).unwrap(), diff --git a/lib/tests/test_merge_trees.rs b/lib/tests/test_merge_trees.rs index ce5d7f22c..fceb36380 100644 --- a/lib/tests/test_merge_trees.rs +++ b/lib/tests/test_merge_trees.rs @@ -12,6 +12,7 @@ // See the License for the specific language governing permissions and // limitations under the License. +use itertools::Itertools; use jujutsu_lib::repo_path::{RepoPath, RepoPathComponent}; use jujutsu_lib::store::{ConflictPart, TreeValue}; use jujutsu_lib::tree::Tree; @@ -72,10 +73,10 @@ fn test_same_type(use_git: bool) { let merged_tree = store.get_tree(&RepoPath::root(), &merged_tree_id).unwrap(); // Check that we have exactly the paths we expect in the merged tree - let names: Vec<&str> = merged_tree + let names = merged_tree .entries_non_recursive() .map(|entry| entry.name().as_str()) - .collect(); + .collect_vec(); assert_eq!( names, vec!["__a", "_a_", "_aa", "_ab", "a_b", "aaa", "aab", "ab_", "aba", "abb", "abc",] @@ -259,7 +260,7 @@ fn test_subtrees(use_git: bool) { let merged_tree_id = tree::merge_trees(&side1_tree, &base_tree, &side2_tree).unwrap(); let merged_tree = store.get_tree(&RepoPath::root(), &merged_tree_id).unwrap(); - let entries: Vec<_> = merged_tree.entries().collect(); + let entries = merged_tree.entries().collect_vec(); let expected_tree = write_tree(vec![ "f1", @@ -270,7 +271,7 @@ fn test_subtrees(use_git: bool) { "d1/d1/d1/f1", "d1/d1/d1/f2", ]); - let expected_entries: Vec<_> = expected_tree.entries().collect(); + let expected_entries = expected_tree.entries().collect_vec(); assert_eq!(entries, expected_entries); } diff --git a/lib/tests/test_revset_graph_iterator.rs b/lib/tests/test_revset_graph_iterator.rs index 9f4d8613c..4ed286659 100644 --- a/lib/tests/test_revset_graph_iterator.rs +++ b/lib/tests/test_revset_graph_iterator.rs @@ -12,6 +12,7 @@ // See the License for the specific language governing permissions and // limitations under the License. +use itertools::Itertools; use jujutsu_lib::revset::revset_for_commits; use jujutsu_lib::revset_graph_iterator::RevsetGraphEdge; use jujutsu_lib::testutils; @@ -47,11 +48,11 @@ fn test_graph_iterator_linearized(skip_transitive_edges: bool) { let pos_a = mut_repo.index().commit_id_to_pos(commit_a.id()).unwrap(); let revset = revset_for_commits(mut_repo.as_repo_ref(), &[&commit_a, &commit_d]); - let commits: Vec<_> = revset + let commits = revset .iter() .graph() .set_skip_transitive_edges(skip_transitive_edges) - .collect(); + .collect_vec(); drop(revset); assert_eq!(commits.len(), 2); assert_eq!(commits[0].0.commit_id(), *commit_d.id()); @@ -97,11 +98,11 @@ fn test_graph_iterator_virtual_octopus(skip_transitive_edges: bool) { mut_repo.as_repo_ref(), &[&commit_a, &commit_b, &commit_c, &commit_f], ); - let commits: Vec<_> = revset + let commits = revset .iter() .graph() .set_skip_transitive_edges(skip_transitive_edges) - .collect(); + .collect_vec(); drop(revset); assert_eq!(commits.len(), 4); assert_eq!(commits[0].0.commit_id(), *commit_f.id()); @@ -155,11 +156,11 @@ fn test_graph_iterator_simple_fork(skip_transitive_edges: bool) { let pos_a = mut_repo.index().commit_id_to_pos(commit_a.id()).unwrap(); let revset = revset_for_commits(mut_repo.as_repo_ref(), &[&commit_a, &commit_c, &commit_e]); - let commits: Vec<_> = revset + let commits = revset .iter() .graph() .set_skip_transitive_edges(skip_transitive_edges) - .collect(); + .collect_vec(); drop(revset); assert_eq!(commits.len(), 3); assert_eq!(commits[0].0.commit_id(), *commit_e.id()); @@ -205,11 +206,11 @@ fn test_graph_iterator_multiple_missing(skip_transitive_edges: bool) { let pos_c = mut_repo.index().commit_id_to_pos(commit_c.id()).unwrap(); let revset = revset_for_commits(mut_repo.as_repo_ref(), &[&commit_b, &commit_f]); - let commits: Vec<_> = revset + let commits = revset .iter() .graph() .set_skip_transitive_edges(skip_transitive_edges) - .collect(); + .collect_vec(); drop(revset); assert_eq!(commits.len(), 2); assert_eq!(commits[0].0.commit_id(), *commit_f.id()); @@ -260,11 +261,11 @@ fn test_graph_iterator_edge_to_ancestor(skip_transitive_edges: bool) { let pos_d = mut_repo.index().commit_id_to_pos(commit_d.id()).unwrap(); let revset = revset_for_commits(mut_repo.as_repo_ref(), &[&commit_c, &commit_d, &commit_f]); - let commits: Vec<_> = revset + let commits = revset .iter() .graph() .set_skip_transitive_edges(skip_transitive_edges) - .collect(); + .collect_vec(); drop(revset); assert_eq!(commits.len(), 3); assert_eq!(commits[0].0.commit_id(), *commit_f.id()); @@ -341,11 +342,11 @@ fn test_graph_iterator_edge_escapes_from_(skip_transitive_edges: bool) { mut_repo.as_repo_ref(), &[&commit_a, &commit_d, &commit_g, &commit_h, &commit_j], ); - let commits: Vec<_> = revset + let commits = revset .iter() .graph() .set_skip_transitive_edges(skip_transitive_edges) - .collect(); + .collect_vec(); drop(revset); assert_eq!(commits.len(), 5); assert_eq!(commits[0].0.commit_id(), *commit_j.id()); diff --git a/lib/tests/test_working_copy.rs b/lib/tests/test_working_copy.rs index 6270f1689..ab31c4684 100644 --- a/lib/tests/test_working_copy.rs +++ b/lib/tests/test_working_copy.rs @@ -18,6 +18,7 @@ use std::io::{Read, Write}; use std::os::unix::fs::PermissionsExt; use std::sync::Arc; +use itertools::Itertools; use jujutsu_lib::commit_builder::CommitBuilder; use jujutsu_lib::repo::ReadonlyRepo; use jujutsu_lib::repo_path::{RepoPath, RepoPathComponent}; @@ -298,11 +299,11 @@ fn test_gitignores(use_git: bool) { let wc = repo.working_copy().clone(); let (repo, commit1) = wc.lock().unwrap().commit(&settings, repo); - let files1: Vec<_> = commit1 + let files1 = commit1 .tree() .entries() .map(|(name, _value)| name) - .collect(); + .collect_vec(); assert_eq!( files1, vec![ @@ -323,11 +324,11 @@ fn test_gitignores(use_git: bool) { let wc = repo.working_copy().clone(); let (_repo, commit2) = wc.lock().unwrap().commit(&settings, repo); - let files2: Vec<_> = commit2 + let files2 = commit2 .tree() .entries() .map(|(name, _value)| name) - .collect(); + .collect_vec(); assert_eq!( files2, vec![ diff --git a/src/commands.rs b/src/commands.rs index 57cef7fa7..8633f3635 100644 --- a/src/commands.rs +++ b/src/commands.rs @@ -29,6 +29,7 @@ use std::{fs, io}; use clap::{crate_version, App, Arg, ArgMatches, SubCommand}; use criterion::Criterion; +use itertools::Itertools; use jujutsu_lib::commit::Commit; use jujutsu_lib::commit_builder::CommitBuilder; use jujutsu_lib::dag_walk::topo_order_reverse; @@ -346,7 +347,7 @@ impl RepoCommandHelper { format!("'{}'", arg.replace("'", "\\'")) } }; - let quoted_strings: Vec<_> = self.string_args.iter().map(shell_escape).collect(); + let quoted_strings = self.string_args.iter().map(shell_escape).collect_vec(); tx.set_tag("args".to_string(), quoted_strings.join(" ")); tx } @@ -1442,7 +1443,7 @@ fn edit_description(repo: &ReadonlyRepo, description: &str) -> String { let editor = std::env::var("EDITOR").unwrap_or_else(|_| "pico".to_string()); // Handle things like `EDITOR=emacs -nw` - let args: Vec<_> = editor.split(' ').collect(); + let args = editor.split(' ').collect_vec(); let editor_args = if args.len() > 1 { &args[1..] } else { &[] }; let exit_status = Command::new(args[0]) .args(editor_args) @@ -1463,10 +1464,10 @@ fn edit_description(repo: &ReadonlyRepo, description: &str) -> String { // Delete the file only if everything went well. // TODO: Tell the user the name of the file we left behind. std::fs::remove_file(description_file_path).ok(); - let mut lines: Vec<_> = description + let mut lines = description .split_inclusive('\n') .filter(|line| !line.starts_with("JJ: ")) - .collect(); + .collect_vec(); // Remove trailing blank lines while matches!(lines.last(), Some(&"\n") | Some(&"\r\n")) { lines.pop().unwrap(); diff --git a/src/templater.rs b/src/templater.rs index df1ee5364..fe302e90c 100644 --- a/src/templater.rs +++ b/src/templater.rs @@ -16,6 +16,7 @@ use std::borrow::BorrowMut; use std::io; use std::ops::Add; +use itertools::Itertools; use jujutsu_lib::commit::Commit; use jujutsu_lib::repo::RepoRef; use jujutsu_lib::store::{CommitId, Signature}; @@ -61,10 +62,10 @@ pub struct LabelTemplate<'a, C> { impl<'a, C> LabelTemplate<'a, C> { pub fn new(content: Box + 'a>, labels: String) -> Self { - let labels: Vec = labels + let labels = labels .split_whitespace() .map(|label| label.to_string()) - .collect(); + .collect_vec(); LabelTemplate { content, labels } } } @@ -103,10 +104,10 @@ impl<'a, C> DynamicLabelTemplate<'a, C> { impl<'a, C> Template for DynamicLabelTemplate<'a, C> { fn format(&self, context: &C, formatter: &mut dyn Formatter) -> io::Result<()> { let labels = self.label_property.as_ref()(context); - let labels: Vec = labels + let labels = labels .split_whitespace() .map(|label| label.to_string()) - .collect(); + .collect_vec(); for label in &labels { formatter.add_label(label.clone())?; } @@ -225,14 +226,14 @@ pub struct GitRefsProperty<'a> { impl TemplateProperty for GitRefsProperty<'_> { fn extract(&self, context: &Commit) -> String { - let refs: Vec<_> = self + let refs = self .repo .view() .git_refs() .iter() .filter(|(_name, id)| *id == context.id()) .map(|(name, _id)| name.clone()) - .collect(); + .collect_vec(); refs.join(" ") } }