Fix incorrect handling of boolean flags for builtin commands (#11492)

# Description
Possible fix of #11456
This PR fixes a bug where builtin commands did not respect the logic of
dynamically passed boolean flags. The reason is
[has_flag](6f59abaf43/crates/nu-protocol/src/ast/call.rs (L204C5-L212C6))
method did not evaluate and take into consideration expression used with
flag.

To address this issue a solution is proposed:
1. `has_flag` method is moved to `CallExt` and new logic to evaluate
expression and check if it is a boolean value is added
2. `has_flag_const` method is added to `CallExt` which is a constant
version of `has_flag`
3. `has_named` method is added to `Call` which is basically the old
logic of `has_flag`
4. All usages of `has_flag` in code are updated, mostly to pass
`engine_state` and `stack` to new `has_flag`. In `run_const` commands it
is replaced with `has_flag_const`. And in a few select places: parser,
`to nuon` and `into string` old logic via `has_named` is used.

# User-Facing Changes
Explicit values of boolean flags are now respected in builtin commands.
Before:

![image](https://github.com/nushell/nushell/assets/17511668/f9fbabb2-3cfd-43f9-ba9e-ece76d80043c)
After:

![image](https://github.com/nushell/nushell/assets/17511668/21867596-2075-437f-9c85-45563ac70083)

Another example:
Before:

![image](https://github.com/nushell/nushell/assets/17511668/efdbc5ca-5227-45a4-ac5b-532cdc2bbf5f)
After:

![image](https://github.com/nushell/nushell/assets/17511668/2907d5c5-aa93-404d-af1c-21cdc3d44646)


# Tests + Formatting
Added test reproducing some variants of original issue.

crates/nu-command/src/system/nu_check.rs

@@ -43,9 +43,9 @@ impl Command for NuCheck {
         input: PipelineData,
     ) -> Result<PipelineData, ShellError> {
         let path: Option<Spanned<String>> = call.opt(engine_state, stack, 0)?;
-        let is_module = call.has_flag("as-module");
-        let is_debug = call.has_flag("debug");
-        let is_all = call.has_flag("all");
+        let is_module = call.has_flag(engine_state, stack, "as-module")?;
+        let is_debug = call.has_flag(engine_state, stack, "debug")?;
+        let is_all = call.has_flag(engine_state, stack, "all")?;
         let config = engine_state.get_config();
         let mut contents = vec![];
 

crates/nu-command/src/system/ps.rs

@@ -1,5 +1,6 @@
 #[cfg(windows)]
 use itertools::Itertools;
+use nu_engine::CallExt;
 #[cfg(all(
     unix,
     not(target_os = "macos"),
@@ -54,11 +55,11 @@ impl Command for Ps {
     fn run(
         &self,
         engine_state: &EngineState,
-        _stack: &mut Stack,
+        stack: &mut Stack,
         call: &Call,
         _input: PipelineData,
     ) -> Result<PipelineData, ShellError> {
-        run_ps(engine_state, call)
+        run_ps(engine_state, stack, call)
     }
 
     fn examples(&self) -> Vec<Example> {
@@ -92,10 +93,14 @@ impl Command for Ps {
     }
 }
 
-fn run_ps(engine_state: &EngineState, call: &Call) -> Result<PipelineData, ShellError> {
+fn run_ps(
+    engine_state: &EngineState,
+    stack: &mut Stack,
+    call: &Call,
+) -> Result<PipelineData, ShellError> {
     let mut output = vec![];
     let span = call.head;
-    let long = call.has_flag("long");
+    let long = call.has_flag(engine_state, stack, "long")?;
 
     for proc in nu_system::collect_proc(Duration::from_millis(100), false) {
         let mut record = Record::new();

crates/nu-command/src/system/registry_query.rs

@@ -88,13 +88,13 @@ fn registry_query(
 ) -> Result<PipelineData, ShellError> {
     let call_span = call.head;
 
-    let skip_expand = call.has_flag("no-expand");
+    let skip_expand = call.has_flag(engine_state, stack, "no-expand")?;
 
     let registry_key: Spanned<String> = call.req(engine_state, stack, 0)?;
     let registry_key_span = &registry_key.clone().span;
     let registry_value: Option<Spanned<String>> = call.opt(engine_state, stack, 1)?;
 
-    let reg_hive = get_reg_hive(call)?;
+    let reg_hive = get_reg_hive(engine_state, stack, call)?;
     let reg_key = reg_hive.open_subkey(registry_key.item)?;
 
     if registry_value.is_none() {
@@ -144,14 +144,22 @@ fn registry_query(
     }
 }
 
-fn get_reg_hive(call: &Call) -> Result<RegKey, ShellError> {
-    let flags: Vec<_> = [
+fn get_reg_hive(
+    engine_state: &EngineState,
+    stack: &mut Stack,
+    call: &Call,
+) -> Result<RegKey, ShellError> {
+    let flags = [
         "hkcr", "hkcu", "hklm", "hku", "hkpd", "hkpt", "hkpnls", "hkcc", "hkdd", "hkculs",
     ]
     .iter()
     .copied()
-    .filter(|flag| call.has_flag(flag))
-    .collect();
+    .filter_map(|flag| match call.has_flag(engine_state, stack, flag) {
+        Ok(true) => Some(Ok(flag)),
+        Ok(false) => None,
+        Err(e) => Some(Err(e)),
+    })
+    .collect::<Result<Vec<_>, ShellError>>()?;
     if flags.len() > 1 {
         return Err(ShellError::GenericError {
             error: "Only one registry key can be specified".into(),

crates/nu-command/src/system/run_external.rs

@@ -60,10 +60,10 @@ impl Command for External {
         call: &Call,
         input: PipelineData,
     ) -> Result<PipelineData, ShellError> {
-        let redirect_stdout = call.has_flag("redirect-stdout");
-        let redirect_stderr = call.has_flag("redirect-stderr");
-        let redirect_combine = call.has_flag("redirect-combine");
-        let trim_end_newline = call.has_flag("trim-end-newline");
+        let redirect_stdout = call.has_flag(engine_state, stack, "redirect-stdout")?;
+        let redirect_stderr = call.has_flag(engine_state, stack, "redirect-stderr")?;
+        let redirect_combine = call.has_flag(engine_state, stack, "redirect-combine")?;
+        let trim_end_newline = call.has_flag(engine_state, stack, "trim-end-newline")?;
 
         if redirect_combine && (redirect_stdout || redirect_stderr) {
             return Err(ShellError::ExternalCommand {

crates/nu-command/src/system/which_.rs

@@ -226,7 +226,7 @@ fn which(
 ) -> Result<PipelineData, ShellError> {
     let which_args = WhichArgs {
         applications: call.rest(engine_state, stack, 0)?,
-        all: call.has_flag("all"),
+        all: call.has_flag(engine_state, stack, "all")?,
     };
     let ctrlc = engine_state.ctrlc.clone();