src: use "impl trait" syntax for args where possible

This syntax is a bit less verbose than the fully-spelled-out generic
form.  I'm surprised by how few sites this was possible for...

Signed-off-by: Allison Karlitskaya <[email protected]>

Author: allisonkarlitskaya

src/dumpfile.rs

@@ -101,11 +101,11 @@ pub fn write_directory(
     )
 }
 
-pub fn write_leaf<ObjectID: FsVerityHashValue>(
+pub fn write_leaf(
     writer: &mut impl fmt::Write,
     path: &Path,
     stat: &Stat,
-    content: &LeafContent<ObjectID>,
+    content: &LeafContent<impl FsVerityHashValue>,
     nlink: usize,
 ) -> fmt::Result {
     match content {

src/erofs/writer.rs

@@ -525,7 +525,7 @@ impl<'a, ObjectID: FsVerityHashValue> InodeCollector<'a, ObjectID> {
 
 /// Takes a list of inodes where each inode contains only local xattr values, determines which
 /// xattrs (key, value) pairs appear more than once, and shares them.
-fn share_xattrs<ObjectID: FsVerityHashValue>(inodes: &mut [Inode<ObjectID>]) -> Vec<XAttr> {
+fn share_xattrs(inodes: &mut [Inode<impl FsVerityHashValue>]) -> Vec<XAttr> {
     let mut xattrs: BTreeMap<XAttr, usize> = BTreeMap::new();
 
     // Collect all xattrs from the inodes
@@ -563,9 +563,9 @@ fn share_xattrs<ObjectID: FsVerityHashValue>(inodes: &mut [Inode<ObjectID>]) ->
     xattrs.into_keys().collect()
 }
 
-fn write_erofs<ObjectID: FsVerityHashValue>(
+fn write_erofs(
     output: &mut impl Output,
-    inodes: &[Inode<ObjectID>],
+    inodes: &[Inode<impl FsVerityHashValue>],
     xattrs: &[XAttr],
 ) {
     // Write composefs header

src/oci/image.rs

@@ -68,10 +68,7 @@ pub fn compose_filesystem<ObjectID: FsVerityHashValue>(
     Ok(filesystem)
 }
 
-pub fn create_dumpfile<ObjectID: FsVerityHashValue>(
-    repo: &Repository<ObjectID>,
-    layers: &[String],
-) -> Result<()> {
+pub fn create_dumpfile(repo: &Repository<impl FsVerityHashValue>, layers: &[String]) -> Result<()> {
     let filesystem = compose_filesystem(repo, layers)?;
     let mut stdout = std::io::stdout();
     write_dumpfile(&mut stdout, &filesystem)?;

src/oci/mod.rs

@@ -212,8 +212,8 @@ impl<'repo, ObjectID: FsVerityHashValue> ImageOp<'repo, ObjectID> {
 
 /// Pull the target image, and add the provided tag. If this is a mountable
 /// image (i.e. not an artifact), it is *not* unpacked by default.
-pub async fn pull<ObjectID: FsVerityHashValue>(
-    repo: &Repository<ObjectID>,
+pub async fn pull(
+    repo: &Repository<impl FsVerityHashValue>,
     imgref: &str,
     reference: Option<&str>,
 ) -> Result<()> {

src/oci/tar.rs

@@ -43,9 +43,9 @@ async fn read_header_async(reader: &mut (impl AsyncRead + Unpin)) -> Result<Opti
 /// Splits the tar file from tar_stream into a Split Stream.  The store_data function is
 /// responsible for ensuring that "external data" is in the composefs repository and returns the
 /// fsverity hash value of that data.
-pub fn split<ObjectID: FsVerityHashValue>(
+pub fn split(
     tar_stream: &mut impl Read,
-    writer: &mut SplitStreamWriter<ObjectID>,
+    writer: &mut SplitStreamWriter<impl FsVerityHashValue>,
 ) -> Result<()> {
     while let Some(header) = read_header(tar_stream)? {
         // the header always gets stored as inline data
@@ -73,9 +73,9 @@ pub fn split<ObjectID: FsVerityHashValue>(
     Ok(())
 }
 
-pub async fn split_async<ObjectID: FsVerityHashValue>(
+pub async fn split_async(
     mut tar_stream: impl AsyncRead + Unpin,
-    writer: &mut SplitStreamWriter<'_, ObjectID>,
+    writer: &mut SplitStreamWriter<'_, impl FsVerityHashValue>,
 ) -> Result<()> {
     while let Some(header) = read_header_async(&mut tar_stream).await? {
         // the header always gets stored as inline data

tests/mkfs.rs

@@ -17,15 +17,15 @@ use composefs::{
     image::{Directory, FileSystem, Inode, Leaf, LeafContent, RegularFile, Stat},
 };
 
-fn debug_fs<ObjectID: FsVerityHashValue>(mut fs: FileSystem<ObjectID>) -> String {
+fn debug_fs(mut fs: FileSystem<impl FsVerityHashValue>) -> String {
     fs.done();
     let image = mkfs_erofs(&fs);
     let mut output = vec![];
     debug_img(&mut output, &image).unwrap();
     String::from_utf8(output).unwrap()
 }
 
-fn empty<ObjectID: FsVerityHashValue>(_fs: &mut FileSystem<ObjectID>) {}
+fn empty(_fs: &mut FileSystem<impl FsVerityHashValue>) {}
 
 #[test]
 fn test_empty() {