Allow parse-time evaluation of calls, pipelines and subexpressions (#9499)

Co-authored-by: Antoine Stevan <44101798+amtoine@users.noreply.github.com>

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

@@ -1,5 +1,5 @@
 use nu_protocol::ast::Call;
-use nu_protocol::engine::{Command, EngineState, Stack};
+use nu_protocol::engine::{Command, EngineState, Stack, StateWorkingSet};
 use nu_protocol::{
     Category, Example, IntoPipelineData, PipelineData, ShellError, Signature, Type, Value,
 };
@@ -27,6 +27,10 @@ impl Command for Describe {
             .category(Category::Core)
     }
 
+    fn is_const(&self) -> bool {
+        true
+    }
+
     fn run(
         &self,
         _engine_state: &EngineState,
@@ -34,39 +38,16 @@ impl Command for Describe {
         call: &Call,
         input: PipelineData,
     ) -> Result<PipelineData, ShellError> {
-        let head = call.head;
+        run(call, input)
+    }
 
-        let no_collect: bool = call.has_flag("no-collect");
-
-        let description = match input {
-            PipelineData::ExternalStream { .. } => "raw input".into(),
-            PipelineData::ListStream(_, _) => {
-                if no_collect {
-                    "stream".into()
-                } else {
-                    let value = input.into_value(head);
-                    let base_description = match value {
-                        Value::CustomValue { val, .. } => val.value_string(),
-                        _ => value.get_type().to_string(),
-                    };
-
-                    format!("{base_description} (stream)")
-                }
-            }
-            _ => {
-                let value = input.into_value(head);
-                match value {
-                    Value::CustomValue { val, .. } => val.value_string(),
-                    _ => value.get_type().to_string(),
-                }
-            }
-        };
-
-        Ok(Value::String {
-            val: description,
-            span: head,
-        }
-        .into_pipeline_data())
+    fn run_const(
+        &self,
+        _working_set: &StateWorkingSet,
+        call: &Call,
+        input: PipelineData,
+    ) -> Result<PipelineData, ShellError> {
+        run(call, input)
     }
 
     fn examples(&self) -> Vec<Example> {
@@ -96,6 +77,42 @@ impl Command for Describe {
     }
 }
 
+fn run(call: &Call, input: PipelineData) -> Result<PipelineData, ShellError> {
+    let head = call.head;
+
+    let no_collect: bool = call.has_flag("no-collect");
+
+    let description = match input {
+        PipelineData::ExternalStream { .. } => "raw input".into(),
+        PipelineData::ListStream(_, _) => {
+            if no_collect {
+                "stream".into()
+            } else {
+                let value = input.into_value(head);
+                let base_description = match value {
+                    Value::CustomValue { val, .. } => val.value_string(),
+                    _ => value.get_type().to_string(),
+                };
+
+                format!("{base_description} (stream)")
+            }
+        }
+        _ => {
+            let value = input.into_value(head);
+            match value {
+                Value::CustomValue { val, .. } => val.value_string(),
+                _ => value.get_type().to_string(),
+            }
+        }
+    };
+
+    Ok(Value::String {
+        val: description,
+        span: head,
+    }
+    .into_pipeline_data())
+}
+
 #[cfg(test)]
 mod test {
     #[test]

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

@@ -1,6 +1,6 @@
 use nu_engine::CallExt;
 use nu_protocol::ast::Call;
-use nu_protocol::engine::{Command, EngineState, Stack};
+use nu_protocol::engine::{Command, EngineState, Stack, StateWorkingSet};
 use nu_protocol::{
     Category, Example, ListStream, PipelineData, ShellError, Signature, Span, SyntaxShape, Type,
     Value,
@@ -31,6 +31,10 @@ it returns it. Otherwise, it returns a list of the arguments. There is usually
 little reason to use this over just writing the values as-is."#
     }
 
+    fn is_const(&self) -> bool {
+        true
+    }
+
     fn run(
         &self,
         engine_state: &EngineState,
@@ -38,22 +42,18 @@ little reason to use this over just writing the values as-is."#
         call: &Call,
         _input: PipelineData,
     ) -> Result<PipelineData, ShellError> {
-        call.rest(engine_state, stack, 0).map(|to_be_echoed| {
-            let n = to_be_echoed.len();
-            match n.cmp(&1usize) {
-                //  More than one value is converted in a stream of values
-                std::cmp::Ordering::Greater => PipelineData::ListStream(
-                    ListStream::from_stream(to_be_echoed.into_iter(), engine_state.ctrlc.clone()),
-                    None,
-                ),
+        let args = call.rest(engine_state, stack, 0);
+        run(engine_state, args, call)
+    }
 
-                //  But a single value can be forwarded as it is
-                std::cmp::Ordering::Equal => PipelineData::Value(to_be_echoed[0].clone(), None),
-
-                //  When there are no elements, we echo the empty string
-                std::cmp::Ordering::Less => PipelineData::Value(Value::string("", call.head), None),
-            }
-        })
+    fn run_const(
+        &self,
+        working_set: &StateWorkingSet,
+        call: &Call,
+        _input: PipelineData,
+    ) -> Result<PipelineData, ShellError> {
+        let args = call.rest_const(working_set, 0);
+        run(working_set.permanent(), args, call)
     }
 
     fn examples(&self) -> Vec<Example> {
@@ -76,6 +76,29 @@ little reason to use this over just writing the values as-is."#
     }
 }
 
+fn run(
+    engine_state: &EngineState,
+    args: Result<Vec<Value>, ShellError>,
+    call: &Call,
+) -> Result<PipelineData, ShellError> {
+    args.map(|to_be_echoed| {
+        let n = to_be_echoed.len();
+        match n.cmp(&1usize) {
+            //  More than one value is converted in a stream of values
+            std::cmp::Ordering::Greater => PipelineData::ListStream(
+                ListStream::from_stream(to_be_echoed.into_iter(), engine_state.ctrlc.clone()),
+                None,
+            ),
+
+            //  But a single value can be forwarded as it is
+            std::cmp::Ordering::Equal => PipelineData::Value(to_be_echoed[0].clone(), None),
+
+            //  When there are no elements, we echo the empty string
+            std::cmp::Ordering::Less => PipelineData::Value(Value::string("", call.head), None),
+        }
+    })
+}
+
 #[cfg(test)]
 mod test {
     #[test]

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

@@ -1,5 +1,5 @@
 use nu_protocol::ast::Call;
-use nu_protocol::engine::{Command, EngineState, Stack};
+use nu_protocol::engine::{Command, EngineState, Stack, StateWorkingSet};
 use nu_protocol::{Category, Example, PipelineData, ShellError, Signature, Span, Type, Value};
 
 #[derive(Clone)]
@@ -24,6 +24,10 @@ impl Command for Ignore {
         vec!["silent", "quiet", "out-null"]
     }
 
+    fn is_const(&self) -> bool {
+        true
+    }
+
     fn run(
         &self,
         _engine_state: &EngineState,
@@ -35,6 +39,16 @@ impl Command for Ignore {
         Ok(PipelineData::empty())
     }
 
+    fn run_const(
+        &self,
+        _working_set: &StateWorkingSet,
+        call: &Call,
+        input: PipelineData,
+    ) -> Result<PipelineData, ShellError> {
+        input.into_value(call.head);
+        Ok(PipelineData::empty())
+    }
+
     fn examples(&self) -> Vec<Example> {
         vec![Example {
             description: "Ignore the output of an echo command",

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

@@ -1,5 +1,5 @@
 use nu_protocol::ast::Call;
-use nu_protocol::engine::{Command, EngineState, Stack};
+use nu_protocol::engine::{Command, EngineState, Stack, StateWorkingSet};
 use nu_protocol::{
     Category, Example, IntoPipelineData, PipelineData, Record, ShellError, Signature, Type, Value,
 };
@@ -26,14 +26,27 @@ impl Command for Version {
         "Display Nu version, and its build configuration."
     }
 
+    fn is_const(&self) -> bool {
+        true
+    }
+
     fn run(
         &self,
         engine_state: &EngineState,
-        stack: &mut Stack,
+        _stack: &mut Stack,
         call: &Call,
-        input: PipelineData,
+        _input: PipelineData,
     ) -> Result<PipelineData, ShellError> {
-        version(engine_state, stack, call, input)
+        version(engine_state, call)
+    }
+
+    fn run_const(
+        &self,
+        working_set: &StateWorkingSet,
+        call: &Call,
+        _input: PipelineData,
+    ) -> Result<PipelineData, ShellError> {
+        version(working_set.permanent(), call)
     }
 
     fn examples(&self) -> Vec<Example> {
@@ -45,12 +58,7 @@ impl Command for Version {
     }
 }
 
-pub fn version(
-    engine_state: &EngineState,
-    _stack: &mut Stack,
-    call: &Call,
-    _input: PipelineData,
-) -> Result<PipelineData, ShellError> {
+pub fn version(engine_state: &EngineState, call: &Call) -> Result<PipelineData, ShellError> {
     // Pre-allocate the arrays in the worst case (12 items):
     // - version
     // - branch