Remove dead Option layer from run_piped (#3634)

This is a clean-up PR: I noticed that the `run_piped` function has an
`Option` layer that is unnecessary:
- If the process launching fails, it returns an error.
- If it succeeds, it returns `Ok(Some(process))`

Thus, the `Option` layer is always `Some`. The main change is updating
the function signature from:
```rust
pub fn run_piped(verbosity: &impl Verbosity, mut cmd: Command) -> Result<Option<Child>>
```
to:
```rust
pub fn run_piped(verbosity: &impl Verbosity, mut cmd: Command) -> Result<Child>
```

By submitting this pull request, I confirm that my contribution is made
under the terms of the Apache 2.0 and MIT licenses.

Author: zhassan-aws

kani-driver/src/call_cargo.rs

@@ -277,62 +277,59 @@ crate-type = ["lib"]
     fn run_build(&self, cargo_cmd: Command) -> Result<Vec<RustcArtifact>> {
         let support_color = std::io::stdout().is_terminal();
         let mut artifacts = vec![];
-        if let Some(mut cargo_process) = self.run_piped(cargo_cmd)? {
-            let reader = BufReader::new(cargo_process.stdout.take().unwrap());
-            let mut error_count = 0;
-            for message in Message::parse_stream(reader) {
-                let message = message.unwrap();
-                match message {
-                    Message::CompilerMessage(msg) => match msg.message.level {
-                        DiagnosticLevel::FailureNote => {
-                            print_msg(&msg.message, support_color)?;
-                        }
-                        DiagnosticLevel::Error => {
-                            error_count += 1;
-                            print_msg(&msg.message, support_color)?;
-                        }
-                        DiagnosticLevel::Ice => {
-                            print_msg(&msg.message, support_color)?;
-                            let _ = cargo_process.wait();
-                            return Err(anyhow::Error::msg(msg.message).context(format!(
-                                "Failed to compile `{}` due to an internal compiler error.",
-                                msg.target.name
-                            )));
-                        }
-                        _ => {
-                            if !self.args.common_args.quiet {
-                                print_msg(&msg.message, support_color)?;
-                            }
-                        }
-                    },
-                    Message::CompilerArtifact(rustc_artifact) => {
-                        // Compares two targets, and falls back to a weaker
-                        // comparison where we avoid dashes in their names.
-                        artifacts.push(rustc_artifact)
+        let mut cargo_process = self.run_piped(cargo_cmd)?;
+        let reader = BufReader::new(cargo_process.stdout.take().unwrap());
+        let mut error_count = 0;
+        for message in Message::parse_stream(reader) {
+            let message = message.unwrap();
+            match message {
+                Message::CompilerMessage(msg) => match msg.message.level {
+                    DiagnosticLevel::FailureNote => {
+                        print_msg(&msg.message, support_color)?;
                     }
-                    Message::BuildScriptExecuted(_) | Message::BuildFinished(_) => {
-                        // do nothing
+                    DiagnosticLevel::Error => {
+                        error_count += 1;
+                        print_msg(&msg.message, support_color)?;
                     }
-                    Message::TextLine(msg) => {
-                        if !self.args.common_args.quiet {
-                            println!("{msg}");
-                        }
+                    DiagnosticLevel::Ice => {
+                        print_msg(&msg.message, support_color)?;
+                        let _ = cargo_process.wait();
+                        return Err(anyhow::Error::msg(msg.message).context(format!(
+                            "Failed to compile `{}` due to an internal compiler error.",
+                            msg.target.name
+                        )));
                     }
-
-                    // Non-exhaustive enum.
                     _ => {
                         if !self.args.common_args.quiet {
-                            println!("{message:?}");
+                            print_msg(&msg.message, support_color)?;
                         }
                     }
+                },
+                Message::CompilerArtifact(rustc_artifact) => {
+                    // Compares two targets, and falls back to a weaker
+                    // comparison where we avoid dashes in their names.
+                    artifacts.push(rustc_artifact)
+                }
+                Message::BuildScriptExecuted(_) | Message::BuildFinished(_) => {
+                    // do nothing
+                }
+                Message::TextLine(msg) => {
+                    if !self.args.common_args.quiet {
+                        println!("{msg}");
+                    }
+                }
+
+                // Non-exhaustive enum.
+                _ => {
+                    if !self.args.common_args.quiet {
+                        println!("{message:?}");
+                    }
                 }
             }
-            let status = cargo_process.wait()?;
-            if !status.success() {
-                bail!(
-                    "Failed to execute cargo ({status}). Found {error_count} compilation errors."
-                );
-            }
+        }
+        let status = cargo_process.wait()?;
+        if !status.success() {
+            bail!("Failed to execute cargo ({status}). Found {error_count} compilation errors.");
         }
         Ok(artifacts)
     }
@@ -383,7 +380,7 @@ crate-type = ["lib"]
                 cmd.arg(pkg);
                 // For some reason clippy cannot see that we are invoking wait() in the next line.
                 #[allow(clippy::zombie_processes)]
-                let mut process = self.run_piped(cmd)?.unwrap();
+                let mut process = self.run_piped(cmd)?;
                 let result = process.wait()?;
                 if !result.success() {
                     bail!("Failed to retrieve information for `{pkg}`");

kani-driver/src/call_cbmc.rs

@@ -88,8 +88,8 @@ impl KaniSession {
             cmd.arg("--json-ui");
 
             // Spawn the CBMC process and process its output below
-            let cbmc_process_opt = self.run_piped(cmd)?;
-            let cbmc_process = cbmc_process_opt.ok_or(anyhow::Error::msg("Failed to run cbmc"))?;
+            let cbmc_process =
+                self.run_piped(cmd).map_err(|_| anyhow::Error::msg("Failed to run cbmc"))?;
             let output = process_cbmc_output(cbmc_process, |i| {
                 kani_cbmc_output_filter(
                     i,

kani-driver/src/session.rs

@@ -124,7 +124,7 @@ impl KaniSession {
     }
 
     /// Call [run_piped] with the verbosity configured by the user.
-    pub fn run_piped(&self, cmd: Command) -> Result<Option<Child>> {
+    pub fn run_piped(&self, cmd: Command) -> Result<Child> {
         run_piped(&self.args.common_args, cmd)
     }
 
@@ -227,7 +227,7 @@ pub fn run_redirect(
 ///
 /// NOTE: Unlike other `run_` functions, this function does not attempt to indicate
 /// the process exit code, you need to remember to check this yourself.
-pub fn run_piped(verbosity: &impl Verbosity, mut cmd: Command) -> Result<Option<Child>> {
+pub fn run_piped(verbosity: &impl Verbosity, mut cmd: Command) -> Result<Child> {
     if verbosity.verbose() {
         println!("[Kani] Running: `{}`", render_command(&cmd).to_string_lossy());
     }
@@ -237,7 +237,7 @@ pub fn run_piped(verbosity: &impl Verbosity, mut cmd: Command) -> Result<Option<
         .spawn()
         .context(format!("Failed to invoke {}", cmd.get_program().to_string_lossy()))?;
 
-    Ok(Some(process))
+    Ok(process)
 }
 
 /// Execute the provided function and measure the clock time it took for its execution.