Add unified deprecation system and @deprecated attribute (#15770)

crates/nu-cmd-base/src/lib.rs

@@ -3,3 +3,6 @@ pub mod formats;
 pub mod hook;
 pub mod input_handler;
 pub mod util;
+mod wrap_call;
+
+pub use wrap_call::*;

crates/nu-cmd-base/src/wrap_call.rs

@@ -0,0 +1,101 @@
+use nu_engine::CallExt;
+use nu_protocol::{
+    DeclId, FromValue, ShellError, Span,
+    engine::{Call, EngineState, Stack, StateWorkingSet},
+};
+
+/// A helper utility to aid in implementing commands which have the same behavior for `run` and `run_const`.
+///
+/// Only supports functions in [`Call`] and [`CallExt`] which have a `const` suffix.
+///
+/// To use, the actual command logic should be moved to a function. Then, `eval` and `eval_const` can be implemented like this:
+/// ```rust
+/// # use nu_engine::command_prelude::*;
+/// # use nu_cmd_base::WrapCall;
+/// # fn do_command_logic(call: WrapCall) -> Result<PipelineData, ShellError> { Ok(PipelineData::Empty) }
+///
+/// # struct Command {}
+/// # impl Command {
+/// fn run(&self, engine_state: &EngineState, stack: &mut Stack, call: &Call) -> Result<PipelineData, ShellError> {
+///     let call = WrapCall::Eval(engine_state, stack, call);
+///     do_command_logic(call)
+/// }
+///
+/// fn run_const(&self, working_set: &StateWorkingSet, call: &Call) -> Result<PipelineData, ShellError> {
+///     let call = WrapCall::ConstEval(working_set, call);
+///     do_command_logic(call)
+/// }
+/// # }
+/// ```
+///
+/// Then, the typical [`Call`] and [`CallExt`] operations can be called using destructuring:
+///
+/// ```rust
+/// # use nu_engine::command_prelude::*;
+/// # use nu_cmd_base::WrapCall;
+/// # let call = WrapCall::Eval(&EngineState::new(), &mut Stack::new(), &Call::new(Span::unknown()));
+/// # fn do_command_logic(call: WrapCall) -> Result<(), ShellError> {
+/// let (call, required): (_, String) = call.req(0)?;
+/// let (call, flag): (_, Option<i64>) = call.get_flag("number")?;
+/// # Ok(())
+/// # }
+/// ```
+///
+/// A new `WrapCall` instance has to be returned after each function to ensure
+/// that there is only ever one copy of mutable [`Stack`] reference.
+pub enum WrapCall<'a> {
+    Eval(&'a EngineState, &'a mut Stack, &'a Call<'a>),
+    ConstEval(&'a StateWorkingSet<'a>, &'a Call<'a>),
+}
+
+/// Macro to choose between the non-const and const versions of each [`Call`]/[`CallExt`] function
+macro_rules! proxy {
+    ($self:ident , $eval:ident , $const:ident , $( $args:expr ),*) => {
+        match $self {
+            WrapCall::Eval(engine_state, stack, call) => {
+                Call::$eval(call, engine_state, stack, $( $args ),*)
+                .map(|val| (WrapCall::Eval(engine_state, stack, call), val))
+            },
+            WrapCall::ConstEval(working_set, call) => {
+                Call::$const(call, working_set, $( $args ),*)
+                .map(|val| (WrapCall::ConstEval(working_set, call), val))
+            },
+        }
+    };
+}
+
+impl WrapCall<'_> {
+    pub fn head(&self) -> Span {
+        match self {
+            WrapCall::Eval(_, _, call) => call.head,
+            WrapCall::ConstEval(_, call) => call.head,
+        }
+    }
+
+    pub fn decl_id(&self) -> DeclId {
+        match self {
+            WrapCall::Eval(_, _, call) => call.decl_id,
+            WrapCall::ConstEval(_, call) => call.decl_id,
+        }
+    }
+
+    pub fn has_flag<T: FromValue>(self, flag_name: &str) -> Result<(Self, bool), ShellError> {
+        proxy!(self, has_flag, has_flag_const, flag_name)
+    }
+
+    pub fn get_flag<T: FromValue>(self, name: &str) -> Result<(Self, Option<T>), ShellError> {
+        proxy!(self, get_flag, get_flag_const, name)
+    }
+
+    pub fn req<T: FromValue>(self, pos: usize) -> Result<(Self, T), ShellError> {
+        proxy!(self, req, req_const, pos)
+    }
+
+    pub fn rest<T: FromValue>(self, pos: usize) -> Result<(Self, Vec<T>), ShellError> {
+        proxy!(self, rest, rest_const, pos)
+    }
+
+    pub fn opt<T: FromValue>(self, pos: usize) -> Result<(Self, Option<T>), ShellError> {
+        proxy!(self, opt, opt_const, pos)
+    }
+}