refactor: return lazy boxed iterator from BuildTaskRunner

BuildTaskRunner::run previously collected the entire cargo message stream
into a Vec, which forced every message to be parsed and allocated up front
and prevented get_target_dir_from_output from short-circuiting once the
matching cdylib artifact is found.

Return Box<dyn Iterator<..>> instead so the runner forwards BuildTask::run's
lazy stream while still being mockable (mockall cannot mock an opaque
impl Trait return, but can mock a boxed trait object). BuildTask::run gains
+ use<> precise capturing so its owned, 'static iterator can move out of the
temporary BuildTask and be boxed.

Addresses PR review comment r3581534373.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Copilot-Session: fa978dd1-9d61-4cea-a03a-7ebc914228fa

Author: krishnakumar4a4

crates/cargo-wdk/src/actions/build/build_task.rs

@@ -50,14 +50,21 @@ pub struct BuildTaskRunner {}
 #[automock]
 #[allow(dead_code, clippy::unused_self, clippy::elidable_lifetime_names)]
 impl BuildTaskRunner {
+    // Returns `Box<dyn Iterator<...>>` rather than `impl Iterator<...>` because
+    // this method is `#[automock]`ed. mockall must be able to *name* the return
+    // type to generate the mock's expectation storage, and it cannot mock an
+    // opaque `impl Trait` return. Boxing into a trait object gives mockall a
+    // concrete, nameable type while still forwarding `BuildTask::run`'s lazy
+    // message stream, so consumers like `get_target_dir_from_output` can
+    // short-circuit instead of parsing/allocating every cargo message up front.
     pub fn run<'a>(
         &self,
         params: &BuildTaskParams<'a>,
         command_exec: &CommandExec,
-    ) -> Result<Vec<Result<Message, std::io::Error>>, BuildTaskError> {
-        BuildTask::new(*params, command_exec)
-            .run()
-            .map(Iterator::collect)
+    ) -> Result<Box<dyn Iterator<Item = Result<Message, std::io::Error>>>, BuildTaskError> {
+        BuildTask::new(*params, command_exec).run().map(|messages| {
+            Box::new(messages) as Box<dyn Iterator<Item = Result<Message, std::io::Error>>>
+        })
     }
 }
 
@@ -110,9 +117,14 @@ impl<'a> BuildTask<'a> {
     ///   not a valid unicode
     /// * `BuildTaskError::CargoBuild` - If there is an error running the `cargo
     ///   build` command
+    // `+ use<>` opts this RPIT out of capturing the `&self` lifetime (edition
+    // 2024 captures in-scope lifetimes by default). The returned iterator owns
+    // its buffer (`Cursor<Vec<u8>>`), so it is effectively `'static`; opting out
+    // of the capture lets `BuildTaskRunner::run` move it out of the temporary
+    // `BuildTask` and box it as a `'static` trait object.
     pub fn run(
         &self,
-    ) -> Result<impl Iterator<Item = Result<Message, std::io::Error>>, BuildTaskError> {
+    ) -> Result<impl Iterator<Item = Result<Message, std::io::Error>> + use<>, BuildTaskError> {
         debug!("Running cargo build");
         let mut args = vec!["build".to_string()];
         args.push("--message-format=json-render-diagnostics".to_string());

crates/cargo-wdk/src/actions/build/mod.rs

@@ -418,8 +418,7 @@ impl<'a> BuildAction<'a> {
             self.get_target_arch_from_cargo_rustc(working_dir)?
         };
         debug!("Target architecture for package: {package_name} is: {target_arch}");
-        let target_dir =
-            Self::get_target_dir_from_output(package, output_message_iter.into_iter())?;
+        let target_dir = Self::get_target_dir_from_output(package, output_message_iter)?;
         debug!(
             "Target directory for package: {} is: {}",
             package_name,

crates/cargo-wdk/src/actions/build/tests.rs

@@ -822,7 +822,12 @@ impl BuildActionHarness {
                     && params.features.features == expected_features.features
             })
             .once()
-            .return_once(move |_, _| result);
+            .return_once(move |_, _| {
+                result.map(|messages| {
+                    Box::new(messages.into_iter())
+                        as Box<dyn Iterator<Item = Result<Message, io::Error>>>
+                })
+            });
     }
 
     fn expect_package_runner(