mirror of
https://github.com/nushell/nushell.git
synced 2025-05-05 23:42:56 +00:00
# Description This PR adds an internal representation language to Nushell, offering an alternative evaluator based on simple instructions, stream-containing registers, and indexed control flow. The number of registers required is determined statically at compile-time, and the fixed size required is allocated upon entering the block. Each instruction is associated with a span, which makes going backwards from IR instructions to source code very easy. Motivations for IR: 1. **Performance.** By simplifying the evaluation path and making it more cache-friendly and branch predictor-friendly, code that does a lot of computation in Nushell itself can be sped up a decent bit. Because the IR is fairly easy to reason about, we can also implement optimization passes in the future to eliminate and simplify code. 2. **Correctness.** The instructions mostly have very simple and easily-specified behavior, so hopefully engine changes are a little bit easier to reason about, and they can be specified in a more formal way at some point. I have made an effort to document each of the instructions in the docs for the enum itself in a reasonably specific way. Some of the errors that would have happened during evaluation before are now moved to the compilation step instead, because they don't make sense to check during evaluation. 3. **As an intermediate target.** This is a good step for us to bring the [`new-nu-parser`](https://github.com/nushell/new-nu-parser) in at some point, as code generated from new AST can be directly compared to code generated from old AST. If the IR code is functionally equivalent, it will behave the exact same way. 4. **Debugging.** With a little bit more work, we can probably give control over advancing the virtual machine that `IrBlock`s run on to some sort of external driver, making things like breakpoints and single stepping possible. Tools like `view ir` and [`explore ir`](https://github.com/devyn/nu_plugin_explore_ir) make it easier than before to see what exactly is going on with your Nushell code. The goal is to eventually replace the AST evaluator entirely, once we're sure it's working just as well. You can help dogfood this by running Nushell with `$env.NU_USE_IR` set to some value. The environment variable is checked when Nushell starts, so config runs with IR, or it can also be set on a line at the REPL to change it dynamically. It is also checked when running `do` in case within a script you want to just run a specific piece of code with or without IR. # Example ```nushell view ir { |data| mut sum = 0 for n in $data { $sum += $n } $sum } ``` ```gas # 3 registers, 19 instructions, 0 bytes of data 0: load-literal %0, int(0) 1: store-variable var 904, %0 # let 2: drain %0 3: drop %0 4: load-variable %1, var 903 5: iterate %0, %1, end 15 # for, label(1), from(14:) 6: store-variable var 905, %0 7: load-variable %0, var 904 8: load-variable %2, var 905 9: binary-op %0, Math(Plus), %2 10: span %0 11: store-variable var 904, %0 12: load-literal %0, nothing 13: drain %0 14: jump 5 15: drop %0 # label(0), from(5:) 16: drain %0 17: load-variable %0, var 904 18: return %0 ``` # Benchmarks All benchmarks run on a base model Mac Mini M1. ## Iterative Fibonacci sequence This is about as best case as possible, making use of the much faster control flow. Most code will not experience a speed improvement nearly this large. ```nushell def fib [n: int] { mut a = 0 mut b = 1 for _ in 2..=$n { let c = $a + $b $a = $b $b = $c } $b } use std bench bench { 0..50 | each { |n| fib $n } } ``` IR disabled: ``` ╭───────┬─────────────────╮ │ mean │ 1ms 924µs 665ns │ │ min │ 1ms 700µs 83ns │ │ max │ 3ms 450µs 125ns │ │ std │ 395µs 759ns │ │ times │ [list 50 items] │ ╰───────┴─────────────────╯ ``` IR enabled: ``` ╭───────┬─────────────────╮ │ mean │ 452µs 820ns │ │ min │ 427µs 417ns │ │ max │ 540µs 167ns │ │ std │ 17µs 158ns │ │ times │ [list 50 items] │ ╰───────┴─────────────────╯ ```  ## [gradient_benchmark_no_check.nu](https://github.com/nushell/nu_scripts/blob/main/benchmarks/gradient_benchmark_no_check.nu) IR disabled: ``` ╭───┬──────────────────╮ │ 0 │ 27ms 929µs 958ns │ │ 1 │ 21ms 153µs 459ns │ │ 2 │ 18ms 639µs 666ns │ │ 3 │ 19ms 554µs 583ns │ │ 4 │ 13ms 383µs 375ns │ │ 5 │ 11ms 328µs 208ns │ │ 6 │ 5ms 659µs 542ns │ ╰───┴──────────────────╯ ``` IR enabled: ``` ╭───┬──────────────────╮ │ 0 │ 22ms 662µs │ │ 1 │ 17ms 221µs 792ns │ │ 2 │ 14ms 786µs 708ns │ │ 3 │ 13ms 876µs 834ns │ │ 4 │ 13ms 52µs 875ns │ │ 5 │ 11ms 269µs 666ns │ │ 6 │ 6ms 942µs 500ns │ ╰───┴──────────────────╯ ``` ## [random-bytes.nu](https://github.com/nushell/nu_scripts/blob/main/benchmarks/random-bytes.nu) I got pretty random results out of this benchmark so I decided not to include it. Not clear why. # User-Facing Changes - IR compilation errors may appear even if the user isn't evaluating with IR. - IR evaluation can be enabled by setting the `NU_USE_IR` environment variable to any value. - New command `view ir` pretty-prints the IR for a block, and `view ir --json` can be piped into an external tool like [`explore ir`](https://github.com/devyn/nu_plugin_explore_ir). # Tests + Formatting All tests are passing with `NU_USE_IR=1`, and I've added some more eval tests to compare the results for some very core operations. I will probably want to add some more so we don't have to always check `NU_USE_IR=1 toolkit test --workspace` on a regular basis. # After Submitting - [ ] release notes - [ ] further documentation of instructions? - [ ] post-release: publish `nu_plugin_explore_ir`
447 lines
15 KiB
Rust
447 lines
15 KiB
Rust
use nu_protocol::{
|
|
ast::{self, Expression},
|
|
engine::{Call, CallImpl, EngineState, Stack},
|
|
ir, FromValue, ShellError, Span, Spanned, Value,
|
|
};
|
|
use serde::{Deserialize, Serialize};
|
|
|
|
/// A representation of the plugin's invocation command including command line args
|
|
///
|
|
/// The `EvaluatedCall` contains information about the way a `Plugin` was invoked representing the
|
|
/// [`Span`] corresponding to the invocation as well as the arguments it was invoked with. It is
|
|
/// one of the items passed to `PluginCommand::run()`, along with the plugin reference, the engine
|
|
/// interface, and a [`Value`] that represents the input.
|
|
///
|
|
/// The evaluated call is used with the Plugins because the plugin doesn't have
|
|
/// access to the Stack and the EngineState the way a built in command might. For that
|
|
/// reason, before encoding the message to the plugin all the arguments to the original
|
|
/// call (which are expressions) are evaluated and passed to Values
|
|
#[derive(Debug, Clone, Serialize, Deserialize)]
|
|
pub struct EvaluatedCall {
|
|
/// Span of the command invocation
|
|
pub head: Span,
|
|
/// Values of positional arguments
|
|
pub positional: Vec<Value>,
|
|
/// Names and values of named arguments
|
|
pub named: Vec<(Spanned<String>, Option<Value>)>,
|
|
}
|
|
|
|
impl EvaluatedCall {
|
|
/// Try to create an [`EvaluatedCall`] from a command `Call`.
|
|
pub fn try_from_call(
|
|
call: &Call,
|
|
engine_state: &EngineState,
|
|
stack: &mut Stack,
|
|
eval_expression_fn: fn(&EngineState, &mut Stack, &Expression) -> Result<Value, ShellError>,
|
|
) -> Result<Self, ShellError> {
|
|
match &call.inner {
|
|
CallImpl::AstRef(call) => {
|
|
Self::try_from_ast_call(call, engine_state, stack, eval_expression_fn)
|
|
}
|
|
CallImpl::AstBox(call) => {
|
|
Self::try_from_ast_call(call, engine_state, stack, eval_expression_fn)
|
|
}
|
|
CallImpl::IrRef(call) => Self::try_from_ir_call(call, stack),
|
|
CallImpl::IrBox(call) => Self::try_from_ir_call(call, stack),
|
|
}
|
|
}
|
|
|
|
fn try_from_ast_call(
|
|
call: &ast::Call,
|
|
engine_state: &EngineState,
|
|
stack: &mut Stack,
|
|
eval_expression_fn: fn(&EngineState, &mut Stack, &Expression) -> Result<Value, ShellError>,
|
|
) -> Result<Self, ShellError> {
|
|
let positional =
|
|
call.rest_iter_flattened(0, |expr| eval_expression_fn(engine_state, stack, expr))?;
|
|
|
|
let mut named = Vec::with_capacity(call.named_len());
|
|
for (string, _, expr) in call.named_iter() {
|
|
let value = match expr {
|
|
None => None,
|
|
Some(expr) => Some(eval_expression_fn(engine_state, stack, expr)?),
|
|
};
|
|
|
|
named.push((string.clone(), value))
|
|
}
|
|
|
|
Ok(Self {
|
|
head: call.head,
|
|
positional,
|
|
named,
|
|
})
|
|
}
|
|
|
|
fn try_from_ir_call(call: &ir::Call, stack: &Stack) -> Result<Self, ShellError> {
|
|
let positional = call.rest_iter_flattened(stack, 0)?;
|
|
|
|
let mut named = Vec::with_capacity(call.named_len(stack));
|
|
named.extend(
|
|
call.named_iter(stack)
|
|
.map(|(name, value)| (name.map(|s| s.to_owned()), value.cloned())),
|
|
);
|
|
|
|
Ok(Self {
|
|
head: call.head,
|
|
positional,
|
|
named,
|
|
})
|
|
}
|
|
|
|
/// Check if a flag (named parameter that does not take a value) is set
|
|
/// Returns Ok(true) if flag is set or passed true value
|
|
/// Returns Ok(false) if flag is not set or passed false value
|
|
/// Returns Err if passed value is not a boolean
|
|
///
|
|
/// # Examples
|
|
/// Invoked as `my_command --foo`:
|
|
/// ```
|
|
/// # use nu_protocol::{Spanned, Span, Value};
|
|
/// # use nu_plugin_protocol::EvaluatedCall;
|
|
/// # let null_span = Span::new(0, 0);
|
|
/// # let call = EvaluatedCall {
|
|
/// # head: null_span,
|
|
/// # positional: Vec::new(),
|
|
/// # named: vec![(
|
|
/// # Spanned { item: "foo".to_owned(), span: null_span},
|
|
/// # None
|
|
/// # )],
|
|
/// # };
|
|
/// assert!(call.has_flag("foo").unwrap());
|
|
/// ```
|
|
///
|
|
/// Invoked as `my_command --bar`:
|
|
/// ```
|
|
/// # use nu_protocol::{Spanned, Span, Value};
|
|
/// # use nu_plugin_protocol::EvaluatedCall;
|
|
/// # let null_span = Span::new(0, 0);
|
|
/// # let call = EvaluatedCall {
|
|
/// # head: null_span,
|
|
/// # positional: Vec::new(),
|
|
/// # named: vec![(
|
|
/// # Spanned { item: "bar".to_owned(), span: null_span},
|
|
/// # None
|
|
/// # )],
|
|
/// # };
|
|
/// assert!(!call.has_flag("foo").unwrap());
|
|
/// ```
|
|
///
|
|
/// Invoked as `my_command --foo=true`:
|
|
/// ```
|
|
/// # use nu_protocol::{Spanned, Span, Value};
|
|
/// # use nu_plugin_protocol::EvaluatedCall;
|
|
/// # let null_span = Span::new(0, 0);
|
|
/// # let call = EvaluatedCall {
|
|
/// # head: null_span,
|
|
/// # positional: Vec::new(),
|
|
/// # named: vec![(
|
|
/// # Spanned { item: "foo".to_owned(), span: null_span},
|
|
/// # Some(Value::bool(true, Span::unknown()))
|
|
/// # )],
|
|
/// # };
|
|
/// assert!(call.has_flag("foo").unwrap());
|
|
/// ```
|
|
///
|
|
/// Invoked as `my_command --foo=false`:
|
|
/// ```
|
|
/// # use nu_protocol::{Spanned, Span, Value};
|
|
/// # use nu_plugin_protocol::EvaluatedCall;
|
|
/// # let null_span = Span::new(0, 0);
|
|
/// # let call = EvaluatedCall {
|
|
/// # head: null_span,
|
|
/// # positional: Vec::new(),
|
|
/// # named: vec![(
|
|
/// # Spanned { item: "foo".to_owned(), span: null_span},
|
|
/// # Some(Value::bool(false, Span::unknown()))
|
|
/// # )],
|
|
/// # };
|
|
/// assert!(!call.has_flag("foo").unwrap());
|
|
/// ```
|
|
///
|
|
/// Invoked with wrong type as `my_command --foo=1`:
|
|
/// ```
|
|
/// # use nu_protocol::{Spanned, Span, Value};
|
|
/// # use nu_plugin_protocol::EvaluatedCall;
|
|
/// # let null_span = Span::new(0, 0);
|
|
/// # let call = EvaluatedCall {
|
|
/// # head: null_span,
|
|
/// # positional: Vec::new(),
|
|
/// # named: vec![(
|
|
/// # Spanned { item: "foo".to_owned(), span: null_span},
|
|
/// # Some(Value::int(1, Span::unknown()))
|
|
/// # )],
|
|
/// # };
|
|
/// assert!(call.has_flag("foo").is_err());
|
|
/// ```
|
|
pub fn has_flag(&self, flag_name: &str) -> Result<bool, ShellError> {
|
|
for name in &self.named {
|
|
if flag_name == name.0.item {
|
|
return match &name.1 {
|
|
Some(Value::Bool { val, .. }) => Ok(*val),
|
|
None => Ok(true),
|
|
Some(result) => Err(ShellError::CantConvert {
|
|
to_type: "bool".into(),
|
|
from_type: result.get_type().to_string(),
|
|
span: result.span(),
|
|
help: Some("".into()),
|
|
}),
|
|
};
|
|
}
|
|
}
|
|
|
|
Ok(false)
|
|
}
|
|
|
|
/// Returns the [`Value`] of an optional named argument
|
|
///
|
|
/// # Examples
|
|
/// Invoked as `my_command --foo 123`:
|
|
/// ```
|
|
/// # use nu_protocol::{Spanned, Span, Value};
|
|
/// # use nu_plugin_protocol::EvaluatedCall;
|
|
/// # let null_span = Span::new(0, 0);
|
|
/// # let call = EvaluatedCall {
|
|
/// # head: null_span,
|
|
/// # positional: Vec::new(),
|
|
/// # named: vec![(
|
|
/// # Spanned { item: "foo".to_owned(), span: null_span},
|
|
/// # Some(Value::int(123, null_span))
|
|
/// # )],
|
|
/// # };
|
|
/// let opt_foo = match call.get_flag_value("foo") {
|
|
/// Some(Value::Int { val, .. }) => Some(val),
|
|
/// None => None,
|
|
/// _ => panic!(),
|
|
/// };
|
|
/// assert_eq!(opt_foo, Some(123));
|
|
/// ```
|
|
///
|
|
/// Invoked as `my_command`:
|
|
/// ```
|
|
/// # use nu_protocol::{Spanned, Span, Value};
|
|
/// # use nu_plugin_protocol::EvaluatedCall;
|
|
/// # let null_span = Span::new(0, 0);
|
|
/// # let call = EvaluatedCall {
|
|
/// # head: null_span,
|
|
/// # positional: Vec::new(),
|
|
/// # named: vec![],
|
|
/// # };
|
|
/// let opt_foo = match call.get_flag_value("foo") {
|
|
/// Some(Value::Int { val, .. }) => Some(val),
|
|
/// None => None,
|
|
/// _ => panic!(),
|
|
/// };
|
|
/// assert_eq!(opt_foo, None);
|
|
/// ```
|
|
pub fn get_flag_value(&self, flag_name: &str) -> Option<Value> {
|
|
for name in &self.named {
|
|
if flag_name == name.0.item {
|
|
return name.1.clone();
|
|
}
|
|
}
|
|
|
|
None
|
|
}
|
|
|
|
/// Returns the [`Value`] of a given (zero indexed) positional argument, if present
|
|
///
|
|
/// Examples:
|
|
/// Invoked as `my_command a b c`:
|
|
/// ```
|
|
/// # use nu_protocol::{Spanned, Span, Value};
|
|
/// # use nu_plugin_protocol::EvaluatedCall;
|
|
/// # let null_span = Span::new(0, 0);
|
|
/// # let call = EvaluatedCall {
|
|
/// # head: null_span,
|
|
/// # positional: vec![
|
|
/// # Value::string("a".to_owned(), null_span),
|
|
/// # Value::string("b".to_owned(), null_span),
|
|
/// # Value::string("c".to_owned(), null_span),
|
|
/// # ],
|
|
/// # named: vec![],
|
|
/// # };
|
|
/// let arg = match call.nth(1) {
|
|
/// Some(Value::String { val, .. }) => val,
|
|
/// _ => panic!(),
|
|
/// };
|
|
/// assert_eq!(arg, "b".to_owned());
|
|
///
|
|
/// let arg = call.nth(7);
|
|
/// assert!(arg.is_none());
|
|
/// ```
|
|
pub fn nth(&self, pos: usize) -> Option<Value> {
|
|
self.positional.get(pos).cloned()
|
|
}
|
|
|
|
/// Returns the value of a named argument interpreted as type `T`
|
|
///
|
|
/// # Examples
|
|
/// Invoked as `my_command --foo 123`:
|
|
/// ```
|
|
/// # use nu_protocol::{Spanned, Span, Value};
|
|
/// # use nu_plugin_protocol::EvaluatedCall;
|
|
/// # let null_span = Span::new(0, 0);
|
|
/// # let call = EvaluatedCall {
|
|
/// # head: null_span,
|
|
/// # positional: Vec::new(),
|
|
/// # named: vec![(
|
|
/// # Spanned { item: "foo".to_owned(), span: null_span},
|
|
/// # Some(Value::int(123, null_span))
|
|
/// # )],
|
|
/// # };
|
|
/// let foo = call.get_flag::<i64>("foo");
|
|
/// assert_eq!(foo.unwrap(), Some(123));
|
|
/// ```
|
|
///
|
|
/// Invoked as `my_command --bar 123`:
|
|
/// ```
|
|
/// # use nu_protocol::{Spanned, Span, Value};
|
|
/// # use nu_plugin_protocol::EvaluatedCall;
|
|
/// # let null_span = Span::new(0, 0);
|
|
/// # let call = EvaluatedCall {
|
|
/// # head: null_span,
|
|
/// # positional: Vec::new(),
|
|
/// # named: vec![(
|
|
/// # Spanned { item: "bar".to_owned(), span: null_span},
|
|
/// # Some(Value::int(123, null_span))
|
|
/// # )],
|
|
/// # };
|
|
/// let foo = call.get_flag::<i64>("foo");
|
|
/// assert_eq!(foo.unwrap(), None);
|
|
/// ```
|
|
///
|
|
/// Invoked as `my_command --foo abc`:
|
|
/// ```
|
|
/// # use nu_protocol::{Spanned, Span, Value};
|
|
/// # use nu_plugin_protocol::EvaluatedCall;
|
|
/// # let null_span = Span::new(0, 0);
|
|
/// # let call = EvaluatedCall {
|
|
/// # head: null_span,
|
|
/// # positional: Vec::new(),
|
|
/// # named: vec![(
|
|
/// # Spanned { item: "foo".to_owned(), span: null_span},
|
|
/// # Some(Value::string("abc".to_owned(), null_span))
|
|
/// # )],
|
|
/// # };
|
|
/// let foo = call.get_flag::<i64>("foo");
|
|
/// assert!(foo.is_err());
|
|
/// ```
|
|
pub fn get_flag<T: FromValue>(&self, name: &str) -> Result<Option<T>, ShellError> {
|
|
if let Some(value) = self.get_flag_value(name) {
|
|
FromValue::from_value(value).map(Some)
|
|
} else {
|
|
Ok(None)
|
|
}
|
|
}
|
|
|
|
/// Retrieve the Nth and all following positional arguments as type `T`
|
|
///
|
|
/// # Example
|
|
/// Invoked as `my_command zero one two three`:
|
|
/// ```
|
|
/// # use nu_protocol::{Spanned, Span, Value};
|
|
/// # use nu_plugin_protocol::EvaluatedCall;
|
|
/// # let null_span = Span::new(0, 0);
|
|
/// # let call = EvaluatedCall {
|
|
/// # head: null_span,
|
|
/// # positional: vec![
|
|
/// # Value::string("zero".to_owned(), null_span),
|
|
/// # Value::string("one".to_owned(), null_span),
|
|
/// # Value::string("two".to_owned(), null_span),
|
|
/// # Value::string("three".to_owned(), null_span),
|
|
/// # ],
|
|
/// # named: Vec::new(),
|
|
/// # };
|
|
/// let args = call.rest::<String>(0);
|
|
/// assert_eq!(args.unwrap(), vec!["zero", "one", "two", "three"]);
|
|
///
|
|
/// let args = call.rest::<String>(2);
|
|
/// assert_eq!(args.unwrap(), vec!["two", "three"]);
|
|
/// ```
|
|
pub fn rest<T: FromValue>(&self, starting_pos: usize) -> Result<Vec<T>, ShellError> {
|
|
self.positional
|
|
.iter()
|
|
.skip(starting_pos)
|
|
.map(|value| FromValue::from_value(value.clone()))
|
|
.collect()
|
|
}
|
|
|
|
/// Retrieve the value of an optional positional argument interpreted as type `T`
|
|
///
|
|
/// Returns the value of a (zero indexed) positional argument of type `T`.
|
|
/// Alternatively returns [`None`] if the positional argument does not exist
|
|
/// or an error that can be passed back to the shell on error.
|
|
pub fn opt<T: FromValue>(&self, pos: usize) -> Result<Option<T>, ShellError> {
|
|
if let Some(value) = self.nth(pos) {
|
|
FromValue::from_value(value).map(Some)
|
|
} else {
|
|
Ok(None)
|
|
}
|
|
}
|
|
|
|
/// Retrieve the value of a mandatory positional argument as type `T`
|
|
///
|
|
/// Expect a positional argument of type `T` and return its value or, if the
|
|
/// argument does not exist or is of the wrong type, return an error that can
|
|
/// be passed back to the shell.
|
|
pub fn req<T: FromValue>(&self, pos: usize) -> Result<T, ShellError> {
|
|
if let Some(value) = self.nth(pos) {
|
|
FromValue::from_value(value)
|
|
} else if self.positional.is_empty() {
|
|
Err(ShellError::AccessEmptyContent { span: self.head })
|
|
} else {
|
|
Err(ShellError::AccessBeyondEnd {
|
|
max_idx: self.positional.len() - 1,
|
|
span: self.head,
|
|
})
|
|
}
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod test {
|
|
use super::*;
|
|
use nu_protocol::{Span, Spanned, Value};
|
|
|
|
#[test]
|
|
fn call_to_value() {
|
|
let call = EvaluatedCall {
|
|
head: Span::new(0, 10),
|
|
positional: vec![
|
|
Value::float(1.0, Span::new(0, 10)),
|
|
Value::string("something", Span::new(0, 10)),
|
|
],
|
|
named: vec![
|
|
(
|
|
Spanned {
|
|
item: "name".to_string(),
|
|
span: Span::new(0, 10),
|
|
},
|
|
Some(Value::float(1.0, Span::new(0, 10))),
|
|
),
|
|
(
|
|
Spanned {
|
|
item: "flag".to_string(),
|
|
span: Span::new(0, 10),
|
|
},
|
|
None,
|
|
),
|
|
],
|
|
};
|
|
|
|
let name: Option<f64> = call.get_flag("name").unwrap();
|
|
assert_eq!(name, Some(1.0));
|
|
|
|
assert!(call.has_flag("flag").unwrap());
|
|
|
|
let required: f64 = call.req(0).unwrap();
|
|
assert!((required - 1.0).abs() < f64::EPSILON);
|
|
|
|
let optional: Option<String> = call.opt(1).unwrap();
|
|
assert_eq!(optional, Some("something".to_string()));
|
|
|
|
let rest: Vec<String> = call.rest(1).unwrap();
|
|
assert_eq!(rest, vec!["something".to_string()]);
|
|
}
|
|
}
|