Fix ir eval error on branched block redirection (Fixes nushell#16582) (nushell#16676)

### Description

Attempt to fix issue
[nushell#16582](nushell#16582) by avoiding
duplicated `write` and `close` calls for an `out>`/`err>` redirected
file for `try-catch` and `if-else` blocks.

Similarly to [this PR](nushell#15617) a
function to identify if a code block is being handeled, and if so skip
the invocation of `finish_redirection` so that no additional writes are
added. (The blocks perform redirections on their own and this then
avoids the duplication).

### Release notes summary - What our users need to know

The following commands will no longer raise ir-eval errors:

 - `if true { echo "hey" } out> /dev/null`
 - `if false { echo "hey" } else { echo "ho" } out> /dev/null`
 - `try { 1/0 } catch { echo "hi" } out> /dev/null`

IR before changes: 

[before.txt](https://github.com/user-attachments/files/22308084/before.txt)

IR after changes: 

[after.txt](https://github.com/user-attachments/files/22308085/after.txt)

### Tests

Added 8 tests.

- 🟢 `toolkit fmt`
- 🟢 `toolkit clippy`
- 🟢 `toolkit test`
- 🟢 `toolkit test stdlib`

---------

Co-authored-by: Fixerer <[email protected]>

Author: fixerer

crates/nu-command/tests/commands/redirection.rs

@@ -476,7 +476,7 @@ fn pipe_redirection_in_let_and_mut(
 
 #[rstest::rstest]
 #[case("o>", "bar")]
-#[case("e>", "")]
+#[case("e>", "baz")]
 #[case("o+e>", "bar\nbaz")] // in subexpression, the stderr is go to the terminal
 fn subexpression_redirection(#[case] redir: &str, #[case] stdout_file_body: &str) {
     Playground::setup("file redirection with subexpression", |dirs, _| {
@@ -485,6 +485,153 @@ fn subexpression_redirection(#[case] redir: &str, #[case] stdout_file_body: &str
             format!("$env.BAR = 'bar'; $env.BAZ = 'baz'; (nu --testbin echo_env_mixed out-err BAR BAZ) {redir} result.txt")
         );
         assert!(actual.status.success());
-        assert!(file_contents(dirs.test().join("result.txt")).contains(stdout_file_body));
+        assert_eq!(
+            file_contents(dirs.test().join("result.txt")).trim(),
+            stdout_file_body
+        );
+    })
+}
+
+#[rstest::rstest]
+#[case("o>", "bar")]
+#[case("e>", "baz")]
+#[case("o+e>", "bar\nbaz")]
+fn file_redirection_in_if_true(#[case] redir: &str, #[case] stdout_file_body: &str) {
+    Playground::setup("file redirection if true block", |dirs, _| {
+        let actual = nu!(
+            cwd: dirs.test(),
+          format!("$env.BAR = 'bar'; $env.BAZ = 'baz'; if true {{ nu --testbin echo_env_mixed out-err BAR BAZ }} {redir} result.txt")
+        );
+        assert!(actual.status.success());
+        assert_eq!(
+            file_contents(dirs.test().join("result.txt")).trim(),
+            stdout_file_body
+        );
+    })
+}
+
+#[rstest::rstest]
+#[case(true, "hey")]
+#[case(false, "ho")]
+fn file_redirection_in_if_else(#[case] cond: bool, #[case] stdout_file_body: &str) {
+    Playground::setup("file redirection if-else block", |dirs, _| {
+        let actual = nu!(
+            cwd: dirs.test(),
+            format!("if {cond} {{ echo 'hey' }} else {{ echo 'ho' }} out> result.txt")
+        );
+        assert!(actual.status.success());
+        assert_eq!(
+            file_contents(dirs.test().join("result.txt")).trim(),
+            stdout_file_body
+        );
+    })
+}
+
+#[rstest::rstest]
+#[case("o>", "bar")]
+#[case("e>", "baz")]
+#[case("o+e>", "bar\nbaz")]
+fn file_redirection_in_try_catch(#[case] redir: &str, #[case] stdout_file_body: &str) {
+    Playground::setup("file redirection try-catch block", |dirs, _| {
+        let actual = nu!(
+            cwd: dirs.test(),
+            format!("$env.BAR = 'bar'; $env.BAZ = 'baz'; try {{ 1/0 }} catch {{ nu --testbin echo_env_mixed out-err BAR BAZ }} {redir} result.txt")
+        );
+        assert!(actual.status.success());
+        assert_eq!(
+            file_contents(dirs.test().join("result.txt")).trim(),
+            stdout_file_body
+        );
+    })
+}
+
+#[rstest::rstest]
+fn file_redirection_where_closure() {
+    Playground::setup("file redirection where closure", |dirs, _| {
+        let actual = nu!(
+            cwd: dirs.test(),
+            format!("echo foo bar | where {{|x| $x | str contains 'f'}} out> result.txt")
+        );
+        assert!(actual.status.success());
+        assert_eq!(file_contents(dirs.test().join("result.txt")).trim(), "foo");
+    })
+}
+
+#[rstest::rstest]
+fn file_redirection_match_block() {
+    Playground::setup("file redirection match block", |dirs, _| {
+        let actual = nu!(
+            cwd: dirs.test(),
+            format!("match 3 {{ 1 => 'foo', 3 => 'bar' }} out> result.txt")
+        );
+        assert!(actual.status.success());
+        assert_eq!(file_contents(dirs.test().join("result.txt")).trim(), "bar");
+    })
+}
+
+#[rstest::rstest]
+fn file_redirection_pattern_match_block() {
+    Playground::setup("file redirection pattern match block", |dirs, _| {
+        let actual = nu!(
+            cwd: dirs.test(),
+            format!("let foo = {{ name: 'bar' }}; match $foo {{ {{ name: 'bar' }} => 'baz' }} out> result.txt")
+        );
+        assert!(actual.status.success());
+        assert_eq!(file_contents(dirs.test().join("result.txt")).trim(), "baz");
+    })
+}
+
+#[rstest::rstest]
+fn file_redirection_each_block() {
+    Playground::setup("file redirection each block", |dirs, _| {
+        let actual = nu!(
+            cwd: dirs.test(),
+            format!("[1 2 3] | each {{ $in + 1 }} out> result.txt")
+        );
+        assert!(actual.status.success());
+        assert_eq!(
+            file_contents(dirs.test().join("result.txt")).trim(),
+            "2\n3\n4"
+        );
+    })
+}
+
+#[rstest::rstest]
+fn file_redirection_do_block_with_return() {
+    Playground::setup("file redirection do block with return", |dirs, _| {
+        let actual = nu!(
+            cwd: dirs.test(),
+            format!("do {{|x| return ($x + 1); return $x}} 4 out> result.txt")
+        );
+        assert!(actual.status.success());
+        assert_eq!(file_contents(dirs.test().join("result.txt")).trim(), "5");
+    })
+}
+
+#[rstest::rstest]
+fn file_redirection_while_block() {
+    Playground::setup("file redirection on while", |dirs, _| {
+        let actual = nu!(
+            cwd: dirs.test(),
+            format!("mut x = 0; while $x < 3 {{ $x = $x + 1; echo $x }} o> result.txt")
+        );
+        // Why the discrepancy to `for` behaviour?
+        assert!(actual.status.success());
+        assert_eq!(file_contents(dirs.test().join("result.txt")), "");
+    })
+}
+
+#[rstest::rstest]
+fn file_redirection_not_allowed_on_for() {
+    Playground::setup("file redirection disallowed on for", |dirs, _| {
+        let actual = nu!(
+            cwd: dirs.test(),
+            format!("for $it in [1 2 3] {{ echo $in + 1 }} out> result.txt")
+        );
+        assert!(!actual.status.success());
+        assert!(
+            actual.err.contains("Redirection can not be used with for"),
+            "Should fail"
+        );
     })
 }

crates/nu-engine/src/compile/mod.rs

@@ -194,9 +194,9 @@ fn compile_pipeline(
             out_reg,
         )?;
 
-        // only clean up the redirection if current element is not
-        // a subexpression.  The subexpression itself already clean it.
-        if !is_subexpression(&element.expr.expr) {
+        // Only clean up the redirection if current element is NOT
+        // a nested eval expression, since this already cleans it.
+        if !has_nested_eval_expr(&element.expr.expr) {
             // Clean up the redirection
             finish_redirection(builder, redirect_modes, out_reg)?;
         }
@@ -207,6 +207,20 @@ fn compile_pipeline(
     Ok(())
 }
 
+fn has_nested_eval_expr(expr: &Expr) -> bool {
+    is_subexpression(expr) || is_block_call(expr)
+}
+
+fn is_block_call(expr: &Expr) -> bool {
+    match expr {
+        Expr::Call(inner) => inner
+            .arguments
+            .iter()
+            .any(|arg| matches!(arg.expr().map(|e| &e.expr), Some(Expr::Block(..)))),
+        _ => false,
+    }
+}
+
 fn is_subexpression(expr: &Expr) -> bool {
     match expr {
         Expr::FullCellPath(inner) => {