Mirrors/nushell
2
0
Fork 0
mirror of https://github.com/nushell/nushell synced 2024-12-27 05:23:11 +00:00
Code Issues Projects Releases Packages Wiki Activity

Span ID Refactor - Step 1 (#12960)

Browse source 
# Description
First part of SpanID refactoring series. This PR adds a `SpanId` type
and a corresponding `span_id` field to `Expression`. Parser creating
expressions will now add them to an array in `StateWorkingSet`,
generates a corresponding ID and saves the ID to the Expression. The IDs
are not used anywhere yet.

For the rough overall plan, see
https://github.com/nushell/nushell/issues/12963.

# User-Facing Changes
Hopefully none. This is only a refactor of Nushell's internals that
shouldn't have visible side effects.

# Tests + Formatting

# After Submitting
This commit is contained in:
Jakub Žádník 2024-06-05 04:57:14 +03:00 committed by GitHub
parent b10325dff1
commit e4104d0792
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
14 changed files with 1029 additions and 1050 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

22
crates/nu-cli/src/completions/custom_completions.rs
View file

@ -52,18 +52,16 @@ impl Completer for CustomCompletion {
decl_id: self.decl_id,
head: span,
arguments: vec![
Argument::Positional(Expression {
span: Span::unknown(),
ty: Type::String,
expr: Expr::String(self.line.clone()),
custom_completion: None,
}),
Argument::Positional(Expression {
span: Span::unknown(),
ty: Type::Int,
expr: Expr::Int(line_pos as i64),
custom_completion: None,
}),
Argument::Positional(Expression::new_unknown(
Expr::String(self.line.clone()),
Span::unknown(),
Type::String,
)),
Argument::Positional(Expression::new_unknown(
Expr::Int(line_pos as i64),
Span::unknown(),
Type::Int,
)),
],
parser_info: HashMap::new(),
},

7
crates/nu-command/src/system/run_external.rs
View file

@ -665,12 +665,7 @@ mod test {
#[test]
fn test_eval_argument() {
fn expression(expr: Expr) -> Expression {
Expression {
expr,
span: Span::unknown(),
ty: Type::Any,
custom_completion: None,
}
Expression::new_unknown(expr, Span::unknown(), Type::Any)
}
fn eval(expr: Expr, spread: bool) -> Result<Vec<String>, ShellError> {

54
crates/nu-engine/src/documentation.rs
View file

@ -2,9 +2,9 @@ use crate::eval_call;
use nu_protocol::{
ast::{Argument, Call, Expr, Expression, RecordItem},
debugger::WithoutDebug,
engine::{Command, EngineState, Stack},
record, Category, Example, IntoPipelineData, PipelineData, Signature, Span, SyntaxShape, Type,
Value,
engine::{Command, EngineState, Stack, UNKNOWN_SPAN_ID},
record, Category, Example, IntoPipelineData, PipelineData, Signature, Span, SpanId,
SyntaxShape, Type, Value,
};
use std::{collections::HashMap, fmt::Write};
@ -339,8 +339,9 @@ fn get_ansi_color_for_component_or_default(
if let Some(color) = &engine_state.get_config().color_config.get(theme_component) {
let caller_stack = &mut Stack::new().capture();
let span = Span::unknown();
let span_id = UNKNOWN_SPAN_ID;
let argument_opt = get_argument_for_color_value(engine_state, color, span);
let argument_opt = get_argument_for_color_value(engine_state, color, span, span_id);
// Call ansi command using argument
if let Some(argument) = argument_opt {
@ -371,6 +372,7 @@ fn get_argument_for_color_value(
engine_state: &EngineState,
color: &&Value,
span: Span,
span_id: SpanId,
) -> Option<Argument> {
match color {
Value::Record { val, .. } => {
@ -378,43 +380,43 @@ fn get_argument_for_color_value(
.iter()
.map(|(k, v)| {
RecordItem::Pair(
Expression {
expr: Expr::String(k.clone()),
Expression::new_existing(
Expr::String(k.clone()),
span,
ty: Type::String,
custom_completion: None,
},
Expression {
expr: Expr::String(
span_id,
Type::String,
),
Expression::new_existing(
Expr::String(
v.clone().to_expanded_string("", engine_state.get_config()),
),
span,
ty: Type::String,
custom_completion: None,
},
span_id,
Type::String,
),
)
})
.collect();
Some(Argument::Positional(Expression {
span: Span::unknown(),
ty: Type::Record(
Some(Argument::Positional(Expression::new_existing(
Expr::Record(record_exp),
Span::unknown(),
UNKNOWN_SPAN_ID,
Type::Record(
[
("fg".to_string(), Type::String),
("attr".to_string(), Type::String),
]
.into(),
),
expr: Expr::Record(record_exp),
custom_completion: None,
}))
)))
}
Value::String { val, .. } => Some(Argument::Positional(Expression {
span: Span::unknown(),
ty: Type::String,
expr: Expr::String(val.clone()),
custom_completion: None,
})),
Value::String { val, .. } => Some(Argument::Positional(Expression::new_existing(
Expr::String(val.clone()),
Span::unknown(),
UNKNOWN_SPAN_ID,
Type::String,
))),
_ => None,
}
}

56
crates/nu-parser/src/known_external.rs
View file

@ -1,7 +1,7 @@
use nu_engine::command_prelude::*;
use nu_protocol::{
ast::{Argument, Expr, Expression},
engine::CommandType,
engine::{CommandType, UNKNOWN_SPAN_ID},
};
#[derive(Clone)]
@ -56,43 +56,49 @@ impl Command for KnownExternal {
};
let extern_name: Vec<_> = extern_name.split(' ').collect();
let call_head_id = engine_state
.find_span_id(call.head)
.unwrap_or(UNKNOWN_SPAN_ID);
let arg_extern_name = Expression {
expr: Expr::String(extern_name[0].to_string()),
span: call.head,
ty: Type::String,
custom_completion: None,
};
let arg_extern_name = Expression::new_existing(
Expr::String(extern_name[0].to_string()),
call.head,
call_head_id,
Type::String,
);
extern_call.add_positional(arg_extern_name);
for subcommand in extern_name.into_iter().skip(1) {
extern_call.add_positional(Expression {
expr: Expr::String(subcommand.to_string()),
span: call.head,
ty: Type::String,
custom_completion: None,
});
extern_call.add_positional(Expression::new_existing(
Expr::String(subcommand.to_string()),
call.head,
call_head_id,
Type::String,
));
}
for arg in &call.arguments {
match arg {
Argument::Positional(positional) => extern_call.add_positional(positional.clone()),
Argument::Named(named) => {
let named_span_id = engine_state
.find_span_id(named.0.span)
.unwrap_or(UNKNOWN_SPAN_ID);
if let Some(short) = &named.1 {
extern_call.add_positional(Expression {
expr: Expr::String(format!("-{}", short.item)),
span: named.0.span,
ty: Type::String,
custom_completion: None,
});
extern_call.add_positional(Expression::new_existing(
Expr::String(format!("-{}", short.item)),
named.0.span,
named_span_id,
Type::String,
));
} else {
extern_call.add_positional(Expression {
expr: Expr::String(format!("--{}", named.0.item)),
span: named.0.span,
ty: Type::String,
custom_completion: None,
});
extern_call.add_positional(Expression::new_existing(
Expr::String(format!("--{}", named.0.item)),
named.0.span,
named_span_id,
Type::String,
));
}
if let Some(arg) = &named.2 {
extern_call.add_positional(arg.clone());

802
crates/nu-parser/src/parse_keywords.rs
View file

File diff suppressed because it is too large Load diff

891
crates/nu-parser/src/parser.rs
View file

File diff suppressed because it is too large Load diff

87
crates/nu-parser/src/type_check.rs
View file

@ -68,7 +68,7 @@ pub fn type_compatible(lhs: &Type, rhs: &Type) -> bool {
}
pub fn math_result_type(
_working_set: &StateWorkingSet,
working_set: &mut StateWorkingSet,
lhs: &mut Expression,
op: &mut Expression,
rhs: &mut Expression,
@ -104,7 +104,7 @@ pub fn math_result_type(
| Type::Filesize,
_,
) => {
*op = Expression::garbage(op.span);
*op = Expression::garbage(working_set, op.span);
(
Type::Any,
Some(ParseError::UnsupportedOperationRHS(
@ -118,7 +118,7 @@ pub fn math_result_type(
)
}
_ => {
*op = Expression::garbage(op.span);
*op = Expression::garbage(working_set, op.span);
(
Type::Any,
Some(ParseError::UnsupportedOperationLHS(
@ -130,7 +130,7 @@ pub fn math_result_type(
)
}
},
Operator::Math(Math::Append) => check_append(lhs, rhs, op),
Operator::Math(Math::Append) => check_append(working_set, lhs, rhs, op),
Operator::Math(Math::Minus) => match (&lhs.ty, &rhs.ty) {
(Type::Int, Type::Int) => (Type::Int, None),
(Type::Float, Type::Int) => (Type::Float, None),
@ -152,7 +152,7 @@ pub fn math_result_type(
(Type::Any, _) => (Type::Any, None),
(_, Type::Any) => (Type::Any, None),
(Type::Int | Type::Float | Type::Date | Type::Duration | Type::Filesize, _) => {
*op = Expression::garbage(op.span);
*op = Expression::garbage(working_set, op.span);
(
Type::Any,
Some(ParseError::UnsupportedOperationRHS(
@ -166,7 +166,7 @@ pub fn math_result_type(
)
}
_ => {
*op = Expression::garbage(op.span);
*op = Expression::garbage(working_set, op.span);
(
Type::Any,
Some(ParseError::UnsupportedOperationLHS(
@ -209,7 +209,7 @@ pub fn math_result_type(
| (Type::Duration, _)
| (Type::Filesize, _)
| (Type::List(_), _) => {
*op = Expression::garbage(op.span);
*op = Expression::garbage(working_set, op.span);
(
Type::Any,
Some(ParseError::UnsupportedOperationRHS(
@ -223,7 +223,7 @@ pub fn math_result_type(
)
}
_ => {
*op = Expression::garbage(op.span);
*op = Expression::garbage(working_set, op.span);
(
Type::Any,
Some(ParseError::UnsupportedOperationLHS(
@ -252,7 +252,7 @@ pub fn math_result_type(
(Type::Any, _) => (Type::Any, None),
(_, Type::Any) => (Type::Any, None),
(Type::Int | Type::Float, _) => {
*op = Expression::garbage(op.span);
*op = Expression::garbage(working_set, op.span);
(
Type::Any,
Some(ParseError::UnsupportedOperationRHS(
@ -266,7 +266,7 @@ pub fn math_result_type(
)
}
_ => {
*op = Expression::garbage(op.span);
*op = Expression::garbage(working_set, op.span);
(
Type::Any,
Some(ParseError::UnsupportedOperationLHS(
@ -302,7 +302,7 @@ pub fn math_result_type(
(Type::Any, _) => (Type::Any, None),
(_, Type::Any) => (Type::Any, None),
(Type::Int | Type::Float | Type::Filesize | Type::Duration, _) => {
*op = Expression::garbage(op.span);
*op = Expression::garbage(working_set, op.span);
(
Type::Any,
Some(ParseError::UnsupportedOperationRHS(
@ -316,7 +316,7 @@ pub fn math_result_type(
)
}
_ => {
*op = Expression::garbage(op.span);
*op = Expression::garbage(working_set, op.span);
(
Type::Any,
Some(ParseError::UnsupportedOperationLHS(
@ -348,7 +348,7 @@ pub fn math_result_type(
(Type::Any, _) => (Type::Any, None),
(_, Type::Any) => (Type::Any, None),
(Type::Int | Type::Float | Type::Filesize | Type::Duration, _) => {
*op = Expression::garbage(op.span);
*op = Expression::garbage(working_set, op.span);
(
Type::Any,
Some(ParseError::UnsupportedOperationRHS(
@ -362,7 +362,7 @@ pub fn math_result_type(
)
}
_ => {
*op = Expression::garbage(op.span);
*op = Expression::garbage(working_set, op.span);
(
Type::Any,
Some(ParseError::UnsupportedOperationLHS(
@ -390,7 +390,7 @@ pub fn math_result_type(
// definitions. As soon as that syntax is added this should be removed
(a, b) if a == b => (Type::Bool, None),
(Type::Bool, _) => {
*op = Expression::garbage(op.span);
*op = Expression::garbage(working_set, op.span);
(
Type::Any,
Some(ParseError::UnsupportedOperationRHS(
@ -404,7 +404,7 @@ pub fn math_result_type(
)
}
_ => {
*op = Expression::garbage(op.span);
*op = Expression::garbage(working_set, op.span);
(
Type::Any,
Some(ParseError::UnsupportedOperationLHS(
@ -441,7 +441,7 @@ pub fn math_result_type(
(Type::Any, _) => (Type::Bool, None),
(_, Type::Any) => (Type::Bool, None),
(Type::Int | Type::Float | Type::Duration | Type::Filesize, _) => {
*op = Expression::garbage(op.span);
*op = Expression::garbage(working_set, op.span);
(
Type::Any,
Some(ParseError::UnsupportedOperationRHS(
@ -455,7 +455,7 @@ pub fn math_result_type(
)
}
_ => {
*op = Expression::garbage(op.span);
*op = Expression::garbage(working_set, op.span);
(
Type::Any,
Some(ParseError::UnsupportedOperationLHS(
@ -491,7 +491,7 @@ pub fn math_result_type(
(Type::Any, _) => (Type::Bool, None),
(_, Type::Any) => (Type::Bool, None),
(Type::Int | Type::Float | Type::Duration | Type::Filesize, _) => {
*op = Expression::garbage(op.span);
*op = Expression::garbage(working_set, op.span);
(
Type::Any,
Some(ParseError::UnsupportedOperationRHS(
@ -505,7 +505,7 @@ pub fn math_result_type(
)
}
_ => {
*op = Expression::garbage(op.span);
*op = Expression::garbage(working_set, op.span);
(
Type::Any,
Some(ParseError::UnsupportedOperationLHS(
@ -541,7 +541,7 @@ pub fn math_result_type(
(Type::Nothing, _) => (Type::Nothing, None),
(_, Type::Nothing) => (Type::Nothing, None),
(Type::Int | Type::Float | Type::Duration | Type::Filesize, _) => {
*op = Expression::garbage(op.span);
*op = Expression::garbage(working_set, op.span);
(
Type::Any,
Some(ParseError::UnsupportedOperationRHS(
@ -555,7 +555,7 @@ pub fn math_result_type(
)
}
_ => {
*op = Expression::garbage(op.span);
*op = Expression::garbage(working_set, op.span);
(
Type::Any,
Some(ParseError::UnsupportedOperationLHS(
@ -591,7 +591,7 @@ pub fn math_result_type(
(Type::Nothing, _) => (Type::Nothing, None),
(_, Type::Nothing) => (Type::Nothing, None),
(Type::Int | Type::Float | Type::Duration | Type::Filesize, _) => {
*op = Expression::garbage(op.span);
*op = Expression::garbage(working_set, op.span);
(
Type::Any,
Some(ParseError::UnsupportedOperationRHS(
@ -605,7 +605,7 @@ pub fn math_result_type(
)
}
_ => {
*op = Expression::garbage(op.span);
*op = Expression::garbage(working_set, op.span);
(
Type::Any,
Some(ParseError::UnsupportedOperationLHS(
@ -638,7 +638,7 @@ pub fn math_result_type(
(Type::Custom(a), _) => (Type::Custom(a.clone()), None),
(Type::String, _) => {
*op = Expression::garbage(op.span);
*op = Expression::garbage(working_set, op.span);
(
Type::Any,
Some(ParseError::UnsupportedOperationRHS(
@ -652,7 +652,7 @@ pub fn math_result_type(
)
}
_ => {
*op = Expression::garbage(op.span);
*op = Expression::garbage(working_set, op.span);
(
Type::Any,
Some(ParseError::UnsupportedOperationLHS(
@ -673,7 +673,7 @@ pub fn math_result_type(
(Type::Custom(a), _) => (Type::Custom(a.clone()), None),
(Type::String, _) => {
*op = Expression::garbage(op.span);
*op = Expression::garbage(working_set, op.span);
(
Type::Any,
Some(ParseError::UnsupportedOperationRHS(
@ -687,7 +687,7 @@ pub fn math_result_type(
)
}
_ => {
*op = Expression::garbage(op.span);
*op = Expression::garbage(working_set, op.span);
(
Type::Any,
Some(ParseError::UnsupportedOperationLHS(
@ -708,7 +708,7 @@ pub fn math_result_type(
(Type::Custom(a), _) => (Type::Custom(a.clone()), None),
(Type::String, _) => {
*op = Expression::garbage(op.span);
*op = Expression::garbage(working_set, op.span);
(
Type::Any,
Some(ParseError::UnsupportedOperationRHS(
@ -722,7 +722,7 @@ pub fn math_result_type(
)
}
_ => {
*op = Expression::garbage(op.span);
*op = Expression::garbage(working_set, op.span);
(
Type::Any,
Some(ParseError::UnsupportedOperationLHS(
@ -743,7 +743,7 @@ pub fn math_result_type(
(Type::Custom(a), _) => (Type::Custom(a.clone()), None),
(Type::String, _) => {
*op = Expression::garbage(op.span);
*op = Expression::garbage(working_set, op.span);
(
Type::Any,
Some(ParseError::UnsupportedOperationRHS(
@ -757,7 +757,7 @@ pub fn math_result_type(
)
}
_ => {
*op = Expression::garbage(op.span);
*op = Expression::garbage(working_set, op.span);
(
Type::Any,
Some(ParseError::UnsupportedOperationLHS(
@ -781,7 +781,7 @@ pub fn math_result_type(
(Type::Any, _) => (Type::Bool, None),
(_, Type::Any) => (Type::Bool, None),
(Type::Int | Type::Float | Type::String, _) => {
*op = Expression::garbage(op.span);
*op = Expression::garbage(working_set, op.span);
(
Type::Any,
Some(ParseError::UnsupportedOperationRHS(
@ -795,7 +795,7 @@ pub fn math_result_type(
)
}
_ => {
*op = Expression::garbage(op.span);
*op = Expression::garbage(working_set, op.span);
(
Type::Any,
Some(ParseError::UnsupportedOperationLHS(
@ -819,7 +819,7 @@ pub fn math_result_type(
(Type::Any, _) => (Type::Bool, None),
(_, Type::Any) => (Type::Bool, None),
(Type::Int | Type::Float | Type::String, _) => {
*op = Expression::garbage(op.span);
*op = Expression::garbage(working_set, op.span);
(
Type::Any,
Some(ParseError::UnsupportedOperationRHS(
@ -833,7 +833,7 @@ pub fn math_result_type(
)
}
_ => {
*op = Expression::garbage(op.span);
*op = Expression::garbage(working_set, op.span);
(
Type::Any,
Some(ParseError::UnsupportedOperationLHS(
@ -855,7 +855,7 @@ pub fn math_result_type(
(Type::Any, _) => (Type::Any, None),
(_, Type::Any) => (Type::Any, None),
(Type::Int, _) => {
*op = Expression::garbage(op.span);
*op = Expression::garbage(working_set, op.span);
(
Type::Any,
Some(ParseError::UnsupportedOperationRHS(
@ -869,7 +869,7 @@ pub fn math_result_type(
)
}
_ => {
*op = Expression::garbage(op.span);
*op = Expression::garbage(working_set, op.span);
(
Type::Any,
Some(ParseError::UnsupportedOperationLHS(
@ -881,7 +881,9 @@ pub fn math_result_type(
)
}
},
Operator::Assignment(Assignment::AppendAssign) => check_append(lhs, rhs, op),
Operator::Assignment(Assignment::AppendAssign) => {
check_append(working_set, lhs, rhs, op)
}
Operator::Assignment(_) => match (&lhs.ty, &rhs.ty) {
(x, y) if x == y => (Type::Nothing, None),
(Type::Any, _) => (Type::Nothing, None),
@ -894,7 +896,7 @@ pub fn math_result_type(
},
},
_ => {
*op = Expression::garbage(op.span);
*op = Expression::garbage(working_set, op.span);
(
Type::Any,
@ -1026,6 +1028,7 @@ pub fn check_block_input_output(working_set: &StateWorkingSet, block: &Block) ->
}
fn check_append(
working_set: &mut StateWorkingSet,
lhs: &Expression,
rhs: &Expression,
op: &mut Expression,
@ -1050,7 +1053,7 @@ fn check_append(
(Type::Binary, Type::Binary) => (Type::Binary, None),
(Type::Any, _) | (_, Type::Any) => (Type::Any, None),
(Type::Table(_) | Type::String | Type::Binary, _) => {
*op = Expression::garbage(op.span);
*op = Expression::garbage(working_set, op.span);
(
Type::Any,
Some(ParseError::UnsupportedOperationRHS(
@ -1064,7 +1067,7 @@ fn check_append(
)
}
_ => {
*op = Expression::garbage(op.span);
*op = Expression::garbage(working_set, op.span);
(
Type::Any,
Some(ParseError::UnsupportedOperationLHS(

23
crates/nu-protocol/src/ast/call.rs
View file

@ -338,9 +338,13 @@ impl Call {
#[cfg(test)]
mod test {
use super::*;
use crate::engine::EngineState;
#[test]
fn argument_span_named() {
let engine_state = EngineState::new();
let mut working_set = StateWorkingSet::new(&engine_state);
let named = Spanned {
item: "named".to_string(),
span: Span::new(2, 3),
@ -349,7 +353,7 @@ mod test {
item: "short".to_string(),
span: Span::new(5, 7),
};
let expr = Expression::garbage(Span::new(11, 13));
let expr = Expression::garbage(&mut working_set, Span::new(11, 13));
let arg = Argument::Named((named.clone(), None, None));
@ -370,8 +374,11 @@ mod test {
#[test]
fn argument_span_positional() {
let engine_state = EngineState::new();
let mut working_set = StateWorkingSet::new(&engine_state);
let span = Span::new(2, 3);
let expr = Expression::garbage(span);
let expr = Expression::garbage(&mut working_set, span);
let arg = Argument::Positional(expr);
assert_eq!(span, arg.span());
@ -379,8 +386,11 @@ mod test {
#[test]
fn argument_span_unknown() {
let engine_state = EngineState::new();
let mut working_set = StateWorkingSet::new(&engine_state);
let span = Span::new(2, 3);
let expr = Expression::garbage(span);
let expr = Expression::garbage(&mut working_set, span);
let arg = Argument::Unknown(expr);
assert_eq!(span, arg.span());
@ -388,9 +398,12 @@ mod test {
#[test]
fn call_arguments_span() {
let engine_state = EngineState::new();
let mut working_set = StateWorkingSet::new(&engine_state);
let mut call = Call::new(Span::new(0, 1));
call.add_positional(Expression::garbage(Span::new(2, 3)));
call.add_positional(Expression::garbage(Span::new(5, 7)));
call.add_positional(Expression::garbage(&mut working_set, Span::new(2, 3)));
call.add_positional(Expression::garbage(&mut working_set, Span::new(5, 7)));
assert_eq!(Span::new(2, 7), call.arguments_span());
}

54
crates/nu-protocol/src/ast/expression.rs
View file

@ -1,7 +1,7 @@
use crate::{
ast::{Argument, Block, Expr, ExternalArgument, ImportPattern, MatchPattern, RecordItem},
engine::StateWorkingSet,
BlockId, DeclId, Signature, Span, Type, VarId, IN_VARIABLE_ID,
engine::{EngineState, StateWorkingSet},
BlockId, DeclId, Signature, Span, SpanId, Type, VarId, IN_VARIABLE_ID,
};
use serde::{Deserialize, Serialize};
use std::sync::Arc;
@ -10,15 +10,18 @@ use std::sync::Arc;
pub struct Expression {
pub expr: Expr,
pub span: Span,
pub span_id: SpanId,
pub ty: Type,
pub custom_completion: Option<DeclId>,
}
impl Expression {
pub fn garbage(span: Span) -> Expression {
pub fn garbage(working_set: &mut StateWorkingSet, span: Span) -> Expression {
let span_id = working_set.add_span(span);
Expression {
expr: Expr::Garbage,
span,
span_id,
ty: Type::Any,
custom_completion: None,
}
@ -471,4 +474,49 @@ impl Expression {
Expr::VarDecl(_) => {}
}
}
pub fn new(working_set: &mut StateWorkingSet, expr: Expr, span: Span, ty: Type) -> Expression {
let span_id = working_set.add_span(span);
Expression {
expr,
span,
span_id,
ty,
custom_completion: None,
}
}
pub fn new_existing(expr: Expr, span: Span, span_id: SpanId, ty: Type) -> Expression {
Expression {
expr,
span,
span_id,
ty,
custom_completion: None,
}
}
pub fn new_unknown(expr: Expr, span: Span, ty: Type) -> Expression {
Expression {
expr,
span,
span_id: SpanId(0),
ty,
custom_completion: None,
}
}
pub fn with_span_id(self, span_id: SpanId) -> Expression {
Expression {
expr: self.expr,
span: self.span,
span_id,
ty: self.ty,
custom_completion: self.custom_completion,
}
}
pub fn span(&self, engine_state: &EngineState) -> Span {
engine_state.get_span(self.span_id)
}
}

30
crates/nu-protocol/src/engine/engine_state.rs
View file

@ -8,7 +8,7 @@ use crate::{
},
eval_const::create_nu_constant,
BlockId, Category, Config, DeclId, FileId, HistoryConfig, Module, ModuleId, OverlayId,
ShellError, Signature, Span, Type, Value, VarId, VirtualPathId,
ShellError, Signature, Span, SpanId, Type, Value, VarId, VirtualPathId,
};
use fancy_regex::Regex;
use lru::LruCache;
@ -81,6 +81,7 @@ pub struct EngineState {
// especially long, so it helps
pub(super) blocks: Arc<Vec<Arc<Block>>>,
pub(super) modules: Arc<Vec<Arc<Module>>>,
pub spans: Vec<Span>,
usage: Usage,
pub scope: ScopeFrame,
pub ctrlc: Option<Arc<AtomicBool>>,
@ -115,6 +116,9 @@ pub const IN_VARIABLE_ID: usize = 1;
pub const ENV_VARIABLE_ID: usize = 2;
// NOTE: If you add more to this list, make sure to update the > checks based on the last in the list
// The first span is unknown span
pub const UNKNOWN_SPAN_ID: SpanId = SpanId(0);
impl EngineState {
pub fn new() -> Self {
Self {
@ -132,6 +136,7 @@ impl EngineState {
modules: Arc::new(vec![Arc::new(Module::new(
DEFAULT_OVERLAY_NAME.as_bytes().to_vec(),
))]),
spans: vec![Span::unknown()],
usage: Usage::new(),
// make sure we have some default overlay:
scope: ScopeFrame::with_empty_overlay(
@ -184,6 +189,7 @@ impl EngineState {
self.files.extend(delta.files);
self.virtual_paths.extend(delta.virtual_paths);
self.vars.extend(delta.vars);
self.spans.extend(delta.spans);
self.usage.merge_with(delta.usage);
// Avoid potentially cloning the Arcs if we aren't adding anything
@ -565,6 +571,9 @@ impl EngineState {
self.modules.len()
}
pub fn num_spans(&self) -> usize {
self.spans.len()
}
pub fn print_vars(&self) {
for var in self.vars.iter().enumerate() {
println!("var{}: {:?}", var.0, var.1);
@ -1019,6 +1028,25 @@ impl EngineState {
)));
}
}
/// Add new span and return its ID
pub fn add_span(&mut self, span: Span) -> SpanId {
self.spans.push(span);
SpanId(self.num_spans() - 1)
}
/// Get existing span
pub fn get_span(&self, span_id: SpanId) -> Span {
*self
.spans
.get(span_id.0)
.expect("internal error: missing span")
}
/// Find ID of a span (should be avoided if possible)
pub fn find_span_id(&self, span: Span) -> Option<SpanId> {
self.spans.iter().position(|sp| sp == &span).map(SpanId)
}
}
impl Default for EngineState {

4
crates/nu-protocol/src/engine/state_delta.rs
View file

@ -4,7 +4,7 @@ use crate::{
usage::Usage, CachedFile, Command, EngineState, OverlayFrame, ScopeFrame, Variable,
VirtualPath,
},
Module,
Module, Span,
};
use std::sync::Arc;
@ -21,6 +21,7 @@ pub struct StateDelta {
pub(super) decls: Vec<Box<dyn Command>>, // indexed by DeclId
pub blocks: Vec<Arc<Block>>, // indexed by BlockId
pub(super) modules: Vec<Arc<Module>>, // indexed by ModuleId
pub spans: Vec<Span>, // indexed by SpanId
pub(super) usage: Usage,
pub scope: Vec<ScopeFrame>,
#[cfg(feature = "plugin")]
@ -45,6 +46,7 @@ impl StateDelta {
decls: vec![],
blocks: vec![],
modules: vec![],
spans: vec![],
scope: vec![scope_frame],
usage: Usage::new(),
#[cfg(feature = "plugin")]

21
crates/nu-protocol/src/engine/state_working_set.rs
View file

@ -5,7 +5,7 @@ use crate::{
StateDelta, Variable, VirtualPath, Visibility,
},
BlockId, Category, Config, DeclId, FileId, Module, ModuleId, ParseError, ParseWarning, Span,
Type, Value, VarId, VirtualPathId,
SpanId, Type, Value, VarId, VirtualPathId,
};
use core::panic;
use std::{
@ -1013,6 +1013,25 @@ impl<'a> StateWorkingSet<'a> {
.expect("internal error: missing virtual path")
}
}
pub fn add_span(&mut self, span: Span) -> SpanId {
let num_permanent_spans = self.permanent_state.spans.len();
self.delta.spans.push(span);
SpanId(num_permanent_spans + self.delta.spans.len() - 1)
}
pub fn get_span(&self, span_id: SpanId) -> Span {
let num_permanent_spans = self.permanent_state.num_spans();
if span_id.0 < num_permanent_spans {
self.permanent_state.get_span(span_id)
} else {
*self
.delta
.spans
.get(span_id.0 - num_permanent_spans)
.expect("internal error: missing span")
}
}
}
impl<'a> miette::SourceCode for &StateWorkingSet<'a> {

4
crates/nu-protocol/src/id.rs
View file

@ -1,3 +1,5 @@
use serde::{Deserialize, Serialize};
pub type VarId = usize;
pub type DeclId = usize;
pub type BlockId = usize;
@ -5,3 +7,5 @@ pub type ModuleId = usize;
pub type OverlayId = usize;
pub type FileId = usize;
pub type VirtualPathId = usize;
#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
pub struct SpanId(pub usize); // more robust ID style used in the new parser

24
crates/nuon/src/from.rs
View file

@ -56,12 +56,12 @@ pub fn from_nuon(input: &str, span: Option<Span>) -> Result<Value, ShellError> {
}
let expr = if block.pipelines.is_empty() {
Expression {
expr: Expr::Nothing,
span: span.unwrap_or(Span::unknown()),
custom_completion: None,
ty: Type::Nothing,
}
Expression::new(
&mut working_set,
Expr::Nothing,
span.unwrap_or(Span::unknown()),
Type::Nothing,
)
} else {
let mut pipeline = Arc::make_mut(&mut block).pipelines.remove(0);
@ -81,12 +81,12 @@ pub fn from_nuon(input: &str, span: Option<Span>) -> Result<Value, ShellError> {
}
if pipeline.elements.is_empty() {
Expression {
expr: Expr::Nothing,
span: span.unwrap_or(Span::unknown()),
custom_completion: None,
ty: Type::Nothing,
}
Expression::new(
&mut working_set,
Expr::Nothing,
span.unwrap_or(Span::unknown()),
Type::Nothing,
)
} else {
pipeline.elements.remove(0).expr
}