Allow parse-time evaluation of if (#10326)

crates/nu-cmd-lang/src/core_commands/if_.rs

@@ -1,6 +1,7 @@
 use nu_engine::{eval_block, eval_expression, eval_expression_with_input, CallExt};
 use nu_protocol::ast::Call;
-use nu_protocol::engine::{Block, Command, EngineState, Stack};
+use nu_protocol::engine::{Block, Command, EngineState, Stack, StateWorkingSet};
+use nu_protocol::eval_const::{eval_const_subexpression, eval_constant, eval_constant_with_input};
 use nu_protocol::{
     Category, Example, PipelineData, ShellError, Signature, SyntaxShape, Type, Value,
 };
@@ -40,6 +41,60 @@ impl Command for If {
             .category(Category::Core)
     }
 
+    fn is_const(&self) -> bool {
+        true
+    }
+
+    fn run_const(
+        &self,
+        working_set: &StateWorkingSet,
+        call: &Call,
+        input: PipelineData,
+    ) -> Result<PipelineData, ShellError> {
+        let cond = call.positional_nth(0).expect("checked through parser");
+        let then_block: Block = call.req_const(working_set, 1)?;
+        let else_case = call.positional_nth(2);
+
+        let result = eval_constant(working_set, cond)?;
+        match &result {
+            Value::Bool { val, .. } => {
+                if *val {
+                    let block = working_set.get_block(then_block.block_id);
+                    eval_const_subexpression(
+                        working_set,
+                        block,
+                        input,
+                        block.span.unwrap_or(call.head),
+                    )
+                } else if let Some(else_case) = else_case {
+                    if let Some(else_expr) = else_case.as_keyword() {
+                        if let Some(block_id) = else_expr.as_block() {
+                            let block = working_set.get_block(block_id);
+                            eval_const_subexpression(
+                                working_set,
+                                block,
+                                input,
+                                block.span.unwrap_or(call.head),
+                            )
+                        } else {
+                            eval_constant_with_input(working_set, else_expr, input)
+                        }
+                    } else {
+                        eval_constant_with_input(working_set, else_case, input)
+                    }
+                } else {
+                    Ok(PipelineData::empty())
+                }
+            }
+            x => Err(ShellError::CantConvert {
+                to_type: "bool".into(),
+                from_type: x.get_type().to_string(),
+                span: result.span(),
+                help: None,
+            }),
+        }
+    }
+
     fn run(
         &self,
         engine_state: &EngineState,