thanks clippy

Sebastian Thiel committed 3 years ago

Commit bac57dd1 parent e22080e100 files · +172 −230Browse files

Unified · Split

100 files

git-attributes/tests/match_group/mod.rs +1 −1
git-attributes/tests/parse/attribute.rs +1 −1
git-commitgraph/src/file/init.rs +2 −2
git-commitgraph/src/graph/init.rs +1 −1
git-config-value/src/color.rs +1 −1
git-config-value/src/integer.rs +1 −1
git-config/src/file/init/from_env.rs +2 −2
git-config/src/file/mutable/section.rs +2 −2
git-config/src/file/write.rs +1 −1
git-config/src/parse/error.rs +1 −1
git-credentials/src/protocol/context/mod.rs +1 −1
git-credentials/tests/helper/cascade.rs +1 −1
git-credentials/tests/helper/context.rs +4 −6
git-credentials/tests/helper/invoke.rs +1 −1
git-date/src/time/write.rs +1 −1
git-diff/src/tree/visit.rs +1 −2
git-diff/tests/tree/mod.rs +2 −2
git-discover/src/upwards/types.rs +1 −1
git-discover/tests/upwards/mod.rs +3 −11
git-glob/tests/pattern/matching.rs +2 −3
git-hash/src/object_id.rs +2 −2
git-hash/src/oid.rs +1 −1
git-hash/tests/prefix/mod.rs +1 −1
git-lock/src/backoff.rs +3 −8
git-object/tests/object.rs +1 −2
git-odb/src/store_impls/dynamic/find.rs +2 −2
git-odb/src/store_impls/dynamic/header.rs +1 −1
git-pack/src/cache/delta/traverse/mod.rs +1 −1
git-pack/src/cache/lru.rs +2 −2
git-pack/src/cache/object.rs +1 −1
git-pack/src/data/file/init.rs +1 −2
git-pack/src/data/input/entries_to_bytes.rs +2 −2
git-pack/src/data/output/count/objects/mod.rs +1 −1
git-pack/src/data/output/entry/iter_from_counts.rs +1 −1
git-pack/src/index/init.rs +1 −1
git-pack/src/index/traverse/reduce.rs +1 −1
git-pack/src/index/traverse/with_index.rs +1 −1
git-pack/src/index/traverse/with_lookup.rs +2 −2
git-pack/src/index/write/mod.rs +1 −2
git-path/tests/convert/normalize.rs +1 −2
git-pathspec/tests/pathspec.rs +18 −60
git-protocol/src/command/tests.rs +2 −2
git-protocol/src/fetch/arguments/mod.rs +2 −2
git-protocol/src/fetch_fn.rs +1 −1
git-protocol/tests/fetch/response.rs +1 −1
git-protocol/tests/fetch/v1.rs +1 −1
git-protocol/tests/fetch/v2.rs +1 −1
git-ref/src/store/file/loose/reflog.rs +1 −1
git-ref/src/store/file/transaction/prepare.rs +1 −1
git-ref/src/store/packed/transaction.rs +5 −5
git-ref/src/transaction/ext.rs +2 −5
git-ref/tests/file/store/find.rs +1 −1
git-ref/tests/file/store/iter.rs +1 −1
git-ref/tests/file/transaction/prepare_and_commit/create_or_update/collisions.rs +1 −4
git-refspec/tests/matching/mod.rs +7 −14
git-repository/src/clone/fetch/util.rs +1 −0
git-repository/src/clone/mod.rs +1 −0
git-repository/src/config/cache/access.rs +1 −0
git-repository/src/config/cache/incubate.rs +1 −0
git-repository/src/config/cache/init.rs +1 −0
git-repository/src/config/cache/util.rs +2 −1
git-repository/src/config/mod.rs +1 −1
git-repository/src/config/snapshot/access.rs +1 −0
git-repository/src/config/tree/keys.rs +2 −0
git-repository/src/config/tree/sections/core.rs +1 −1
git-repository/src/discover.rs +1 −0
git-repository/src/init.rs +1 −0
git-repository/src/lib.rs +5 −0
git-repository/src/open/mod.rs +1 −3
git-repository/src/open/options.rs +1 −0
git-repository/src/open/repository.rs +1 −0
git-repository/src/reference/edits.rs +1 −0
git-repository/src/remote/connect.rs +1 −0
git-repository/src/remote/connection/fetch/mod.rs +1 −1
git-repository/src/remote/connection/fetch/receive_pack.rs +1 −1
git-repository/src/remote/connection/fetch/update_refs/mod.rs +1 −0
git-repository/src/remote/connection/fetch/update_refs/tests.rs +4 −5
git-repository/src/remote/connection/fetch/update_refs/update.rs +1 −1
git-repository/src/repository/config/transport.rs +4 −3
git-repository/src/repository/object.rs +1 −0
git-repository/src/repository/remote.rs +1 −0
git-repository/src/repository/worktree.rs +1 −0
git-repository/src/revision/spec/parse/error.rs +3 −3
git-repository/src/worktree/proxy.rs +1 −0
git-repository/tests/util/mod.rs +1 −0
git-revision/src/describe.rs +1 −1
git-tempfile/examples/try-deadlock-on-cleanup.rs +3 −4
git-tempfile/src/fs/create_dir.rs +1 −2
git-tempfile/src/fs/remove_dir.rs +1 −4
git-transport/src/client/blocking_io/http/curl/remote.rs +1 −1
git-transport/src/client/blocking_io/http/mod.rs +4 −5
git-transport/src/client/blocking_io/ssh/program_kind.rs +1 −1
git-transport/src/client/blocking_io/traits.rs +2 −2
git-transport/src/client/git/mod.rs +2 −2
git-transport/tests/client/blocking_io/http/mod.rs +3 −3
git-url/src/expand_path.rs +1 −1
git-url/src/lib.rs +1 −1
git-url/tests/expand_path/mod.rs +2 −2
git-worktree/src/fs/cache/state.rs +2 −2
tests/tools/src/lib.rs +1 −1

git-attributes/tests/match_group/mod.rs+1−1

@@ -82,7 +82,7 @@ mod ignore { · 81 unmodified lines
82	);	82	);
83	}	83	}
84	(None, None) => {}	84	(None, None) => {}
85	(actual, expected) => panic!("actual {:?} should match {:?} with path '{}'", actual, expected, path),	85	(actual, expected) => panic!("actual {actual:?} should match {expected:?} with path '{path}'"),
86	}	86	}
87	}	87	}
88	Ok(())	88	Ok(())

git-attributes/tests/parse/attribute.rs+1−1

@@ -275,7 +275,7 @@ fn unspecified(attr: &str) -> (BString, StateRef) { · 274 unmodified lines
275	(attr.into(), StateRef::Unspecified)	275	(attr.into(), StateRef::Unspecified)
276	}	276	}
277		277
278	fn value<'a, 'b>(attr: &'a str, value: &'b str) -> (BString, StateRef<'b>) {	278	fn value<'b>(attr: &str, value: &'b str) -> (BString, StateRef<'b>) {
279	(attr.into(), StateRef::Value(value.as_bytes().as_bstr()))	279	(attr.into(), StateRef::Value(value.as_bytes().as_bstr()))
280	}	280	}
281		281

git-commitgraph/src/file/init.rs+2−2

@@ -148,7 +148,7 @@ impl TryFrom<&Path> for File { · 147 unmodified lines
148	if chunk_size % entry_size != 0 {	148	if chunk_size % entry_size != 0 {
149	return Err(Error::InvalidChunkSize {	149	return Err(Error::InvalidChunkSize {
150	id: COMMIT_DATA_CHUNK_ID,	150	id: COMMIT_DATA_CHUNK_ID,
151	msg: format!("chunk size {} is not a multiple of {}", chunk_size, entry_size),	151	msg: format!("chunk size {chunk_size} is not a multiple of {entry_size}"),
152	});	152	});
153	}	153	}
154	Ok((	154	Ok((
@@ -166,7 +166,7 @@ impl TryFrom<&Path> for File { · 11 unmodified lines
166	if chunk_size != expected_size {	166	if chunk_size != expected_size {
167	return Err(Error::InvalidChunkSize {	167	return Err(Error::InvalidChunkSize {
168	id: OID_FAN_CHUNK_ID,	168	id: OID_FAN_CHUNK_ID,
169	msg: format!("expected chunk length {}, got {}", expected_size, chunk_size),	169	msg: format!("expected chunk length {expected_size}, got {chunk_size}"),
170	});	170	});
171	}	171	}
172	Ok(chunk_range.start)	172	Ok(chunk_range.start)

git-commitgraph/src/graph/init.rs+1−1

@@ -62,7 +62,7 @@ impl Graph { · 61 unmodified lines
62	err: e,	62	err: e,
63	path: chain_file_path.clone(),	63	path: chain_file_path.clone(),
64	})?;	64	})?;
65	let graph_file_path = commit_graphs_dir.join(format!("graph-{}.graph", hash));	65	let graph_file_path = commit_graphs_dir.join(format!("graph-{hash}.graph"));
66	files.push(File::at(&graph_file_path).map_err(\|e\| Error::File {	66	files.push(File::at(&graph_file_path).map_err(\|e\| Error::File {
67	err: e,	67	err: e,
68	path: graph_file_path.clone(),	68	path: graph_file_path.clone(),

git-config-value/src/color.rs+1−1

@@ -148,7 +148,7 @@ impl Display for Name { · 147 unmodified lines
148	Self::White => write!(f, "white"),	148	Self::White => write!(f, "white"),
149	Self::BrightWhite => write!(f, "brightwhite"),	149	Self::BrightWhite => write!(f, "brightwhite"),
150	Self::Ansi(num) => num.fmt(f),	150	Self::Ansi(num) => num.fmt(f),
151	Self::Rgb(r, g, b) => write!(f, "#{:02x}{:02x}{:02x}", r, g, b),	151	Self::Rgb(r, g, b) => write!(f, "#{r:02x}{g:02x}{b:02x}"),
152	}	152	}
153	}	153	}
154	}	154	}

git-config-value/src/integer.rs+1−1

@@ -26,7 +26,7 @@ impl Display for Integer { · 25 unmodified lines
26	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {	26	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
27	write!(f, "{}", self.value)?;	27	write!(f, "{}", self.value)?;
28	if let Some(suffix) = self.suffix {	28	if let Some(suffix) = self.suffix {
29	write!(f, "{}", suffix)	29	write!(f, "{suffix}")
30	} else {	30	} else {
31	Ok(())	31	Ok(())
32	}	32	}

git-config/src/file/init/from_env.rs+2−2

@@ -56,10 +56,10 @@ impl File<'static> { · 55 unmodified lines
56	let mut config = File::new(meta);	56	let mut config = File::new(meta);
57	for i in 0..count {	57	for i in 0..count {
58	let key = git_path::os_string_into_bstring(	58	let key = git_path::os_string_into_bstring(
59	env::var_os(format!("GIT_CONFIG_KEY_{}", i)).ok_or(Error::InvalidKeyId { key_id: i })?,	59	env::var_os(format!("GIT_CONFIG_KEY_{i}")).ok_or(Error::InvalidKeyId { key_id: i })?,
60	)	60	)
61	.map_err(\|_\| Error::IllformedUtf8 { index: i, kind: "key" })?;	61	.map_err(\|_\| Error::IllformedUtf8 { index: i, kind: "key" })?;
62	let value = env::var_os(format!("GIT_CONFIG_VALUE_{}", i)).ok_or(Error::InvalidValueId { value_id: i })?;	62	let value = env::var_os(format!("GIT_CONFIG_VALUE_{i}")).ok_or(Error::InvalidValueId { value_id: i })?;
63	let key = parse::key(<_ as AsRef<BStr>>::as_ref(&key)).ok_or_else(\|\| Error::InvalidKeyValue {	63	let key = parse::key(<_ as AsRef<BStr>>::as_ref(&key)).ok_or_else(\|\| Error::InvalidKeyValue {
64	key_id: i,	64	key_id: i,
65	key_val: key.to_string(),	65	key_val: key.to_string(),

git-config/src/file/mutable/section.rs+2−2

@@ -217,9 +217,9 @@ impl<'a, 'event> SectionMut<'a, 'event> { · 216 unmodified lines
217	}	217	}
218	}	218	}
219		219
220	pub(crate) fn get<'key>(	220	pub(crate) fn get(
221	&self,	221	&self,
222	key: &Key<'key>,	222	key: &Key<'_>,
223	start: Index,	223	start: Index,
224	end: Index,	224	end: Index,
225	) -> Result<Cow<'_, BStr>, lookup::existing::Error> {	225	) -> Result<Cow<'_, BStr>, lookup::existing::Error> {

git-config/src/file/write.rs+1−1

@@ -67,7 +67,7 @@ pub(crate) fn ends_with_newline(e: &[crate::parse::Event<'_>], nl: impl AsRef<[u · 66 unmodified lines
67	.unwrap_or(false)	67	.unwrap_or(false)
68	}	68	}
69		69
70	pub(crate) fn extract_newline<'a, 'b>(e: &'a Event<'b>) -> Option<&'a BStr> {	70	pub(crate) fn extract_newline<'a>(e: &'a Event<'_>) -> Option<&'a BStr> {
71	match e {	71	match e {
72	Event::Newline(b) => b.as_ref().into(),	72	Event::Newline(b) => b.as_ref().into(),
73	_ => None,	73	_ => None,

git-config/src/parse/error.rs+1−1

@@ -55,7 +55,7 @@ impl Display for Error { · 54 unmodified lines
55	data_size - 10	55	data_size - 10
56	)	56	)
57	}	57	}
58	(Ok(data), _) => write!(f, "'{}'", data),	58	(Ok(data), _) => write!(f, "'{data}'"),
59	(Err(_), _) => self.parsed_until.fmt(f),	59	(Err(_), _) => self.parsed_until.fmt(f),
60	}	60	}
61	}	61	}

git-credentials/src/protocol/context/mod.rs+1−1

@@ -62,7 +62,7 @@ mod mutate { · 61 unmodified lines
62	self.host = url.host().map(ToOwned::to_owned).map(\|mut host\| {	62	self.host = url.host().map(ToOwned::to_owned).map(\|mut host\| {
63	if let Some(port) = url.port {	63	if let Some(port) = url.port {
64	use std::fmt::Write;	64	use std::fmt::Write;
65	write!(host, ":{}", port).expect("infallible");	65	write!(host, ":{port}").expect("infallible");
66	}	66	}
67	host	67	host
68	});	68	});

git-credentials/tests/helper/cascade.rs+1−1

@@ -163,7 +163,7 @@ mod invoke { · 162 unmodified lines
163	fn fixtures<'a>(names: impl IntoIterator<Item = &'a str>) -> Vec<Program> {	163	fn fixtures<'a>(names: impl IntoIterator<Item = &'a str>) -> Vec<Program> {
164	names	164	names
165	.into_iter()	165	.into_iter()
166	.map(\|name\| git_path::realpath(fixture_path(format!("{}.sh", name))).unwrap())	166	.map(\|name\| git_path::realpath(fixture_path(format!("{name}.sh"))).unwrap())
167	.map(\|path\| {	167	.map(\|path\| {
168	let mut script = git_path::to_unix_separators_on_windows(git_path::into_bstr(path)).into_owned();	168	let mut script = git_path::to_unix_separators_on_windows(git_path::into_bstr(path)).into_owned();
169	script.insert_str(0, "sh ");	169	script.insert_str(0, "sh ");

git-credentials/tests/helper/context.rs+4−6

     #[test]
     fn quit_supports_git_config_boolean_values() {
         for true_value in ["1", "42", "-42", "true", "on", "yes"] {
-            let input = format!("quit={}", true_value);
+            let input = format!("quit={true_value}");
             assert_eq!(
                 Context::from_bytes(input.as_bytes()).unwrap().quit,
                 Some(true),
-                "{}",
+                "{input}"
-                input
             )
         }
         for false_value in ["0", "false", "off", "no"] {
-            let input = format!("quit={}", false_value);
+            let input = format!("quit={false_value}");
             assert_eq!(
                 Context::from_bytes(input.as_bytes()).unwrap().quit,
                 Some(false),
-                "{}",
+                "{input}"
-                input
             )
         }
     }

git-credentials/tests/helper/invoke.rs+1−1

@@ -126,7 +126,7 @@ mod program { · 125 unmodified lines
126		126
127	pub fn script_helper(name: &str) -> Program {	127	pub fn script_helper(name: &str) -> Program {
128	let mut script = git_path::to_unix_separators_on_windows(git_path::into_bstr(	128	let mut script = git_path::to_unix_separators_on_windows(git_path::into_bstr(
129	git_path::realpath(fixture_path(format!("{}.sh", name))).unwrap(),	129	git_path::realpath(fixture_path(format!("{name}.sh"))).unwrap(),
130	))	130	))
131	.into_owned();	131	.into_owned();
132	script.insert_str(0, "sh ");	132	script.insert_str(0, "sh ");

git-date/src/time/write.rs+1−1

@@ -26,7 +26,7 @@ impl Time { · 25 unmodified lines
26	const SECONDS_PER_HOUR: i32 = 60 * 60;	26	const SECONDS_PER_HOUR: i32 = 60 * 60;
27	let offset = self.offset_in_seconds.abs();	27	let offset = self.offset_in_seconds.abs();
28	let hours = offset / SECONDS_PER_HOUR;	28	let hours = offset / SECONDS_PER_HOUR;
29	assert!(hours < 25, "offset is more than a day: {}", hours);	29	assert!(hours < 25, "offset is more than a day: {hours}");
30	let minutes = (offset - (hours * SECONDS_PER_HOUR)) / 60;	30	let minutes = (offset - (hours * SECONDS_PER_HOUR)) / 60;
31		31
32	if hours < 10 {	32	if hours < 10 {

git-diff/src/tree/visit.rs+1−2

         let actual = std::mem::size_of::<Change>();
         assert!(
             actual <= 46,
-            "{} <= 46: this type shouldn't grow without us knowing",
+            "{actual} <= 46: this type shouldn't grow without us knowing"
-            actual
         )
     }
 }

git-diff/tests/tree/mod.rs+2−2

@@ -25,7 +25,7 @@ mod changes { · 24 unmodified lines
25	) -> crate::Result<TreeRefIter<'a>> {	25	) -> crate::Result<TreeRefIter<'a>> {
26	let tree_id = db	26	let tree_id = db
27	.try_find(commit, buf)?	27	.try_find(commit, buf)?
28	.ok_or_else(\|\| format!("start commit {:?} to be present", commit))?	28	.ok_or_else(\|\| format!("start commit {commit:?} to be present"))?
29	.0	29	.0
30	.decode()?	30	.decode()?
31	.into_commit()	31	.into_commit()
@@ -66,7 +66,7 @@ mod changes { · 34 unmodified lines
66	let (main_tree_id, parent_commit_id) = {	66	let (main_tree_id, parent_commit_id) = {
67	let commit = db	67	let commit = db
68	.try_find(commit_id, &mut buf)?	68	.try_find(commit_id, &mut buf)?
69	.ok_or_else(\|\| format!("start commit {:?} to be present", commit_id))?	69	.ok_or_else(\|\| format!("start commit {commit_id:?} to be present"))?
70	.0	70	.0
71	.decode()?	71	.decode()?
72	.into_commit()	72	.into_commit()

git-discover/src/upwards/types.rs+1−1

@@ -138,7 +138,7 @@ mod tests { · 137 unmodified lines
138		138
139	// Parse & build ceiling dirs string	139	// Parse & build ceiling dirs string
140	let symlink_str = symlink_path.to_str().expect("symlink path is valid utf8");	140	let symlink_str = symlink_path.to_str().expect("symlink path is valid utf8");
141	let ceiling_dir_string = format!("{}:relative::{}", symlink_str, symlink_str);	141	let ceiling_dir_string = format!("{symlink_str}:relative::{symlink_str}");
142	let ceiling_dirs = parse_ceiling_dirs(OsStr::new(ceiling_dir_string.as_str()));	142	let ceiling_dirs = parse_ceiling_dirs(OsStr::new(ceiling_dir_string.as_str()));
143		143
144	assert_eq!(ceiling_dirs.len(), 2, "Relative path is discarded");	144	assert_eq!(ceiling_dirs.len(), 2, "Relative path is discarded");

git-discover/tests/upwards/mod.rs+3−11

             let (path, _trust) = git_discover::upwards(&submodule_m1_workdir)?;
             assert!(
                 matches!(path, git_discover::repository::Path::LinkedWorkTree{ref work_dir, ref git_dir} if work_dir == &submodule_m1_workdir && git_dir == &submodule_m1_gitdir),
-                "{:?} should match {:?} {:?}",
+                "{path:?} should match {submodule_m1_workdir:?} {submodule_m1_gitdir:?}"
-                path,
-                submodule_m1_workdir,
-                submodule_m1_gitdir
             );
             let (path, _trust) = git_discover::upwards(submodule_m1_workdir.join("subdir"))?;
             assert!(
                 matches!(path, git_discover::repository::Path::LinkedWorkTree{ref work_dir, ref git_dir} if work_dir == &submodule_m1_workdir && git_dir == &submodule_m1_gitdir),
-                "{:?} should match {:?} {:?}",
+                "{path:?} should match {submodule_m1_workdir:?} {submodule_m1_gitdir:?}"
-                path,
-                submodule_m1_workdir,
-                submodule_m1_gitdir
             );
         }
         Ok(())
             let (path, _trust) = git_discover::upwards(&submodule_m1_gitdir)?;
             assert!(
                 matches!(path, git_discover::repository::Path::Repository(ref dir) if dir == &submodule_m1_gitdir),
-                "{:?} should match {:?}",
+                "{path:?} should match {submodule_m1_gitdir:?}"
-                path,
-                submodule_m1_gitdir
             );
         }
         Ok(())

git-glob/tests/pattern/matching.rs+2−3

         } in Baseline::new(&input)
         {
             total_matches += 1;
-            assert!(seen.insert(m), "duplicate match entry: {:?}", m);
+            assert!(seen.insert(m), "duplicate match entry: {m:?}");
             assert_eq!(
                 is_match, *expected_matches,
-                "baseline for matches must be {} - check baseline and git version: {:?}",
+                "baseline for matches must be {expected_matches} - check baseline and git version: {m:?}"
-                expected_matches, m
             );
             match std::panic::catch_unwind(|| {
                 let pattern = pat(pattern);

git-hash/src/object_id.rs+2−2

@@ -157,7 +157,7 @@ impl std::fmt::Debug for ObjectId { · 156 unmodified lines
157	ObjectId::Sha1(_hash) => f.write_str("Sha1(")?,	157	ObjectId::Sha1(_hash) => f.write_str("Sha1(")?,
158	}	158	}
159	for b in self.as_bytes() {	159	for b in self.as_bytes() {
160	write!(f, "{:02x}", b)?;	160	write!(f, "{b:02x}")?;
161	}	161	}
162	f.write_str(")")	162	f.write_str(")")
163	}	163	}
@@ -173,7 +173,7 @@ impl From<&[u8]> for ObjectId { · 9 unmodified lines
173	fn from(v: &[u8]) -> Self {	173	fn from(v: &[u8]) -> Self {
174	match v.len() {	174	match v.len() {
175	20 => Self::Sha1(v.try_into().expect("prior length validation")),	175	20 => Self::Sha1(v.try_into().expect("prior length validation")),
176	other => panic!("BUG: unsupported hash len: {}", other),	176	other => panic!("BUG: unsupported hash len: {other}"),
177	}	177	}
178	}	178	}
179	}	179	}

git-hash/src/oid.rs+1−1

@@ -180,7 +180,7 @@ impl<'a> From<&'a [u8; SIZE_OF_SHA1_DIGEST]> for &'a oid { · 179 unmodified lines
180	impl fmt::Display for &oid {	180	impl fmt::Display for &oid {
181	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {	181	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
182	for b in self.as_bytes() {	182	for b in self.as_bytes() {
183	write!(f, "{:02x}", b)?;	183	write!(f, "{b:02x}")?;
184	}	184	}
185	Ok(())	185	Ok(())
186	}	186	}

git-hash/tests/prefix/mod.rs+1−1

@@ -47,7 +47,7 @@ mod new { · 46 unmodified lines
47	let num_of_zeros = oid.kind().len_in_hex() - hex_len;	47	let num_of_zeros = oid.kind().len_in_hex() - hex_len;
48	expected.extend(std::iter::repeat('0').take(num_of_zeros));	48	expected.extend(std::iter::repeat('0').take(num_of_zeros));
49	let prefix = git_hash::Prefix::new(oid, hex_len).unwrap();	49	let prefix = git_hash::Prefix::new(oid, hex_len).unwrap();
50	assert_eq!(prefix.as_oid().to_hex().to_string(), expected, "{}", hex_len);	50	assert_eq!(prefix.as_oid().to_hex().to_string(), expected, "{hex_len}");
51	assert_eq!(prefix.hex_len(), hex_len);	51	assert_eq!(prefix.hex_len(), hex_len);
52	assert_eq!(prefix.cmp_oid(&oid), Ordering::Equal);	52	assert_eq!(prefix.cmp_oid(&oid), Ordering::Equal);
53	}	53	}

git-lock/src/backoff.rs+3−8

             }
             assert!(
                 actual * 1000 >= (expected - 1) * 750,
-                "value too small: {} < {}",
+                "value too small: {actual} < {expected}"
-                actual,
-                expected
             );
             assert!(
                 actual * 1000 <= (expected + 1) * 1250,
-                "value too big: {} > {}",
+                "value too big: {actual} > {expected}"
-                actual,
-                expected
             );
         }
         assert!(
             num_identities < EXPECTED_TILL_SECOND.len(),
-            "too many untransformed values: {}",
+            "too many untransformed values: {num_identities}"
-            num_identities
         );
     }

git-object/tests/object.rs+1−2

@@ -33,8 +33,7 @@ fn size_in_memory() { · 32 unmodified lines
33	let actual = std::mem::size_of::<git_object::Object>();	33	let actual = std::mem::size_of::<git_object::Object>();
34	assert!(	34	assert!(
35	actual <= 264,	35	actual <= 264,
36	"{} <= 264: Prevent unexpected growth of what should be lightweight objects",	36	"{actual} <= 264: Prevent unexpected growth of what should be lightweight objects"
37	actual
38	)	37	)
39	}	38	}
40		39

git-odb/src/store_impls/dynamic/find.rs+2−2

@@ -70,7 +70,7 @@ pub(crate) mod error { · 69 unmodified lines
70	#[test]	70	#[test]
71	fn error_size() {	71	fn error_size() {
72	let actual = std::mem::size_of::<Error>();	72	let actual = std::mem::size_of::<Error>();
73	assert!(actual <= 88, "{} <= 88: should not grow without us noticing", actual);	73	assert!(actual <= 88, "{actual} <= 88: should not grow without us noticing");
74	}	74	}
75	}	75	}
76	}	76	}
@@ -219,7 +219,7 @@ where · 142 unmodified lines
219	}	219	}
220		220
221	out.unwrap_or_else(\|\| {	221	out.unwrap_or_else(\|\| {
222	panic!("could not find object {} in any index after looking up one of its base objects {}", id, base_id)	222	panic!("could not find object {id} in any index after looking up one of its base objects {base_id}" )
223	})	223	})
224	}	224	}
225	};	225	};

git-odb/src/store_impls/dynamic/header.rs+1−1

@@ -119,7 +119,7 @@ where · 118 unmodified lines
119	}	119	}
120		120
121	out.unwrap_or_else(\|\| {	121	out.unwrap_or_else(\|\| {
122	panic!("could not find object {} in any index after looking up one of its base objects {}", id, base_id)	122	panic!("could not find object {id} in any index after looking up one of its base objects {base_id}")
123	})	123	})
124	}	124	}
125	};	125	};

git-pack/src/cache/delta/traverse/mod.rs+1−1

@@ -143,7 +143,7 @@ where · 142 unmodified lines
143	(	143	(
144	Vec::<u8>::with_capacity(4096),	144	Vec::<u8>::with_capacity(4096),
145	lock(&object_progress)	145	lock(&object_progress)
146	.add_child_with_id(format!("thread {}", thread_index), git_features::progress::UNKNOWN),	146	.add_child_with_id(format!("thread {thread_index}"), git_features::progress::UNKNOWN),
147	new_thread_state(),	147	new_thread_state(),
148	resolve.clone(),	148	resolve.clone(),
149	inspect_object.clone(),	149	inspect_object.clone(),

git-pack/src/cache/lru.rs+2−2

@@ -40,7 +40,7 @@ mod memory { · 39 unmodified lines
40	.with_scale(CustomScale),	40	.with_scale(CustomScale),
41	),	41	),
42	free_list: Vec::new(),	42	free_list: Vec::new(),
43	debug: git_features::cache::Debug::new(format!("MemoryCappedHashmap({}B)", memory_cap_in_bytes)),	43	debug: git_features::cache::Debug::new(format!("MemoryCappedHashmap({memory_cap_in_bytes}B)")),
44	}	44	}
45	}	45	}
46	}	46	}
@@ -113,7 +113,7 @@ mod _static { · 66 unmodified lines
113	StaticLinkedList {	113	StaticLinkedList {
114	inner: Default::default(),	114	inner: Default::default(),
115	free_list: Vec::new(),	115	free_list: Vec::new(),
116	debug: git_features::cache::Debug::new(format!("StaticLinkedList<{}>", SIZE)),	116	debug: git_features::cache::Debug::new(format!("StaticLinkedList<{SIZE}>")),
117	}	117	}
118	}	118	}
119	}	119	}

git-pack/src/cache/object.rs+1−1

@@ -49,7 +49,7 @@ mod memory { · 48 unmodified lines
49	.with_scale(CustomScale),	49	.with_scale(CustomScale),
50	),	50	),
51	free_list: Vec::new(),	51	free_list: Vec::new(),
52	debug: git_features::cache::Debug::new(format!("MemoryCappedObjectHashmap({}B)", memory_cap_in_bytes)),	52	debug: git_features::cache::Debug::new(format!("MemoryCappedObjectHashmap({memory_cap_in_bytes}B)")),
53	}	53	}
54	}	54	}
55	}	55	}

git-pack/src/data/file/init.rs+1−2

         let pack_len = data.len();
         if pack_len < N32_SIZE * 3 + hash_len {
             return Err(data::header::decode::Error::Corrupt(format!(
-                "Pack data of size {} is too small for even an empty pack with shortest hash",
+                "Pack data of size {pack_len} is too small for even an empty pack with shortest hash"
-                pack_len
             )));
         }
         let (kind, num_objects) =

git-pack/src/data/input/entries_to_bytes.rs+2−2

@@ -90,11 +90,11 @@ where · 89 unmodified lines
90	} else {	90	} else {
91	header_bytes.len() as u64	91	header_bytes.len() as u64
92	};	92	};
93	self.output.seek(std::io::SeekFrom::Start(0))?;	93	self.output.rewind()?;
94	self.output.write_all(&header_bytes[..])?;	94	self.output.write_all(&header_bytes[..])?;
95	self.output.flush()?;	95	self.output.flush()?;
96		96
97	self.output.seek(std::io::SeekFrom::Start(0))?;	97	self.output.rewind()?;
98	let interrupt_never = std::sync::atomic::AtomicBool::new(false);	98	let interrupt_never = std::sync::atomic::AtomicBool::new(false);
99	let digest = hash::bytes(	99	let digest = hash::bytes(
100	&mut self.output,	100	&mut self.output,

git-pack/src/data/output/count/objects/mod.rs+1−1

@@ -79,7 +79,7 @@ where · 78 unmodified lines
79	{	79	{
80	let mut p = progress	80	let mut p = progress
81	.lock()	81	.lock()
82	.add_child_with_id(format!("thread {}", n), git_features::progress::UNKNOWN);	82	.add_child_with_id(format!("thread {n}"), git_features::progress::UNKNOWN);
83	p.init(None, git_features::progress::count("objects"));	83	p.init(None, git_features::progress::count("objects"));
84	p	84	p
85	},	85	},

git-pack/src/data/output/entry/iter_from_counts.rs+1−1

@@ -143,7 +143,7 @@ pub(crate) mod function { · 142 unmodified lines
143	Vec::new(), // object data buffer	143	Vec::new(), // object data buffer
144	progress	144	progress
145	.lock()	145	.lock()
146	.add_child_with_id(format!("thread {}", n), git_features::progress::UNKNOWN),	146	.add_child_with_id(format!("thread {n}"), git_features::progress::UNKNOWN),
147	)	147	)
148	}	148	}
149	},	149	},

git-pack/src/index/init.rs+1−1

@@ -40,7 +40,7 @@ impl index::File { · 39 unmodified lines
40	let footer_size = hash_len * 2;	40	let footer_size = hash_len * 2;
41	if idx_len < FAN_LEN * N32_SIZE + footer_size {	41	if idx_len < FAN_LEN * N32_SIZE + footer_size {
42	return Err(Error::Corrupt {	42	return Err(Error::Corrupt {
43	message: format!("Pack index of size {} is too small for even an empty index", idx_len),	43	message: format!("Pack index of size {idx_len} is too small for even an empty index"),
44	});	44	});
45	}	45	}
46	let (kind, fan, num_objects) = {	46	let (kind, fan, num_objects) = {

git-pack/src/index/traverse/reduce.rs+1−1

@@ -76,7 +76,7 @@ where · 75 unmodified lines
76	fn feed(&mut self, input: Self::Input) -> Result<(), Self::Error> {	76	fn feed(&mut self, input: Self::Input) -> Result<(), Self::Error> {
77	let chunk_stats: Vec<_> = match input {	77	let chunk_stats: Vec<_> = match input {
78	Err(err @ traverse::Error::PackDecode { .. }) if !self.check.fatal_decode_error() => {	78	Err(err @ traverse::Error::PackDecode { .. }) if !self.check.fatal_decode_error() => {
79	lock(&self.progress).info(format!("Ignoring decode error: {}", err));	79	lock(&self.progress).info(format!("Ignoring decode error: {err}"));
80	return Ok(());	80	return Ok(());
81	}	81	}
82	res => res,	82	res => res,

git-pack/src/index/traverse/with_index.rs+1−1

@@ -150,7 +150,7 @@ impl index::File { · 149 unmodified lines
150	);	150	);
151	match result {	151	match result {
152	Err(err @ Error::PackDecode { .. }) if !check.fatal_decode_error() => {	152	Err(err @ Error::PackDecode { .. }) if !check.fatal_decode_error() => {
153	progress.info(format!("Ignoring decode error: {}", err));	153	progress.info(format!("Ignoring decode error: {err}"));
154	Ok(())	154	Ok(())
155	}	155	}
156	res => res,	156	res => res,

git-pack/src/index/traverse/with_lookup.rs+2−2

@@ -136,7 +136,7 @@ impl index::File { · 135 unmodified lines
136	new_processor(),	136	new_processor(),
137	Vec::with_capacity(2048), // decode buffer	137	Vec::with_capacity(2048), // decode buffer
138	lock(&reduce_progress)	138	lock(&reduce_progress)
139	.add_child_with_id(format!("thread {}", index), git_features::progress::UNKNOWN), // per thread progress	139	.add_child_with_id(format!("thread {index}"), git_features::progress::UNKNOWN), // per thread progress
140	)	140	)
141	}	141	}
142	};	142	};
@@ -171,7 +171,7 @@ impl index::File { · 28 unmodified lines
171	progress.inc();	171	progress.inc();
172	let stat = match result {	172	let stat = match result {
173	Err(err @ Error::PackDecode { .. }) if !check.fatal_decode_error() => {	173	Err(err @ Error::PackDecode { .. }) if !check.fatal_decode_error() => {
174	progress.info(format!("Ignoring decode error: {}", err));	174	progress.info(format!("Ignoring decode error: {err}"));
175	continue;	175	continue;
176	}	176	}
177	res => res,	177	res => res,

git-pack/src/index/write/mod.rs+1−2

         }
         if num_objects != anticipated_num_objects {
             objects_progress.info(format!(
-                "{} objects were resolved into {} objects during thin-pack resolution",
+                "{anticipated_num_objects} objects were resolved into {num_objects} objects during thin-pack resolution"
-                anticipated_num_objects, num_objects
             ));
         }
         let num_objects: u32 = num_objects

git-path/tests/convert/normalize.rs+1−2

         assert_eq!(
             normalize(path, cwd).unwrap_or_else(|| panic!("{path:?}")),
             Cow::Borrowed(p(expected)),
-            "'{}' got an unexpected result",
+            "'{input}' got an unexpected result"
-            input
         );
     }
 }

git-pathspec/tests/pathspec.rs+18−60

         fn empty_input() {
             let input = "";
-            assert!(
+            assert!(!check_against_baseline(input), "This pathspec is valid in git: {input}");
-                !check_against_baseline(input),
-                "This pathspec is valid in git: {}",
-                input
-            );
             let output = git_pathspec::parse(input.as_bytes());
             assert!(output.is_err());
             ];
             for input in inputs.into_iter() {
-                assert!(
+                assert!(!check_against_baseline(input), "This pathspec is valid in git: {input}");
-                    !check_against_baseline(input),
-                    "This pathspec is valid in git: {}",
-                    input
-                );
                 let output = git_pathspec::parse(input.as_bytes());
                 assert!(output.is_err());
             ];
             for input in inputs.into_iter() {
-                assert!(
+                assert!(!check_against_baseline(input), "This pathspec is valid in git: {input}");
-                    !check_against_baseline(input),
-                    "This pathspec is valid in git: {}",
-                    input
-                );
                 let output = git_pathspec::parse(input.as_bytes());
                 assert!(output.is_err());
             ];
             for input in inputs {
-                assert!(
+                assert!(!check_against_baseline(input), "This pathspec is valid in git: {input}");
-                    !check_against_baseline(input),
-                    "This pathspec is valid in git: {}",
-                    input
-                );
                 let output = git_pathspec::parse(input.as_bytes());
-                assert!(output.is_err(), "This pathspec did not produce an error {}", input);
+                assert!(output.is_err(), "This pathspec did not produce an error {input}");
                 assert!(matches!(output.unwrap_err(), Error::InvalidAttribute { .. }));
             }
         }
             ];
             for input in inputs {
-                assert!(
+                assert!(!check_against_baseline(input), "This pathspec is valid in git: {input}");
-                    !check_against_baseline(input),
-                    "This pathspec is valid in git: {}",
-                    input
-                );
                 let output = git_pathspec::parse(input.as_bytes());
-                assert!(output.is_err(), "This pathspec did not produce an error {}", input);
+                assert!(output.is_err(), "This pathspec did not produce an error {input}");
                 assert!(
                     matches!(output.unwrap_err(), Error::InvalidAttributeValue { .. }),
-                    "Errors did not match for pathspec: {}",
+                    "Errors did not match for pathspec: {input}"
-                    input
                 );
             }
         }
             ];
             for input in inputs {
-                assert!(
+                assert!(!check_against_baseline(input), "This pathspec is valid in git: {input}");
-                    !check_against_baseline(input),
-                    "This pathspec is valid in git: {}",
-                    input
-                );
                 let output = git_pathspec::parse(input.as_bytes());
-                assert!(output.is_err(), "This pathspec did not produce an error {}", input);
+                assert!(output.is_err(), "This pathspec did not produce an error {input}");
                 assert!(matches!(output.unwrap_err(), Error::TrailingEscapeCharacter));
             }
         }
         fn empty_attribute_specification() {
             let input = ":(attr:)";
-            assert!(
+            assert!(!check_against_baseline(input), "This pathspec is valid in git: {input}");
-                !check_against_baseline(input),
-                "This pathspec is valid in git: {}",
-                input
-            );
             let output = git_pathspec::parse(input.as_bytes());
             assert!(output.is_err());
         fn multiple_attribute_specifications() {
             let input = ":(attr:one,attr:two)some/path";
-            assert!(
+            assert!(!check_against_baseline(input), "This pathspec is valid in git: {input}");
-                !check_against_baseline(input),
-                "This pathspec is valid in git: {}",
-                input
-            );
             let output = git_pathspec::parse(input.as_bytes());
             assert!(output.is_err());
         fn missing_parentheses() {
             let input = ":(top";
-            assert!(
+            assert!(!check_against_baseline(input), "This pathspec is valid in git: {input}");
-                !check_against_baseline(input),
-                "This pathspec is valid in git: {}",
-                input
-            );
             let output = git_pathspec::parse(input.as_bytes());
             assert!(output.is_err());
         fn glob_and_literal_keywords_present() {
             let input = ":(glob,literal)some/path";
-            assert!(
+            assert!(!check_against_baseline(input), "This pathspec is valid in git: {input}");
-                !check_against_baseline(input),
-                "This pathspec is valid in git: {}",
-                input
-            );
             let output = git_pathspec::parse(input.as_bytes());
             assert!(output.is_err());
         for (input, expected) in inputs.into_iter() {
             assert!(
                 check_against_baseline(input),
-                "This pathspec is invalid in git: {}",
+                "This pathspec is invalid in git: {input}"
-                input
             );
             let pattern: PatternForTesting = git_pathspec::parse(input.as_bytes())
-                .unwrap_or_else(|_| panic!("parsing should not fail with pathspec {}", input))
+                .unwrap_or_else(|_| panic!("parsing should not fail with pathspec {input}"))
                 .into();
-            assert_eq!(pattern, expected, "while checking input: \"{}\"", input);
+            assert_eq!(pattern, expected, "while checking input: \"{input}\"");
         }
     }
         let key: &BStr = pathspec.into();
         let base = BASELINE
             .get(key)
-            .unwrap_or_else(|| panic!("missing baseline for pathspec: {:?}", pathspec));
+            .unwrap_or_else(|| panic!("missing baseline for pathspec: {pathspec:?}"));
         *base == 0
     }
 }

git-protocol/src/command/tests.rs+2−2

@@ -1,6 +1,6 @@
1	mod v1 {	1	mod v1 {
2	fn capabilities(input: &str) -> git_transport::client::Capabilities {	2	fn capabilities(input: &str) -> git_transport::client::Capabilities {
3	git_transport::client::Capabilities::from_bytes(format!("\0{}", input).as_bytes())	3	git_transport::client::Capabilities::from_bytes(format!("\0{input}").as_bytes())
4	.expect("valid input capabilities")	4	.expect("valid input capabilities")
5	.0	5	.0
6	}	6	}
@@ -54,7 +54,7 @@ mod v2 { · 47 unmodified lines
54	use git_transport::client::Capabilities;	54	use git_transport::client::Capabilities;
55		55
56	fn capabilities(command: &str, input: &str) -> Capabilities {	56	fn capabilities(command: &str, input: &str) -> Capabilities {
57	Capabilities::from_lines(format!("version 2\n{}={}", command, input).into())	57	Capabilities::from_lines(format!("version 2\n{command}={input}").into())
58	.expect("valid input for V2 capabilities")	58	.expect("valid input for V2 capabilities")
59	}	59	}
60		60

git-protocol/src/fetch/arguments/mod.rs+2−2

@@ -157,7 +157,7 @@ impl Arguments { · 156 unmodified lines
157	}	157	}
158	}	158	}
159	fn prefixed(&mut self, prefix: &str, value: impl fmt::Display) {	159	fn prefixed(&mut self, prefix: &str, value: impl fmt::Display) {
160	self.args.push(format!("{}{}", prefix, value).into());	160	self.args.push(format!("{prefix}{value}").into());
161	}	161	}
162	/// Create a new instance to help setting up arguments to send to the server as part of a `fetch` operation	162	/// Create a new instance to help setting up arguments to send to the server as part of a `fetch` operation
163	/// for which `features` are the available and configured features to use.	163	/// for which `features` are the available and configured features to use.
@@ -181,7 +181,7 @@ impl Arguments { · 17 unmodified lines
181	let baked_features = features	181	let baked_features = features
182	.iter()	182	.iter()
183	.map(\|(n, v)\| match v {	183	.map(\|(n, v)\| match v {
184	Some(v) => format!("{}={}", n, v),	184	Some(v) => format!("{n}={v}"),
185	None => n.to_string(),	185	None => n.to_string(),
186	})	186	})
187	.collect::<Vec<_>>();	187	.collect::<Vec<_>>();

git-protocol/src/fetch_fn.rs+1−1

@@ -123,7 +123,7 @@ where · 122 unmodified lines
123	let mut round = 1;	123	let mut round = 1;
124	'negotiation: loop {	124	'negotiation: loop {
125	progress.step();	125	progress.step();
126	progress.set_name(format!("negotiate (round {})", round));	126	progress.set_name(format!("negotiate (round {round})"));
127	round += 1;	127	round += 1;
128	let action = delegate.negotiate(&refs, &mut arguments, previous_response.as_ref())?;	128	let action = delegate.negotiate(&refs, &mut arguments, previous_response.as_ref())?;
129	let mut reader = arguments.send(&mut transport, action == Action::Cancel).await?;	129	let mut reader = arguments.send(&mut transport, action == Action::Cancel).await?;

git-protocol/tests/fetch/response.rs+1−1

@@ -214,7 +214,7 @@ mod v2 { · 213 unmodified lines
214	fetch::response::Error::UploadPack(err) => {	214	fetch::response::Error::UploadPack(err) => {
215	assert_eq!(err.message, "segmentation fault\n")	215	assert_eq!(err.message, "segmentation fault\n")
216	}	216	}
217	err => panic!("we expect upload pack errors, got {:#?}", err),	217	err => panic!("we expect upload pack errors, got {err:#?}"),
218	},	218	},
219	}	219	}
220	}	220	}

git-protocol/tests/fetch/v1.rs+1−1

@@ -28,7 +28,7 @@ async fn clone() -> crate::Result { · 27 unmodified lines
28	"agent",	28	"agent",
29	)	29	)
30	.await?;	30	.await?;
31	assert_eq!(dlg.pack_bytes, 876, "{}: It be able to read pack bytes", fixture);	31	assert_eq!(dlg.pack_bytes, 876, "{fixture}: It be able to read pack bytes");
32	}	32	}
33	Ok(())	33	Ok(())
34	}	34	}

git-protocol/tests/fetch/v2.rs+1−1

@@ -140,7 +140,7 @@ async fn ls_remote_abort_in_prep_ls_refs() -> crate::Result { · 139 unmodified lines
140	assert_eq!(err.kind(), std::io::ErrorKind::Other);	140	assert_eq!(err.kind(), std::io::ErrorKind::Other);
141	assert_eq!(err.get_ref().expect("other error").to_string(), "hello world");	141	assert_eq!(err.get_ref().expect("other error").to_string(), "hello world");
142	}	142	}
143	err => panic!("should not have another error here, got: {}", err),	143	err => panic!("should not have another error here, got: {err}"),
144	}	144	}
145	Ok(())	145	Ok(())
146	}	146	}

git-ref/src/store/file/loose/reflog.rs+1−1

@@ -156,7 +156,7 @@ pub mod create_or_update { · 155 unmodified lines
156	.and_then(\|_\| committer.write_to(&mut file))	156	.and_then(\|_\| committer.write_to(&mut file))
157	.and_then(\|_\| {	157	.and_then(\|_\| {
158	if !message.is_empty() {	158	if !message.is_empty() {
159	writeln!(file, "\t{}", message)	159	writeln!(file, "\t{message}")
160	} else {	160	} else {
161	writeln!(file)	161	writeln!(file)
162	}	162	}

git-ref/src/store/file/transaction/prepare.rs+1−1

@@ -183,7 +183,7 @@ impl<'s, 'p> Transaction<'s, 'p> { · 182 unmodified lines
183	let mut lock = lock.take().map(Ok).unwrap_or_else(obtain_lock)?;	183	let mut lock = lock.take().map(Ok).unwrap_or_else(obtain_lock)?;
184		184
185	lock.with_mut(\|file\| match new {	185	lock.with_mut(\|file\| match new {
186	Target::Peeled(oid) => write!(file, "{}", oid),	186	Target::Peeled(oid) => write!(file, "{oid}"),
187	Target::Symbolic(name) => write!(file, "ref: {}", name.0),	187	Target::Symbolic(name) => write!(file, "ref: {}", name.0),
188	})?;	188	})?;
189	Some(lock.close()?)	189	Some(lock.close()?)

git-ref/src/store/packed/transaction.rs+5−5

@@ -81,7 +81,7 @@ impl packed::Transaction { · 80 unmodified lines
81	Some(kind) if kind == git_object::Kind::Tag => {	81	Some(kind) if kind == git_object::Kind::Tag => {
82	next_id = git_object::TagRefIter::from_bytes(&buf).target_id().map_err(\|_\| {	82	next_id = git_object::TagRefIter::from_bytes(&buf).target_id().map_err(\|_\| {
83	prepare::Error::Resolve(	83	prepare::Error::Resolve(
84	format!("Couldn't get target object id from tag {}", next_id).into(),	84	format!("Couldn't get target object id from tag {next_id}").into(),
85	)	85	)
86	})?;	86	})?;
87	}	87	}
@@ -90,7 +90,7 @@ impl packed::Transaction { · 2 unmodified lines
90	}	90	}
91	None => {	91	None => {
92	return Err(prepare::Error::Resolve(	92	return Err(prepare::Error::Resolve(
93	format!("Couldn't find object with id {}", next_id).into(),	93	format!("Couldn't find object with id {next_id}").into(),
94	))	94	))
95	}	95	}
96	}	96	}
@@ -194,7 +194,7 @@ fn write_packed_ref(mut out: impl std::io::Write, pref: packed::Reference<'_>) - · 97 unmodified lines
194	out.write_all(pref.name.as_bstr())?;	194	out.write_all(pref.name.as_bstr())?;
195	out.write_all(b"\n")?;	195	out.write_all(b"\n")?;
196	if let Some(object) = pref.object {	196	if let Some(object) = pref.object {
197	writeln!(out, "^{}", object)?;	197	writeln!(out, "^{object}")?;
198	}	198	}
199	Ok(())	199	Ok(())
200	}	200	}
@@ -206,11 +206,11 @@ fn write_edit(mut out: impl std::io::Write, edit: &Edit, lines_written: &mut i32 · 5 unmodified lines
206	new: Target::Peeled(target_oid),	206	new: Target::Peeled(target_oid),
207	..	207	..
208	} => {	208	} => {
209	write!(out, "{} ", target_oid)?;	209	write!(out, "{target_oid} ")?;
210	out.write_all(edit.inner.name.as_bstr())?;	210	out.write_all(edit.inner.name.as_bstr())?;
211	out.write_all(b"\n")?;	211	out.write_all(b"\n")?;
212	if let Some(object) = edit.peeled {	212	if let Some(object) = edit.peeled {
213	writeln!(out, "^{}", object)?;	213	writeln!(out, "^{object}")?;
214	}	214	}
215	*lines_written += 1;	215	*lines_written += 1;
216	}	216	}

git-ref/src/transaction/ext.rs+2−5

         self.assure_one_name_has_one_edit().map_err(|name| {
             std::io::Error::new(
                 std::io::ErrorKind::AlreadyExists,
-                format!("A reference named '{}' has multiple edits", name),
+                format!("A reference named '{name}' has multiple edits"),
             )
         })
     }
             if round == 5 {
                 break Err(std::io::Error::new(
                     std::io::ErrorKind::WouldBlock,
-                    format!(
+                    format!("Could not follow all splits after {round} rounds, assuming reference cycle"),
-                        "Could not follow all splits after {} rounds, assuming reference cycle",
-                        round
-                    ),
                 ));
             }
             round += 1;

git-ref/tests/file/store/find.rs+1−1

@@ -109,7 +109,7 @@ mod loose { · 108 unmodified lines
109	Err(git_ref::file::find::existing::Error::NotFound { name }) => {	109	Err(git_ref::file::find::existing::Error::NotFound { name }) => {
110	assert_eq!(name, Path::new(*partial_name));	110	assert_eq!(name, Path::new(*partial_name));
111	}	111	}
112	Err(err) => panic!("Unexpected err: {:?}", err),	112	Err(err) => panic!("Unexpected err: {err:?}"),
113	},	113	},
114	}	114	}
115	}	115	}

git-ref/tests/file/store/iter.rs+1−1

@@ -302,7 +302,7 @@ fn loose_iter_with_broken_refs() -> crate::Result { · 301 unmodified lines
302	"tags/t1"	302	"tags/t1"
303	]	303	]
304	.into_iter()	304	.into_iter()
305	.map(\|p\| format!("refs/{}", p))	305	.map(\|p\| format!("refs/{p}"))
306	.collect::<Vec<_>>(),	306	.collect::<Vec<_>>(),
307	"all paths are as expected"	307	"all paths are as expected"
308	);	308	);

git-ref/tests/file/transaction/prepare_and_commit/create_or_update/collisions.rs+1−4

     match res {
         Ok(_) if case_sensitive => {}
         Ok(_) if !case_sensitive => panic!("should fail as 'a' and 'A' clash"),
-        Err(err) if case_sensitive => panic!(
+        Err(err) if case_sensitive => panic!("should work as case sensitivity allows 'a' and 'A' to coexist: {err:?}"),
-            "should work as case sensitivity allows 'a' and 'A' to coexist: {:?}",
-            err
-        ),
         Err(err) if !case_sensitive => {
             assert_eq!(err.to_string(), "A lock could not be obtained for reference \"refs/A\"")
         }

git-refspec/tests/matching/mod.rs+7−14

                 Err(e) if e.to_string() == err => {
                     saw_err = true;
                 }
-                Err(err) => panic!("Unexpected parse error: {:?}", err),
+                Err(err) => panic!("Unexpected parse error: {err:?}"),
             }
         }
-        assert!(saw_err, "Failed to see error when parsing specs: {:?}", err)
+        assert!(saw_err, "Failed to see error when parsing specs: {err:?}")
     }
     /// Here we checked by hand which refs are actually written with a particular refspec
         let key: Vec<_> = specs.into_iter().map(BString::from).collect();
         let expected = BASELINE
             .get(&key)
-            .unwrap_or_else(|| panic!("BUG: Need {:?} added to the baseline", key))
+            .unwrap_or_else(|| panic!("BUG: Need {key:?} added to the baseline"))
             .as_ref();
         let actual = match_group.match_remotes(input()).validated();
         assert_eq!(
             actual.len(),
             expected.len(),
-            "got a different amount of mappings: {:?} != {:?}",
+            "got a different amount of mappings: {actual:?} != {expected:?}"
-            actual,
-            expected
         );
         for (idx, (actual, expected)) in actual.iter().zip(expected).enumerate() {
-            assert_eq!(
+            assert_eq!(source_to_bstring(actual.lhs), expected.remote, "{idx}: remote mismatch");
-                source_to_bstring(actual.lhs),
-                expected.remote,
-                "{}: remote mismatch",
-                idx
-            );
             if let Some(expected) = expected.local.as_ref() {
                 match actual.rhs.as_ref() {
-                    None => panic!("{}: Expected local ref to be {}, got none", idx, expected),
+                    None => panic!("{idx}: Expected local ref to be {expected}, got none"),
-                    Some(actual) => assert_eq!(actual.as_ref(), expected, "{}: mismatched local ref", idx),
+                    Some(actual) => assert_eq!(actual.as_ref(), expected, "{idx}: mismatched local ref"),
                 }
             }
         }

git-repository/src/clone/fetch/util.rs+1−0

@@ -12,6 +12,7 @@ use crate::{ · 11 unmodified lines
12	Repository,	12	Repository,
13	};	13	};
14		14
		15	#[allow(clippy::result_large_err)]
15	pub fn write_remote_to_local_config_file(	16	pub fn write_remote_to_local_config_file(
16	remote: &mut crate::Remote<'_>,	17	remote: &mut crate::Remote<'_>,
17	remote_name: BString,	18	remote_name: BString,

git-repository/src/clone/mod.rs+1−0

@@ -1,3 +1,4 @@
		1	#![allow(clippy::result_large_err)]
1	use std::convert::TryInto;	2	use std::convert::TryInto;
2		3
3	use crate::bstr::BString;	4	use crate::bstr::BString;

git-repository/src/config/cache/access.rs+1−0

@@ -1,3 +1,4 @@
		1	#![allow(clippy::result_large_err)]
1	use std::{borrow::Cow, path::PathBuf, time::Duration};	2	use std::{borrow::Cow, path::PathBuf, time::Duration};
2		3
3	use git_lock::acquire::Fail;	4	use git_lock::acquire::Fail;

git-repository/src/config/cache/incubate.rs+1−0

@@ -1,3 +1,4 @@
		1	#![allow(clippy::result_large_err)]
1	use super::{util, Error};	2	use super::{util, Error};
2	use crate::config::tree::{Core, Extensions};	3	use crate::config::tree::{Core, Extensions};
3		4

git-repository/src/config/cache/init.rs+1−0

@@ -1,3 +1,4 @@
		1	#![allow(clippy::result_large_err)]
1	use std::borrow::Cow;	2	use std::borrow::Cow;
2		3
3	use git_sec::Permission;	4	use git_sec::Permission;

git-repository/src/config/cache/util.rs+2−1

+#![allow(clippy::result_large_err)]
 use super::Error;
 use crate::{
     config,
     lenient_config: bool,
 ) -> Result<Option<ObjectKindHint>, config::key::GenericErrorWithValue> {
     match config.string_by_key("core.disambiguate") {
-        None => return Ok(None),
+        None => Ok(None),
         Some(value) => Core::DISAMBIGUATE
             .try_into_object_kind_hint(value)
             .with_leniency(lenient_config),

git-repository/src/config/mod.rs+1−1

@@ -124,7 +124,7 @@ pub mod protocol { · 123 unmodified lines
124	/// The error returned when obtaining the permission for a particular scheme.	124	/// The error returned when obtaining the permission for a particular scheme.
125	#[derive(Debug, thiserror::Error)]	125	#[derive(Debug, thiserror::Error)]
126	#[allow(missing_docs)]	126	#[allow(missing_docs)]
127	#[error("The value {value:?} must be allow\|deny\|user in configuration key protocol{0}.allow", scheme.as_ref().map(\|s\| format!(".{}", s)).unwrap_or_default())]	127	#[error("The value {value:?} must be allow\|deny\|user in configuration key protocol{0}.allow", scheme.as_ref().map(\|s\| format!(".{s}")).unwrap_or_default())]
128	pub struct Error {	128	pub struct Error {
129	pub scheme: Option<String>,	129	pub scheme: Option<String>,
130	pub value: BString,	130	pub value: BString,

git-repository/src/config/snapshot/access.rs+1−0

@@ -1,3 +1,4 @@
		1	#![allow(clippy::result_large_err)]
1	use std::borrow::Cow;	2	use std::borrow::Cow;
2		3
3	use git_features::threading::OwnShared;	4	use git_features::threading::OwnShared;

git-repository/src/config/tree/keys.rs+2−0

+#![allow(clippy::result_large_err)]
 use std::{
     borrow::Cow,
     error::Error,
         }
         /// Try to validate `name` as symbolic remote name and return it.
+        #[allow(clippy::result_large_err)]
         pub fn try_into_symbolic_name(
             &'static self,
             name: Cow<'_, BStr>,

git-repository/src/config/tree/sections/core.rs+1−1

@@ -115,7 +115,7 @@ mod disambiguate { · 114 unmodified lines
115		115
116	impl Disambiguate {	116	impl Disambiguate {
117	/// Convert a disambiguation marker into the respective enum.	117	/// Convert a disambiguation marker into the respective enum.
118	pub fn try_into_object_kind_hint<'a>(	118	pub fn try_into_object_kind_hint(
119	&'static self,	119	&'static self,
120	value: Cow<'_, BStr>,	120	value: Cow<'_, BStr>,
121	) -> Result<Option<ObjectKindHint>, config::key::GenericErrorWithValue> {	121	) -> Result<Option<ObjectKindHint>, config::key::GenericErrorWithValue> {

git-repository/src/discover.rs+1−0

@@ -1,3 +1,4 @@
		1	#![allow(clippy::result_large_err)]
1	use std::path::Path;	2	use std::path::Path;
2		3
3	pub use git_discover::*;	4	pub use git_discover::*;

git-repository/src/init.rs+1−0

@@ -1,3 +1,4 @@
		1	#![allow(clippy::result_large_err)]
1	use std::{borrow::Cow, convert::TryInto, path::Path};	2	use std::{borrow::Cow, convert::TryInto, path::Path};
2		3
3	use git_ref::{	4	use git_ref::{

git-repository/src/lib.rs+5−0

 }
 /// See [ThreadSafeRepository::discover()], but returns a [`Repository`] instead.
+#[allow(clippy::result_large_err)]
 pub fn discover(directory: impl AsRef<std::path::Path>) -> Result<Repository, discover::Error> {
     ThreadSafeRepository::discover(directory).map(Into::into)
 }
 /// See [ThreadSafeRepository::init()], but returns a [`Repository`] instead.
+#[allow(clippy::result_large_err)]
 pub fn init(directory: impl AsRef<std::path::Path>) -> Result<Repository, init::Error> {
     ThreadSafeRepository::init(directory, create::Kind::WithWorktree, create::Options::default()).map(Into::into)
 }
 /// See [ThreadSafeRepository::init()], but returns a [`Repository`] instead.
+#[allow(clippy::result_large_err)]
 pub fn init_bare(directory: impl AsRef<std::path::Path>) -> Result<Repository, init::Error> {
     ThreadSafeRepository::init(directory, create::Kind::Bare, create::Options::default()).map(Into::into)
 }
 }
 /// See [ThreadSafeRepository::open()], but returns a [`Repository`] instead.
+#[allow(clippy::result_large_err)]
 pub fn open(directory: impl Into<std::path::PathBuf>) -> Result<Repository, open::Error> {
     ThreadSafeRepository::open(directory).map(Into::into)
 }
 /// See [ThreadSafeRepository::open_opts()], but returns a [`Repository`] instead.
+#[allow(clippy::result_large_err)]
 pub fn open_opts(directory: impl Into<std::path::PathBuf>, options: open::Options) -> Result<Repository, open::Error> {
     ThreadSafeRepository::open_opts(directory, options).map(Into::into)
 }

git-repository/src/open/mod.rs+1−3

         let limit = 160;
         assert!(
             actual <= limit,
-            "{} <= {}: size shouldn't change without us knowing (on windows, it's bigger)",
+            "{actual} <= {limit}: size shouldn't change without us knowing (on windows, it's bigger)"
-            actual,
-            limit
         );
     }
 }

git-repository/src/open/options.rs+1−0

@@ -140,6 +140,7 @@ impl Options { · 139 unmodified lines
140	}	140	}
141		141
142	/// Open a repository at `path` with the options set so far.	142	/// Open a repository at `path` with the options set so far.
		143	#[allow(clippy::result_large_err)]
143	pub fn open(self, path: impl Into<PathBuf>) -> Result<ThreadSafeRepository, Error> {	144	pub fn open(self, path: impl Into<PathBuf>) -> Result<ThreadSafeRepository, Error> {
144	ThreadSafeRepository::open_opts(path, self)	145	ThreadSafeRepository::open_opts(path, self)
145	}	146	}

git-repository/src/open/repository.rs+1−0

@@ -1,3 +1,4 @@
		1	#![allow(clippy::result_large_err)]
1	use std::{borrow::Cow, path::PathBuf};	2	use std::{borrow::Cow, path::PathBuf};
2		3
3	use git_features::threading::OwnShared;	4	use git_features::threading::OwnShared;

git-repository/src/reference/edits.rs+1−0

@@ -27,6 +27,7 @@ pub mod set_target_id { · 26 unmodified lines
27	/// Furthermore, refrain from using this method for more than a one-off change as it creates a transaction for each invocation.	27	/// Furthermore, refrain from using this method for more than a one-off change as it creates a transaction for each invocation.
28	/// If multiple reference should be changed, use [Repository::edit_references()][crate::Repository::edit_references()]	28	/// If multiple reference should be changed, use [Repository::edit_references()][crate::Repository::edit_references()]
29	/// or the lower level reference database instead.	29	/// or the lower level reference database instead.
		30	#[allow(clippy::result_large_err)]
30	pub fn set_target_id(	31	pub fn set_target_id(
31	&mut self,	32	&mut self,
32	id: impl Into<git_hash::ObjectId>,	33	id: impl Into<git_hash::ObjectId>,

git-repository/src/remote/connect.rs+1−0

@@ -1,3 +1,4 @@
		1	#![allow(clippy::result_large_err)]
1	use git_protocol::transport::client::Transport;	2	use git_protocol::transport::client::Transport;
2		3
3	use crate::{remote::Connection, Progress, Remote};	4	use crate::{remote::Connection, Progress, Remote};

git-repository/src/remote/connection/fetch/mod.rs+1−1

@@ -32,7 +32,7 @@ pub enum RefLogMessage { · 31 unmodified lines
32	impl RefLogMessage {	32	impl RefLogMessage {
33	pub(crate) fn compose(&self, context: &str) -> BString {	33	pub(crate) fn compose(&self, context: &str) -> BString {
34	match self {	34	match self {
35	RefLogMessage::Prefixed { action } => format!("{}: {}", action, context).into(),	35	RefLogMessage::Prefixed { action } => format!("{action}: {context}").into(),
36	RefLogMessage::Override { message } => message.to_owned(),	36	RefLogMessage::Override { message } => message.to_owned(),
37	}	37	}
38	}	38	}

git-repository/src/remote/connection/fetch/receive_pack.rs+1−1

@@ -98,7 +98,7 @@ where · 97 unmodified lines
98		98
99	let reader = 'negotiation: loop {	99	let reader = 'negotiation: loop {
100	progress.step();	100	progress.step();
101	progress.set_name(format!("negotiate (round {})", round));	101	progress.set_name(format!("negotiate (round {round})"));
102		102
103	let is_done = match negotiate::one_round(	103	let is_done = match negotiate::one_round(
104	negotiate::Algorithm::Naive,	104	negotiate::Algorithm::Naive,

git-repository/src/remote/connection/fetch/update_refs/mod.rs+1−0

@@ -1,3 +1,4 @@
		1	#![allow(clippy::result_large_err)]
1	use std::{collections::BTreeMap, convert::TryInto, path::PathBuf};	2	use std::{collections::BTreeMap, convert::TryInto, path::PathBuf};
2		3
3	use git_odb::{Find, FindExt};	4	use git_odb::{Find, FindExt};

git-repository/src/remote/connection/fetch/update_refs/tests.rs+4−5

                     Change::Update { log, new, .. } => {
                         assert_eq!(
                             log.message,
-                            format!("action: {}", reflog_message),
+                            format!("action: {reflog_message}"),
-                            "{}: reflog messages are specific and we emulate git word for word",
+                            "{spec}: reflog messages are specific and we emulate git word for word"
-                            spec
                         );
                         let remote_ref = repo
                             .find_reference(specs[0].to_ref().source().expect("always present"))
             ("wt-c-locked", "wt-c-locked"),
             ("wt-deleted", "wt-deleted"),
         ] {
-            let spec = format!("refs/heads/main:refs/heads/{}", branch);
+            let spec = format!("refs/heads/main:refs/heads/{branch}");
             let (mappings, specs) = mapping_from_spec(&spec, &repo);
             let out = fetch::refs::update(
                 &repo,
                     },
                     edit_index: None,
                 }],
-                "{}: checked-out checks are done before checking if a change would actually be required (here it isn't)", spec
+                "{spec}: checked-out checks are done before checking if a change would actually be required (here it isn't)"
             );
             assert_eq!(out.edits.len(), 0);
         }

git-repository/src/remote/connection/fetch/update_refs/update.rs+1−1

@@ -81,7 +81,7 @@ impl std::fmt::Display for Mode { · 80 unmodified lines
81	Mode::Forced => "forced-update",	81	Mode::Forced => "forced-update",
82	Mode::New => "new",	82	Mode::New => "new",
83	Mode::ImplicitTagNotSentByRemote => "unrelated tag on remote",	83	Mode::ImplicitTagNotSentByRemote => "unrelated tag on remote",
84	Mode::RejectedSourceObjectNotFound { id } => return write!(f, "rejected ({} not found)", id),	84	Mode::RejectedSourceObjectNotFound { id } => return write!(f, "rejected ({id} not found)"),
85	Mode::RejectedTagUpdate => "rejected (would overwrite existing tag)",	85	Mode::RejectedTagUpdate => "rejected (would overwrite existing tag)",
86	Mode::RejectedNonFastForward => "rejected (non-fast-forward)",	86	Mode::RejectedNonFastForward => "rejected (non-fast-forward)",
87	Mode::RejectedSymbolic => "rejected (refusing to write symbolic refs)",	87	Mode::RejectedSymbolic => "rejected (refusing to write symbolic refs)",

git-repository/src/repository/config/transport.rs+4−3

+#![allow(clippy::result_large_err)]
 use std::any::Any;
 use crate::bstr::BStr;
                                         .with_leniency(lenient)
                                 },
                             )
-                            .map_err(|err| config::transport::http::Error::InvalidFollowRedirects(err))?
+                            .map_err(config::transport::http::Error::InvalidFollowRedirects)?
                     };
                     opts.low_speed_time_seconds = config
                         .map(|value| config::tree::Http::LOW_SPEED_TIME.try_into_u64(value))
                         .transpose()
                         .with_leniency(lenient)
-                        .map_err(|err| config::transport::http::Error::from(err))?
+                        .map_err(config::transport::http::Error::from)?
                         .unwrap_or_default();
                     opts.low_speed_limit_bytes_per_second = config
                         .integer_filter_by_key("http.lowSpeedLimit", &mut trusted_only)
                         .map(|value| config::tree::Http::LOW_SPEED_LIMIT.try_into_u32(value))
                         .transpose()
                         .with_leniency(lenient)
-                        .map_err(|err| config::transport::http::Error::from(err))?
+                        .map_err(config::transport::http::Error::from)?
                         .unwrap_or_default();
                     opts.proxy = proxy(
                         remote_name

git-repository/src/repository/object.rs+1−0

@@ -1,3 +1,4 @@
		1	#![allow(clippy::result_large_err)]
1	use std::convert::TryInto;	2	use std::convert::TryInto;
2		3
3	use git_hash::ObjectId;	4	use git_hash::ObjectId;

git-repository/src/repository/remote.rs+1−0

@@ -1,3 +1,4 @@
		1	#![allow(clippy::result_large_err)]
1	use std::convert::TryInto;	2	use std::convert::TryInto;
2		3
3	use crate::{bstr::BStr, config, remote, remote::find, Remote};	4	use crate::{bstr::BStr, config, remote, remote::find, Remote};

git-repository/src/repository/worktree.rs+1−0

@@ -33,6 +33,7 @@ impl crate::Repository { · 32 unmodified lines
33	///	33	///
34	/// Note that it might be the one that is currently open if this repository doesn't point to a linked worktree.	34	/// Note that it might be the one that is currently open if this repository doesn't point to a linked worktree.
35	/// Also note that the main repo might be bare.	35	/// Also note that the main repo might be bare.
		36	#[allow(clippy::result_large_err)]
36	pub fn main_repo(&self) -> Result<crate::Repository, crate::open::Error> {	37	pub fn main_repo(&self) -> Result<crate::Repository, crate::open::Error> {
37	crate::ThreadSafeRepository::open_opts(self.common_dir(), self.options.clone()).map(Into::into)	38	crate::ThreadSafeRepository::open_opts(self.common_dir(), self.options.clone()).map(Into::into)
38	}	39	}

git-repository/src/revision/spec/parse/error.rs+3−3

@@ -35,11 +35,11 @@ pub enum CandidateInfo { · 34 unmodified lines
35	impl std::fmt::Display for CandidateInfo {	35	impl std::fmt::Display for CandidateInfo {
36	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {	36	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
37	match self {	37	match self {
38	CandidateInfo::FindError { source } => write!(f, "lookup error: {}", source),	38	CandidateInfo::FindError { source } => write!(f, "lookup error: {source}"),
39	CandidateInfo::Tag { name } => write!(f, "tag {:?}", name),	39	CandidateInfo::Tag { name } => write!(f, "tag {name:?}"),
40	CandidateInfo::Object { kind } => std::fmt::Display::fmt(kind, f),	40	CandidateInfo::Object { kind } => std::fmt::Display::fmt(kind, f),
41	CandidateInfo::Commit { date, title } => {	41	CandidateInfo::Commit { date, title } => {
42	write!(f, "commit {} {:?}", date.format(git_date::time::format::SHORT), title)	42	write!(f, "commit {} {title:?}", date.format(git_date::time::format::SHORT))
43	}	43	}
44	}	44	}
45	}	45	}

git-repository/src/worktree/proxy.rs+1−0

@@ -1,3 +1,4 @@
		1	#![allow(clippy::result_large_err)]
1	use std::path::{Path, PathBuf};	2	use std::path::{Path, PathBuf};
2		3
3	use crate::{	4	use crate::{

git-repository/tests/util/mod.rs+1−0

@@ -1,3 +1,4 @@
		1	#![allow(clippy::result_large_err)]
1	use git_repository::{open, Repository, ThreadSafeRepository};	2	use git_repository::{open, Repository, ThreadSafeRepository};
2	use git_testtools::tempfile;	3	use git_testtools::tempfile;
3		4

git-revision/src/describe.rs+1−1

@@ -88,7 +88,7 @@ impl<'a> Display for Format<'a> { · 87 unmodified lines
88	}	88	}
89		89
90	if let Some(suffix) = &self.dirty_suffix {	90	if let Some(suffix) = &self.dirty_suffix {
91	write!(f, "-{}", suffix)?;	91	write!(f, "-{suffix}")?;
92	}	92	}
93	Ok(())	93	Ok(())
94	}	94	}

git-tempfile/examples/try-deadlock-on-cleanup.rs+3−4

                 );
             }
             if let Err(err) = tmp.close() {
-                eprintln!("Error when removing tempdir: {}", err);
+                eprintln!("Error when removing tempdir: {err}");
             }
             eprintln!(
-                "OK: survived {}s without deadlock with {} tempfiles created, lock obtained {} times, cleanup handler ran {} times",
+                "OK: survived {secs_to_run}s without deadlock with {} tempfiles created, lock obtained {} times, cleanup handler ran {} times",
-                secs_to_run,
                 tempfiles_created.load(Ordering::SeqCst),
                 tempfiles_registry_locked.load(Ordering::SeqCst),
                 signal_raised.load(Ordering::SeqCst)
 fn tempfile_for_thread_or_panic(tid: i32, tmp: &Path, count: &AtomicUsize) -> Handle<Writable> {
     let res = git_tempfile::writable_at(
-        tmp.join(format!("thread-{}", tid)),
+        tmp.join(format!("thread-{tid}")),
         ContainingDirectory::Exists,
         AutoRemove::Tempfile,
     )

git-tempfile/src/fs/create_dir.rs+1−2

                     retries,
                 } => write!(
                     f,
-                    "Permanently failing to create directory {:?} ({:?} of {:?})",
+                    "Permanently failing to create directory {dir:?} ({retries_left:?} of {retries:?})",
-                    dir, retries_left, retries
                 ),
             }
         }

git-tempfile/src/fs/remove_dir.rs+1−4

         if !target.starts_with(boundary) {
             return Err(std::io::Error::new(
                 std::io::ErrorKind::InvalidInput,
-                format!(
+                format!("Removal target {target:?} must be contained in boundary {boundary:?}"),
-                    "Removal target {:?} must be contained in boundary {:?}",
-                    target, boundary
-                ),
             ));
         }
         let cursor = if target == boundary {

git-transport/src/client/blocking_io/http/curl/remote.rs+1−1

@@ -54,7 +54,7 @@ impl Handler { · 53 unmodified lines
54	};	54	};
55	match Self::parse_status_inner(data) {	55	match Self::parse_status_inner(data) {
56	Ok(status) if !(200..=valid_end).contains(&status) => {	56	Ok(status) if !(200..=valid_end).contains(&status) => {
57	Some((status, format!("Received HTTP status {}", status).into()))	57	Some((status, format!("Received HTTP status {status}").into()))
58	}	58	}
59	Ok(_) => None,	59	Ok(_) => None,
60	Err(err) => Some((500, err)),	60	Err(err) => Some((500, err)),

git-transport/src/client/blocking_io/http/mod.rs+4−5

         }) {
             return Err(client::Error::Http(Error::Detail {
                 description: format!(
-                    "Didn't find '{}' header to indicate 'smart' protocol, and 'dumb' protocol is not supported.",
+                    "Didn't find '{wanted_content_type}' header to indicate 'smart' protocol, and 'dumb' protocol is not supported."
-                    wanted_content_type
                 ),
             }));
         }
             }
             headers.push(Cow::Owned(format!(
                 "Authorization: Basic {}",
-                base64::engine::general_purpose::STANDARD.encode(format!("{}:{}", username, password))
+                base64::engine::general_purpose::STANDARD.encode(format!("{username}:{password}"))
             )))
         }
         Ok(())
                 &extra_parameters
                     .iter()
                     .map(|(key, value)| match value {
-                        Some(value) => format!("{}={}", key, value),
+                        Some(value) => format!("{key}={value}"),
                         None => key.to_string(),
                     })
                     .collect::<Vec<_>>()
                     .join(":"),
             );
-            dynamic_headers.push(format!("Git-Protocol: {}", parameters).into());
+            dynamic_headers.push(format!("Git-Protocol: {parameters}").into());
         }
         self.add_basic_auth_if_present(&mut dynamic_headers)?;
         let GetResponse { headers, body } =

git-transport/src/client/blocking_io/ssh/program_kind.rs+1−1

@@ -40,7 +40,7 @@ impl ProgramKind { · 39 unmodified lines
40	.env("GIT_PROTOCOL", format!("version={}", desired_version as usize))	40	.env("GIT_PROTOCOL", format!("version={}", desired_version as usize))
41	}	41	}
42	if let Some(port) = url.port {	42	if let Some(port) = url.port {
43	prepare = prepare.arg(format!("-p{}", port));	43	prepare = prepare.arg(format!("-p{port}"));
44	}	44	}
45	}	45	}
46	ProgramKind::Plink \| ProgramKind::Putty \| ProgramKind::TortoisePlink => {	46	ProgramKind::Plink \| ProgramKind::Putty \| ProgramKind::TortoisePlink => {

git-transport/src/client/blocking_io/traits.rs+2−2

@@ -83,10 +83,10 @@ impl<T: Transport> TransportV2Ext for T { · 82 unmodified lines
83	arguments: Option<impl Iterator<Item = BString>>,	83	arguments: Option<impl Iterator<Item = BString>>,
84	) -> Result<Box<dyn ExtendedBufRead + Unpin + '_>, Error> {	84	) -> Result<Box<dyn ExtendedBufRead + Unpin + '_>, Error> {
85	let mut writer = self.request(WriteMode::OneLfTerminatedLinePerWriteCall, MessageKind::Flush)?;	85	let mut writer = self.request(WriteMode::OneLfTerminatedLinePerWriteCall, MessageKind::Flush)?;
86	writer.write_all(format!("command={}", command).as_bytes())?;	86	writer.write_all(format!("command={command}").as_bytes())?;
87	for (name, value) in capabilities {	87	for (name, value) in capabilities {
88	match value {	88	match value {
89	Some(value) => writer.write_all(format!("{}={}", name, value.as_ref()).as_bytes()),	89	Some(value) => writer.write_all(format!("{name}={}", value.as_ref()).as_bytes()),
90	None => writer.write_all(name.as_bytes()),	90	None => writer.write_all(name.as_bytes()),
91	}?;	91	}?;
92	}	92	}

git-transport/src/client/git/mod.rs+2−2

@@ -64,7 +64,7 @@ mod message { · 63 unmodified lines
64	out.extend_from_slice(host.as_bytes());	64	out.extend_from_slice(host.as_bytes());
65	if let Some(port) = port {	65	if let Some(port) = port {
66	out.push_byte(b':');	66	out.push_byte(b':');
67	out.push_str(&format!("{}", port));	67	out.push_str(&format!("{port}"));
68	}	68	}
69	out.push(0);	69	out.push(0);
70	}	70	}
@@ -87,7 +87,7 @@ mod message { · 16 unmodified lines
87	}	87	}
88	for (key, value) in extra_parameters {	88	for (key, value) in extra_parameters {
89	match value {	89	match value {
90	Some(value) => out.push_str(format!("{}={}", key, value)),	90	Some(value) => out.push_str(format!("{key}={value}")),
91	None => out.push_str(key),	91	None => out.push_str(key),
92	}	92	}
93	out.push(0);	93	out.push(0);

git-transport/tests/client/blocking_io/http/mod.rs+3−3

@@ -23,18 +23,18 @@ fn assert_error_status( · 22 unmodified lines
23	kind: std::io::ErrorKind,	23	kind: std::io::ErrorKind,
24	) -> Result<(mock::Server, http::Transport<http::Impl>), crate::Error> {	24	) -> Result<(mock::Server, http::Transport<http::Impl>), crate::Error> {
25	let (server, mut client) =	25	let (server, mut client) =
26	mock::serve_and_connect(&format!("http-{}.response", status), "path/not-important", Protocol::V1)?;	26	mock::serve_and_connect(&format!("http-{status}.response"), "path/not-important", Protocol::V1)?;
27	let error = client	27	let error = client
28	.handshake(Service::UploadPack, &[])	28	.handshake(Service::UploadPack, &[])
29	.err()	29	.err()
30	.expect("non-200 status causes error");	30	.expect("non-200 status causes error");
31	let error = error	31	let error = error
32	.source()	32	.source()
33	.unwrap_or_else(\|\| panic!("no source() in: {:?} ", error))	33	.unwrap_or_else(\|\| panic!("no source() in: {error:?} "))
34	.downcast_ref::<std::io::Error>()	34	.downcast_ref::<std::io::Error>()
35	.expect("io error as source");	35	.expect("io error as source");
36	assert_eq!(error.kind(), kind);	36	assert_eq!(error.kind(), kind);
37	let expected = format!("Received HTTP status {}", status);	37	let expected = format!("Received HTTP status {status}");
38	assert_eq!(error.to_string().get(..expected.len()), Some(expected).as_deref());	38	assert_eq!(error.to_string().get(..expected.len()), Some(expected).as_deref());
39	drop(server.received());	39	drop(server.received());
40	Ok((server, client))	40	Ok((server, client))

git-url/src/expand_path.rs+1−1

@@ -28,7 +28,7 @@ impl From<ForUser> for Option<BString> { · 27 unmodified lines
28	pub enum Error {	28	pub enum Error {
29	#[error("UTF8 conversion on non-unix system failed for path: {path:?}")]	29	#[error("UTF8 conversion on non-unix system failed for path: {path:?}")]
30	IllformedUtf8 { path: BString },	30	IllformedUtf8 { path: BString },
31	#[error("Home directory could not be obtained for {}", match user {Some(user) => format!("user '{}'", user), None => "current user".into()})]	31	#[error("Home directory could not be obtained for {}", match user {Some(user) => format!("user '{user}'"), None => "current user".into()})]
32	MissingHome { user: Option<BString> },	32	MissingHome { user: Option<BString> },
33	}	33	}
34		34

git-url/src/lib.rs+1−1

@@ -188,7 +188,7 @@ impl Url { · 187 unmodified lines
188	(Some(_user), None) => unreachable!("BUG: should not be possible to have a user but no host"),	188	(Some(_user), None) => unreachable!("BUG: should not be possible to have a user but no host"),
189	};	189	};
190	if let Some(port) = &self.port {	190	if let Some(port) = &self.port {
191	write!(&mut out, ":{}", port)?;	191	write!(&mut out, ":{port}")?;
192	}	192	}
193	if self.serialize_alternative_form && self.scheme == Scheme::Ssh {	193	if self.serialize_alternative_form && self.scheme == Scheme::Ssh {
194	out.write_all(b":")?;	194	out.write_all(b":")?;

git-url/tests/expand_path/mod.rs+2−2

@@ -21,7 +21,7 @@ fn user_home(name: &str) -> std::path::PathBuf { · 20 unmodified lines
21	#[cfg(not(windows))]	21	#[cfg(not(windows))]
22	fn user_home(name: &str) -> std::path::PathBuf {	22	fn user_home(name: &str) -> std::path::PathBuf {
23	#[cfg(not(windows))]	23	#[cfg(not(windows))]
24	format!("/home/{}", name).into()	24	format!("/home/{name}").into()
25	}	25	}
26		26
27	#[test]	27	#[test]
@@ -29,7 +29,7 @@ fn without_username() -> crate::Result { · 1 unmodified line
29	let (user, resolved_path) = expand_path::parse(b"/~/hello/git".as_bstr())?;	29	let (user, resolved_path) = expand_path::parse(b"/~/hello/git".as_bstr())?;
30	let resolved_path = expand_path::with(user.as_ref(), resolved_path.as_ref(), \|user: &ForUser\| match user {	30	let resolved_path = expand_path::with(user.as_ref(), resolved_path.as_ref(), \|user: &ForUser\| match user {
31	ForUser::Current => Some(user_home("byron")),	31	ForUser::Current => Some(user_home("byron")),
32	ForUser::Name(name) => Some(format!("/home/{}", name).into()),	32	ForUser::Name(name) => Some(format!("/home/{name}").into()),
33	})?;	33	})?;
34	assert_eq!(resolved_path, expected_path());	34	assert_eq!(resolved_path, expected_path());
35	Ok(())	35	Ok(())

git-worktree/src/fs/cache/state.rs+2−2

@@ -231,10 +231,10 @@ impl State { · 230 unmodified lines
231	/// - ignores entries which aren't blobs	231	/// - ignores entries which aren't blobs
232	/// - ignores ignore entries which are not skip-worktree	232	/// - ignores ignore entries which are not skip-worktree
233	/// - within merges, picks 'our' stage both for ignore and attribute files.	233	/// - within merges, picks 'our' stage both for ignore and attribute files.
234	pub fn build_attribute_list<'paths>(	234	pub fn build_attribute_list(
235	&self,	235	&self,
236	index: &git_index::State,	236	index: &git_index::State,
237	paths: &'paths git_index::PathStorageRef,	237	paths: &git_index::PathStorageRef,
238	case: Case,	238	case: Case,
239	) -> Vec<PathOidMapping> {	239	) -> Vec<PathOidMapping> {
240	let a1_backing;	240	let a1_backing;

tests/tools/src/lib.rs+1−1

@@ -183,7 +183,7 @@ pub fn spawn_git_daemon(working_dir: impl AsRef<Path>) -> std::io::Result<GitDae · 182 unmodified lines
183	}	183	}
184	Ok(GitDaemon {	184	Ok(GitDaemon {
185	child,	185	child,
186	url: format!("git://{}", server_addr),	186	url: format!("git://{server_addr}"),
187	})	187	})
188	}	188	}
189		189