Initial support for parse-time constants (#7436)

crates/nu-command/src/core_commands/const_.rs

@@ -0,0 +1,104 @@
+use nu_protocol::ast::Call;
+use nu_protocol::engine::{Command, EngineState, Stack};
+use nu_protocol::{Category, Example, PipelineData, ShellError, Signature, SyntaxShape, Type};
+
+#[derive(Clone)]
+pub struct Const;
+
+impl Command for Const {
+    fn name(&self) -> &str {
+        "const"
+    }
+
+    fn usage(&self) -> &str {
+        "Create a parse-time constant."
+    }
+
+    fn signature(&self) -> nu_protocol::Signature {
+        Signature::build("const")
+            .input_output_types(vec![(Type::Nothing, Type::Nothing)])
+            .allow_variants_without_examples(true)
+            .required("const_name", SyntaxShape::VarWithOptType, "constant name")
+            .required(
+                "initial_value",
+                SyntaxShape::Keyword(b"=".to_vec(), Box::new(SyntaxShape::Expression)),
+                "equals sign followed by constant value",
+            )
+            .category(Category::Core)
+    }
+
+    fn extra_usage(&self) -> &str {
+        r#"This command is a parser keyword. For details, check:
+  https://www.nushell.sh/book/thinking_in_nu.html"#
+    }
+
+    fn is_parser_keyword(&self) -> bool {
+        true
+    }
+
+    fn search_terms(&self) -> Vec<&str> {
+        vec!["set", "let"]
+    }
+
+    fn run(
+        &self,
+        engine_state: &EngineState,
+        stack: &mut Stack,
+        call: &Call,
+        _input: PipelineData,
+    ) -> Result<nu_protocol::PipelineData, nu_protocol::ShellError> {
+        let var_id = call
+            .positional_nth(0)
+            .expect("checked through parser")
+            .as_var()
+            .expect("internal error: missing variable");
+
+        if let Some(constval) = engine_state.find_constant(var_id, &[]) {
+            // Instead of creating a second copy of the value in the stack, we could change
+            // stack.get_var() to check engine_state.find_constant().
+            stack.add_var(var_id, constval.clone());
+
+            Ok(PipelineData::empty())
+        } else {
+            Err(ShellError::NushellFailedSpanned(
+                "Missing Constant".to_string(),
+                "constant not added by the parser".to_string(),
+                call.head,
+            ))
+        }
+    }
+
+    fn examples(&self) -> Vec<Example> {
+        vec![
+            Example {
+                description: "Create a new parse-time constant.",
+                example: "let x = 10",
+                result: None,
+            },
+            Example {
+                description: "Create a composite constant value",
+                example: "let x = { a: 10, b: 20 }",
+                result: None,
+            },
+        ]
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use nu_protocol::engine::CommandType;
+
+    use super::*;
+
+    #[test]
+    fn test_examples() {
+        use crate::test_examples;
+
+        test_examples(Const {})
+    }
+
+    #[test]
+    fn test_command_type() {
+        assert!(matches!(Const.command_type(), CommandType::Keyword));
+    }
+}

crates/nu-command/src/core_commands/let_.rs

@@ -70,9 +70,8 @@ impl Command for Let {
         )?
         .0;
 
-        //println!("Adding: {:?} to {}", rhs, var_id);
-
         stack.add_var(var_id, rhs.into_value(call.head));
+
         Ok(PipelineData::empty())
     }
 

crates/nu-command/src/core_commands/mod.rs

@@ -2,6 +2,7 @@ mod alias;
 mod ast;
 mod break_;
 mod commandline;
+mod const_;
 mod continue_;
 mod debug;
 mod def;
@@ -40,6 +41,7 @@ pub use alias::Alias;
 pub use ast::Ast;
 pub use break_::Break;
 pub use commandline::Commandline;
+pub use const_::Const;
 pub use continue_::Continue;
 pub use debug::Debug;
 pub use def::Def;

crates/nu-command/src/core_commands/overlay/use_.rs

@@ -84,25 +84,8 @@ impl Command for OverlayUse {
             ));
         };
 
-        let overlay_name = if let Some(kw_expression) = call.positional_nth(1) {
-            // If renamed via the 'as' keyword, use the new name as the overlay name
-            if let Some(new_name_expression) = kw_expression.as_keyword() {
-                if let Some(new_name) = new_name_expression.as_string() {
-                    new_name
-                } else {
-                    return Err(ShellError::NushellFailedSpanned(
-                        "Wrong keyword type".to_string(),
-                        "keyword argument not a string".to_string(),
-                        new_name_expression.span,
-                    ));
-                }
-            } else {
-                return Err(ShellError::NushellFailedSpanned(
-                    "Wrong keyword type".to_string(),
-                    "keyword argument not a keyword".to_string(),
-                    kw_expression.span,
-                ));
-            }
+        let overlay_name = if let Some(name) = call.opt(engine_state, caller_stack, 1)? {
+            name
         } else if engine_state
             .find_overlay(name_arg.item.as_bytes())
             .is_some()

crates/nu-command/src/default_context.rs

@@ -32,6 +32,7 @@ pub fn create_default_context() -> EngineState {
             Ast,
             Break,
             Commandline,
+            Const,
             Continue,
             Debug,
             Def,