Fixed error by also using trait object in remote::fetch::Prepare::receive

and expose a new `pub(crate)` fn `receive_inner`

Signed-off-by: Jiahao XU <[email protected]>

Author: NobodyXu

gix/src/clone/fetch/mod.rs

@@ -1,4 +1,4 @@
-use crate::{clone::PrepareFetch, features::progress::DynNestedProgressToNestedProgress};
+use crate::clone::PrepareFetch;
 
 /// The error returned by [`PrepareFetch::fetch_only()`].
 #[derive(Debug, thiserror::Error)]
@@ -120,7 +120,7 @@ impl PrepareFetch {
                 f(&mut connection).map_err(|err| Error::RemoteConnection(err))?;
             }
             connection
-                .prepare_fetch(&mut progress, {
+                .prepare_fetch(&mut *progress, {
                     let mut opts = self.fetch_options.clone();
                     if !opts.extra_refspecs.contains(&head_refspec) {
                         opts.extra_refspecs.push(head_refspec)
@@ -143,7 +143,7 @@ impl PrepareFetch {
                 message: reflog_message.clone(),
             })
             .with_shallow(self.shallow.clone())
-            .receive(DynNestedProgressToNestedProgress(progress), should_interrupt)
+            .receive_inner(progress, should_interrupt)
             .await?;
 
         util::append_config_to_repo_config(repo, config);

gix/src/remote/connection/fetch/receive_pack.rs

@@ -74,19 +74,28 @@ where
     ///
     #[gix_protocol::maybe_async::maybe_async]
     #[allow(clippy::drop_non_drop)]
-    pub async fn receive<P>(mut self, mut progress: P, should_interrupt: &AtomicBool) -> Result<Outcome, Error>
+    pub async fn receive<P>(self, mut progress: P, should_interrupt: &AtomicBool) -> Result<Outcome, Error>
     where
         P: gix_features::progress::NestedProgress,
         P::SubProgress: 'static,
     {
+        self.receive_inner(&mut progress, should_interrupt)
+    }
+
+    #[gix_protocol::maybe_async::maybe_async]
+    #[allow(clippy::drop_non_drop)]
+    pub(crate) async fn receive_inner(
+        mut self,
+        progress: &mut dyn crate::DynNestedProgress,
+        should_interrupt: &AtomicBool,
+    ) -> Result<Outcome, Error> {
         let _span = gix_trace::coarse!("fetch::Prepare::receive()");
         let mut con = self.con.take().expect("receive() can only be called once");
 
         let handshake = &self.ref_map.handshake;
         let protocol_version = handshake.server_protocol_version;
 
         let fetch = gix_protocol::Command::Fetch;
-        let progress = &mut progress;
         let repo = con.remote.repo;
         let fetch_features = {
             let mut f = fetch.default_features(protocol_version, &handshake.capabilities);
@@ -379,17 +388,14 @@ fn add_shallow_args(
     Ok((shallow_commits, shallow_lock))
 }
 
-fn setup_remote_progress<P>(
-    progress: &mut P,
+fn setup_remote_progress(
+    progress: &mut dyn crate::DynNestedProgress,
     reader: &mut Box<dyn gix_protocol::transport::client::ExtendedBufRead + Unpin + '_>,
     should_interrupt: &AtomicBool,
-) where
-    P: gix_features::progress::NestedProgress,
-    P::SubProgress: 'static,
-{
+) {
     use gix_protocol::transport::client::ExtendedBufRead;
     reader.set_progress_handler(Some(Box::new({
-        let mut remote_progress = progress.add_child_with_id("remote", ProgressId::RemoteProgress.into());
+        let mut remote_progress = progress.add_child_with_id("remote".to_string(), ProgressId::RemoteProgress.into());
         // SAFETY: Ugh, so, with current Rust I can't declare lifetimes in the involved traits the way they need to
         //         be and I also can't use scoped threads to pump from local scopes to an Arc version that could be
         //         used here due to the this being called from sync AND async code (and the async version doesn't work