extern/nushell
1
0
Fork 1
mirror of https://github.com/nushell/nushell.git synced 2025-05-29 14:21:45 +02:00
Code Issues Packages Projects Releases Wiki Activity

use unreachable! in run

Browse Source
This commit is contained in:
Loïc Riegel 2025-04-13 15:07:37 +02:00
parent dbc8da1f17
commit debc913eeb
12 changed files with 66 additions and 435 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
crates/nu-cmd-lang/src/core_commands/break_.rs
View File

@ -34,10 +34,12 @@ impl Command for Break {
&self,
_engine_state: &EngineState,
_stack: &mut Stack,
call: &Call,
_call: &Call,
_input: PipelineData,
) -> Result<PipelineData, ShellError> {
Err(ShellError::Break { span: call.head })
// This is compiled specially by the IR compiler. The code here is never used when
// running in IR mode.
unreachable!()
}
fn examples(&self) -> Vec<Example> {

29
crates/nu-cmd-lang/src/core_commands/const_.rs
View File

@ -41,35 +41,14 @@ impl Command for Const {
fn run(
&self,
engine_state: &EngineState,
stack: &mut Stack,
call: &Call,
_engine_state: &EngineState,
_stack: &mut Stack,
_call: &Call,
_input: PipelineData,
) -> Result<PipelineData, ShellError> {
// This is compiled specially by the IR compiler. The code here is never used when
// running in IR mode.
let call = call.assert_ast_call()?;
let var_id = if let Some(id) = call.positional_nth(0).and_then(|pos| pos.as_var()) {
id
} else {
return Err(ShellError::NushellFailedSpanned {
msg: "Could not get variable".to_string(),
label: "variable not added by the parser".to_string(),
span: call.head,
});
};
if let Some(constval) = &engine_state.get_var(var_id).const_val {
stack.add_var(var_id, constval.clone());
Ok(PipelineData::empty())
} else {
Err(ShellError::NushellFailedSpanned {
msg: "Missing Constant".to_string(),
label: "constant not added by the parser".to_string(),
span: call.head,
})
}
unreachable!()
}
fn run_const(

6
crates/nu-cmd-lang/src/core_commands/continue_.rs
View File

@ -33,10 +33,12 @@ impl Command for Continue {
&self,
_engine_state: &EngineState,
_stack: &mut Stack,
call: &Call,
_call: &Call,
_input: PipelineData,
) -> Result<PipelineData, ShellError> {
Err(ShellError::Continue { span: call.head })
// This is compiled specially by the IR compiler. The code here is never used when
// running in IR mode.
unreachable!()
}
fn examples(&self) -> Vec<Example> {

81
crates/nu-cmd-lang/src/core_commands/for_.rs
View File

@ -1,5 +1,5 @@
use nu_engine::{command_prelude::*, get_eval_block, get_eval_expression};
use nu_protocol::{engine::CommandType, Signals};
use nu_engine::command_prelude::*;
use nu_protocol::engine::CommandType;
#[derive(Clone)]
pub struct For;
@ -43,83 +43,14 @@ impl Command for For {
fn run(
&self,
engine_state: &EngineState,
stack: &mut Stack,
call: &Call,
_engine_state: &EngineState,
_stack: &mut Stack,
_call: &Call,
_input: PipelineData,
) -> Result<PipelineData, ShellError> {
// This is compiled specially by the IR compiler. The code here is never used when
// running in IR mode.
let call = call.assert_ast_call()?;
let head = call.head;
let var_id = call
.positional_nth(0)
.expect("checked through parser")
.as_var()
.expect("internal error: missing variable");
let keyword_expr = call
.positional_nth(1)
.expect("checked through parser")
.as_keyword()
.expect("internal error: missing keyword");
let block_id = call
.positional_nth(2)
.expect("checked through parser")
.as_block()
.expect("internal error: missing block");
let eval_expression = get_eval_expression(engine_state);
let eval_block = get_eval_block(engine_state);
let value = eval_expression(engine_state, stack, keyword_expr)?;
let engine_state = engine_state.clone();
let block = engine_state.get_block(block_id);
let stack = &mut stack.push_redirection(None, None);
let span = value.span();
match value {
Value::List { vals, .. } => {
for x in vals.into_iter() {
engine_state.signals().check(head)?;
// with_env() is used here to ensure that each iteration uses
// a different set of environment variables.
// Hence, a 'cd' in the first loop won't affect the next loop.
stack.add_var(var_id, x);
match eval_block(&engine_state, stack, block, PipelineData::empty()) {
Err(ShellError::Break { .. }) => break,
Err(ShellError::Continue { .. }) => continue,
Err(err) => return Err(err),
Ok(data) => data.drain()?,
}
}
}
Value::Range { val, .. } => {
for x in val.into_range_iter(span, Signals::empty()) {
engine_state.signals().check(head)?;
stack.add_var(var_id, x);
match eval_block(&engine_state, stack, block, PipelineData::empty()) {
Err(ShellError::Break { .. }) => break,
Err(ShellError::Continue { .. }) => continue,
Err(err) => return Err(err),
Ok(data) => data.drain()?,
}
}
}
x => {
stack.add_var(var_id, x);
eval_block(&engine_state, stack, block, PipelineData::empty())?.into_value(head)?;
}
}
Ok(PipelineData::empty())
unreachable!()
}
fn examples(&self) -> Vec<Example> {

45
crates/nu-cmd-lang/src/core_commands/if_.rs
View File

@ -1,6 +1,4 @@
use nu_engine::{
command_prelude::*, get_eval_block, get_eval_expression, get_eval_expression_with_input,
};
use nu_engine::command_prelude::*;
use nu_protocol::{
engine::{CommandType, StateWorkingSet},
eval_const::{eval_const_subexpression, eval_constant, eval_constant_with_input},
@ -60,8 +58,6 @@ impl Command for If {
call: &Call,
input: PipelineData,
) -> Result<PipelineData, ShellError> {
// This is compiled specially by the IR compiler. The code here is never used when
// running in IR mode.
let call = call.assert_ast_call()?;
let cond = call.positional_nth(0).expect("checked through parser");
let then_block = call
@ -97,43 +93,14 @@ impl Command for If {
fn run(
&self,
engine_state: &EngineState,
stack: &mut Stack,
call: &Call,
input: PipelineData,
_engine_state: &EngineState,
_stack: &mut Stack,
_call: &Call,
_input: PipelineData,
) -> Result<PipelineData, ShellError> {
// This is compiled specially by the IR compiler. The code here is never used when
// running in IR mode.
let call = call.assert_ast_call()?;
let cond = call.positional_nth(0).expect("checked through parser");
let then_block = call
.positional_nth(1)
.expect("checked through parser")
.as_block()
.expect("internal error: missing block");
let else_case = call.positional_nth(2);
let eval_expression = get_eval_expression(engine_state);
let eval_expression_with_input = get_eval_expression_with_input(engine_state);
let eval_block = get_eval_block(engine_state);
if eval_expression(engine_state, stack, cond)?.as_bool()? {
let block = engine_state.get_block(then_block);
eval_block(engine_state, stack, block, input)
} else if let Some(else_case) = else_case {
if let Some(else_expr) = else_case.as_keyword() {
if let Some(block_id) = else_expr.as_block() {
let block = engine_state.get_block(block_id);
eval_block(engine_state, stack, block, input)
} else {
eval_expression_with_input(engine_state, stack, else_expr, input)
}
} else {
eval_expression_with_input(engine_state, stack, else_case, input)
}
} else {
Ok(PipelineData::empty())
}
unreachable!()
}
fn search_terms(&self) -> Vec<&str> {

45
crates/nu-cmd-lang/src/core_commands/let_.rs
View File

@ -1,4 +1,4 @@
use nu_engine::{command_prelude::*, get_eval_block};
use nu_engine::command_prelude::*;
use nu_protocol::engine::CommandType;
#[derive(Clone)]
@ -41,47 +41,14 @@ impl Command for Let {
fn run(
&self,
engine_state: &EngineState,
stack: &mut Stack,
call: &Call,
input: PipelineData,
_engine_state: &EngineState,
_stack: &mut Stack,
_call: &Call,
_input: PipelineData,
) -> Result<PipelineData, ShellError> {
// This is compiled specially by the IR compiler. The code here is never used when
// running in IR mode.
let call = call.assert_ast_call()?;
let var_id = call
.positional_nth(0)
.expect("checked through parser")
.as_var()
.expect("internal error: missing variable");
let block_id = call
.positional_nth(1)
.expect("checked through parser")
.as_block()
.expect("internal error: missing right hand side");
let block = engine_state.get_block(block_id);
let eval_block = get_eval_block(engine_state);
let stack = &mut stack.start_collect_value();
let pipeline_data = eval_block(engine_state, stack, block, input)?;
let value = pipeline_data.into_value(call.head)?;
// if given variable type is Glob, and our result is string
// then nushell need to convert from Value::String to Value::Glob
// it's assigned by demand, then it's not quoted, and it's required to expand
// if we pass it to other commands.
let var_type = &engine_state.get_var(var_id).ty;
let val_span = value.span();
let value = match value {
Value::String { val, .. } if var_type == &Type::Glob => {
Value::glob(val, false, val_span)
}
value => value,
};
stack.add_var(var_id, value);
Ok(PipelineData::empty())
unreachable!()
}
fn examples(&self) -> Vec<Example> {

33
crates/nu-cmd-lang/src/core_commands/loop_.rs
View File

@ -1,4 +1,4 @@
use nu_engine::{command_prelude::*, get_eval_block};
use nu_engine::command_prelude::*;
use nu_protocol::engine::CommandType;
#[derive(Clone)]
@ -32,37 +32,14 @@ impl Command for Loop {
fn run(
&self,
engine_state: &EngineState,
stack: &mut Stack,
call: &Call,
_engine_state: &EngineState,
_stack: &mut Stack,
_call: &Call,
_input: PipelineData,
) -> Result<PipelineData, ShellError> {
// This is compiled specially by the IR compiler. The code here is never used when
// running in IR mode.
let call = call.assert_ast_call()?;
let head = call.head;
let block_id = call
.positional_nth(0)
.expect("checked through parser")
.as_block()
.expect("internal error: missing block");
let block = engine_state.get_block(block_id);
let eval_block = get_eval_block(engine_state);
let stack = &mut stack.push_redirection(None, None);
loop {
engine_state.signals().check(head)?;
match eval_block(engine_state, stack, block, PipelineData::empty()) {
Err(ShellError::Break { .. }) => break,
Err(ShellError::Continue { .. }) => continue,
Err(err) => return Err(err),
Ok(data) => data.drain()?,
}
}
Ok(PipelineData::empty())
unreachable!()
}
fn examples(&self) -> Vec<Example> {

60
crates/nu-cmd-lang/src/core_commands/match_.rs
View File

@ -1,7 +1,5 @@
use nu_engine::{
command_prelude::*, get_eval_block, get_eval_expression, get_eval_expression_with_input,
};
use nu_protocol::engine::{CommandType, Matcher};
use nu_engine::command_prelude::*;
use nu_protocol::engine::CommandType;
#[derive(Clone)]
pub struct Match;
@ -38,58 +36,14 @@ impl Command for Match {
fn run(
&self,
engine_state: &EngineState,
stack: &mut Stack,
call: &Call,
input: PipelineData,
_engine_state: &EngineState,
_stack: &mut Stack,
_call: &Call,
_input: PipelineData,
) -> Result<PipelineData, ShellError> {
// This is compiled specially by the IR compiler. The code here is never used when
// running in IR mode.
let call = call.assert_ast_call()?;
let value: Value = call.req(engine_state, stack, 0)?;
let matches = call
.positional_nth(1)
.expect("checked through parser")
.as_match_block()
.expect("missing match block");
let eval_expression = get_eval_expression(engine_state);
let eval_expression_with_input = get_eval_expression_with_input(engine_state);
let eval_block = get_eval_block(engine_state);
let mut match_variables = vec![];
for (pattern, expr) in matches {
if pattern.match_value(&value, &mut match_variables) {
// This case does match, go ahead and return the evaluated expression
for (id, value) in match_variables.drain(..) {
stack.add_var(id, value);
}
let guard_matches = if let Some(guard) = &pattern.guard {
let Value::Bool { val, .. } = eval_expression(engine_state, stack, guard)?
else {
return Err(ShellError::MatchGuardNotBool { span: guard.span });
};
val
} else {
true
};
if guard_matches {
return if let Some(block_id) = expr.as_block() {
let block = engine_state.get_block(block_id);
eval_block(engine_state, stack, block, input)
} else {
eval_expression_with_input(engine_state, stack, expr, input)
};
}
} else {
match_variables.clear();
}
}
Ok(PipelineData::Empty)
unreachable!()
}
fn examples(&self) -> Vec<Example> {

45
crates/nu-cmd-lang/src/core_commands/mut_.rs
View File

@ -1,4 +1,4 @@
use nu_engine::{command_prelude::*, get_eval_block};
use nu_engine::command_prelude::*;
use nu_protocol::engine::CommandType;
#[derive(Clone)]
@ -41,47 +41,14 @@ impl Command for Mut {
fn run(
&self,
engine_state: &EngineState,
stack: &mut Stack,
call: &Call,
input: PipelineData,
_engine_state: &EngineState,
_stack: &mut Stack,
_call: &Call,
_input: PipelineData,
) -> Result<PipelineData, ShellError> {
// This is compiled specially by the IR compiler. The code here is never used when
// running in IR mode.
let call = call.assert_ast_call()?;
let var_id = call
.positional_nth(0)
.expect("checked through parser")
.as_var()
.expect("internal error: missing variable");
let block_id = call
.positional_nth(1)
.expect("checked through parser")
.as_block()
.expect("internal error: missing right hand side");
let block = engine_state.get_block(block_id);
let eval_block = get_eval_block(engine_state);
let stack = &mut stack.start_collect_value();
let pipeline_data = eval_block(engine_state, stack, block, input)?;
let value = pipeline_data.into_value(call.head)?;
// if given variable type is Glob, and our result is string
// then nushell need to convert from Value::String to Value::Glob
// it's assigned by demand, then it's not quoted, and it's required to expand
// if we pass it to other commands.
let var_type = &engine_state.get_var(var_id).ty;
let val_span = value.span();
let value = match value {
Value::String { val, .. } if var_type == &Type::Glob => {
Value::glob(val, false, val_span)
}
value => value,
};
stack.add_var(var_id, value);
Ok(PipelineData::empty())
unreachable!()
}
fn examples(&self) -> Vec<Example> {

15
crates/nu-cmd-lang/src/core_commands/return_.rs
View File

@ -35,17 +35,14 @@ impl Command for Return {
fn run(
&self,
engine_state: &EngineState,
stack: &mut Stack,
call: &Call,
_engine_state: &EngineState,
_stack: &mut Stack,
_call: &Call,
_input: PipelineData,
) -> Result<PipelineData, ShellError> {
let return_value: Option<Value> = call.opt(engine_state, stack, 0)?;
let value = return_value.unwrap_or(Value::nothing(call.head));
Err(ShellError::Return {
span: call.head,
value: Box::new(value),
})
// This is compiled specially by the IR compiler. The code here is never used when
// running in IR mode.
unreachable!()
}
fn examples(&self) -> Vec<Example> {

82
crates/nu-cmd-lang/src/core_commands/try_.rs
View File

@ -1,5 +1,5 @@
use nu_engine::{command_prelude::*, get_eval_block, EvalBlockFn};
use nu_protocol::engine::{Closure, CommandType};
use nu_engine::command_prelude::*;
use nu_protocol::engine::CommandType;
#[derive(Clone)]
pub struct Try;
@ -42,36 +42,14 @@ impl Command for Try {
fn run(
&self,
engine_state: &EngineState,
stack: &mut Stack,
call: &Call,
input: PipelineData,
_engine_state: &EngineState,
_stack: &mut Stack,
_call: &Call,
_input: PipelineData,
) -> Result<PipelineData, ShellError> {
let head = call.head;
// This is compiled specially by the IR compiler. The code here is never used when
// running in IR mode.
let call = call.assert_ast_call()?;
let try_block = call
.positional_nth(0)
.expect("checked through parser")
.as_block()
.expect("internal error: missing block");
let catch_block: Option<Closure> = call.opt(engine_state, stack, 1)?;
let try_block = engine_state.get_block(try_block);
let eval_block = get_eval_block(engine_state);
let result = eval_block(engine_state, stack, try_block, input)
.and_then(|pipeline| pipeline.drain_to_out_dests(engine_state, stack));
match result {
Err(err) => run_catch(err, head, catch_block, engine_state, stack, eval_block),
Ok(PipelineData::Value(Value::Error { error, .. }, ..)) => {
run_catch(*error, head, catch_block, engine_state, stack, eval_block)
}
Ok(pipeline) => Ok(pipeline),
}
unreachable!();
}
fn examples(&self) -> Vec<Example> {
@ -95,52 +73,6 @@ impl Command for Try {
}
}
fn run_catch(
error: ShellError,
span: Span,
catch: Option<Closure>,
engine_state: &EngineState,
stack: &mut Stack,
eval_block: EvalBlockFn,
) -> Result<PipelineData, ShellError> {
let error = intercept_block_control(error)?;
if let Some(catch) = catch {
stack.set_last_error(&error);
let error = error.into_value(&StateWorkingSet::new(engine_state), span);
let block = engine_state.get_block(catch.block_id);
// Put the error value in the positional closure var
if let Some(var) = block.signature.get_positional(0) {
if let Some(var_id) = &var.var_id {
stack.add_var(*var_id, error.clone());
}
}
eval_block(
engine_state,
stack,
block,
// Make the error accessible with $in, too
error.into_pipeline_data(),
)
} else {
Ok(PipelineData::empty())
}
}
/// The flow control commands `break`/`continue`/`return` emit their own [`ShellError`] variants
/// We need to ignore those in `try` and bubble them through
///
/// `Err` when flow control to bubble up with `?`
fn intercept_block_control(error: ShellError) -> Result<ShellError, ShellError> {
match error {
ShellError::Break { .. } => Err(error),
ShellError::Continue { .. } => Err(error),
ShellError::Return { .. } => Err(error),
_ => Ok(error),
}
}
#[cfg(test)]
mod test {
use super::*;

54
crates/nu-cmd-lang/src/core_commands/while_.rs
View File

@ -1,4 +1,4 @@
use nu_engine::{command_prelude::*, get_eval_block, get_eval_expression};
use nu_engine::command_prelude::*;
use nu_protocol::engine::CommandType;
#[derive(Clone)]
@ -41,58 +41,14 @@ impl Command for While {
fn run(
&self,
engine_state: &EngineState,
stack: &mut Stack,
call: &Call,
_engine_state: &EngineState,
_stack: &mut Stack,
_call: &Call,
_input: PipelineData,
) -> Result<PipelineData, ShellError> {
// This is compiled specially by the IR compiler. The code here is never used when
// running in IR mode.
let call = call.assert_ast_call()?;
let head = call.head;
let cond = call.positional_nth(0).expect("checked through parser");
let block_id = call
.positional_nth(1)
.expect("checked through parser")
.as_block()
.expect("internal error: missing block");
let eval_expression = get_eval_expression(engine_state);
let eval_block = get_eval_block(engine_state);
let stack = &mut stack.push_redirection(None, None);
loop {
engine_state.signals().check(head)?;
let result = eval_expression(engine_state, stack, cond)?;
match &result {
Value::Bool { val, .. } => {
if *val {
let block = engine_state.get_block(block_id);
match eval_block(engine_state, stack, block, PipelineData::empty()) {
Err(ShellError::Break { .. }) => break,
Err(ShellError::Continue { .. }) => continue,
Err(err) => return Err(err),
Ok(data) => data.drain()?,
}
} else {
break;
}
}
x => {
return Err(ShellError::CantConvert {
to_type: "bool".into(),
from_type: x.get_type().to_string(),
span: result.span(),
help: None,
})
}
}
}
Ok(PipelineData::empty())
unreachable!()
}
fn examples(&self) -> Vec<Example> {