nushell/crates/nu-parser/src/parser.rs

5439 lines
180 KiB
Rust
Raw Normal View History

2021-09-02 10:25:22 +02:00
use crate::{
lex, lite_parse,
lite_parse::LiteCommand,
parse_keywords::{parse_extern, parse_for, parse_source},
2021-09-02 10:25:22 +02:00
type_check::{math_result_type, type_compatible},
LiteBlock, ParseError, Token, TokenContents,
2021-08-17 01:00:00 +02:00
};
2021-07-02 03:42:25 +02:00
2021-09-02 03:29:43 +02:00
use nu_protocol::{
ast::{
Argument, Block, Call, CellPath, Expr, Expression, FullCellPath, ImportPattern,
ImportPatternHead, ImportPatternMember, Operator, PathMember, Pipeline, RangeInclusion,
RangeOperator,
},
2021-09-02 20:21:37 +02:00
engine::StateWorkingSet,
span, BlockId, Flag, PositionalArg, Signature, Span, Spanned, SyntaxShape, Type, Unit, VarId,
ENV_VARIABLE_ID, IN_VARIABLE_ID,
2021-09-02 03:29:43 +02:00
};
2021-07-23 23:19:30 +02:00
2021-09-26 20:39:19 +02:00
use crate::parse_keywords::{
Overlays (#5375) * WIP: Start laying overlays * Rename Overlay->Module; Start adding overlay * Revamp adding overlay * Add overlay add tests; Disable debug print * Fix overlay add; Add overlay remove * Add overlay remove tests * Add missing overlay remove file * Add overlay list command * (WIP?) Enable overlays for env vars * Move OverlayFrames to ScopeFrames * (WIP) Move everything to overlays only ScopeFrame contains nothing but overlays now * Fix predecls * Fix wrong overlay id translation and aliases * Fix broken env lookup logic * Remove TODOs * Add overlay add + remove for environment * Add a few overlay tests; Fix overlay add name * Some cleanup; Fix overlay add/remove names * Clippy * Fmt * Remove walls of comments * List overlays from stack; Add debugging flag Currently, the engine state ordering is somehow broken. * Fix (?) overlay list test * Fix tests on Windows * Fix activated overlay ordering * Check for active overlays equality in overlay list This removes the -p flag: Either both parser and engine will have the same overlays, or the command will fail. * Add merging on overlay remove * Change help message and comment * Add some remove-merge/discard tests * (WIP) Track removed overlays properly * Clippy; Fmt * Fix getting last overlay; Fix predecls in overlays * Remove merging; Fix re-add overwriting stuff Also some error message tweaks. * Fix overlay error in the engine * Update variable_completions.rs * Adds flags and optional arguments to view-source (#5446) * added flags and optional arguments to view-source * removed redundant code * removed redundant code * fmt * fix bug in shell_integration (#5450) * fix bug in shell_integration * add some comments * enable cd to work with directory abbreviations (#5452) * enable cd to work with abbreviations * add abbreviation example * fix tests * make it configurable * make cd recornize symblic link (#5454) * implement seq char command to generate single character sequence (#5453) * add tmp code * add seq char command * Add split number flag in `split row` (#5434) Signed-off-by: Yuheng Su <gipsyh.icu@gmail.com> * Add two more overlay tests * Add ModuleId to OverlayFrame * Fix env conversion accidentally activating overlay It activated overlay from permanent state prematurely which would cause `overlay add` to misbehave. * Remove unused parameter; Add overlay list test * Remove added traces * Add overlay commands examples * Modify TODO * Fix $nu.scope iteration * Disallow removing default overlay * Refactor some parser errors * Remove last overlay if no argument * Diversify overlay examples * Make it possible to update overlay's module In case the origin module updates, the overlay add loads the new module, makes it overlay's origin and applies the changes. Before, it was impossible to update the overlay if the module changed. Co-authored-by: JT <547158+jntrnr@users.noreply.github.com> Co-authored-by: pwygab <88221256+merelymyself@users.noreply.github.com> Co-authored-by: Darren Schroeder <343840+fdncred@users.noreply.github.com> Co-authored-by: WindSoilder <WindSoilder@outlook.com> Co-authored-by: Yuheng Su <gipsyh.icu@gmail.com>
2022-05-07 21:39:22 +02:00
parse_alias, parse_def, parse_def_predecl, parse_hide, parse_let, parse_module, parse_overlay,
parse_use,
2021-09-02 03:29:43 +02:00
};
2021-07-23 23:19:30 +02:00
2022-06-17 20:11:48 +02:00
use itertools::Itertools;
2022-01-01 22:42:50 +01:00
use log::trace;
2022-03-01 00:31:53 +01:00
use std::{
collections::{HashMap, HashSet},
num::ParseIntError,
};
2021-11-02 21:56:00 +01:00
#[cfg(feature = "plugin")]
use crate::parse_keywords::parse_register;
2021-11-02 21:56:00 +01:00
2021-07-02 09:15:30 +02:00
#[derive(Debug, Clone)]
2021-06-30 03:42:56 +02:00
pub enum Import {}
2021-09-26 20:39:19 +02:00
pub fn garbage(span: Span) -> Expression {
2021-07-01 02:01:04 +02:00
Expression::garbage(span)
}
pub fn garbage_pipeline(spans: &[Span]) -> Pipeline {
Pipeline::from_vec(vec![garbage(span(spans))])
2021-09-10 09:28:43 +02:00
}
2021-07-01 03:31:02 +02:00
fn is_identifier_byte(b: u8) -> bool {
b != b'.'
&& b != b'['
&& b != b'('
&& b != b'{'
&& b != b'+'
&& b != b'-'
&& b != b'*'
&& b != b'^'
&& b != b'/'
&& b != b'='
&& b != b'!'
&& b != b'<'
&& b != b'>'
&& b != b'&'
&& b != b'|'
2021-07-01 03:31:02 +02:00
}
pub fn is_math_expression_like(
working_set: &mut StateWorkingSet,
span: Span,
expand_aliases_denylist: &[usize],
) -> bool {
let bytes = working_set.get_span_contents(span);
if bytes.is_empty() {
return false;
}
2022-04-06 21:10:25 +02:00
if bytes == b"true" || bytes == b"false" || bytes == b"null" || bytes == b"not" {
return true;
}
let b = bytes[0];
if b == b'('
|| b == b'{'
|| b == b'['
|| b == b'$'
|| b == b'"'
|| b == b'\''
|| b == b'`'
|| b == b'-'
{
return true;
}
if parse_number(bytes, span).1.is_none() {
return true;
}
if parse_filesize(working_set, span).1.is_none() {
return true;
}
if parse_duration(working_set, span).1.is_none() {
return true;
}
if parse_datetime(working_set, span).1.is_none() {
return true;
}
if parse_binary(working_set, span).1.is_none() {
return true;
}
if parse_range(working_set, span, expand_aliases_denylist)
.1
.is_none()
{
return true;
}
false
}
2021-07-01 03:31:02 +02:00
fn is_identifier(bytes: &[u8]) -> bool {
bytes.iter().all(|x| is_identifier_byte(*x))
}
fn is_variable(bytes: &[u8]) -> bool {
if bytes.len() > 1 && bytes[0] == b'$' {
is_identifier(&bytes[1..])
} else {
is_identifier(bytes)
}
}
2021-11-14 20:40:26 +01:00
pub fn trim_quotes(bytes: &[u8]) -> &[u8] {
if (bytes.starts_with(b"\"") && bytes.ends_with(b"\"") && bytes.len() > 1)
|| (bytes.starts_with(b"\'") && bytes.ends_with(b"\'") && bytes.len() > 1)
|| (bytes.starts_with(b"`") && bytes.ends_with(b"`") && bytes.len() > 1)
2021-11-14 20:40:26 +01:00
{
&bytes[1..(bytes.len() - 1)]
} else {
bytes
}
}
pub fn trim_quotes_str(s: &str) -> &str {
if (s.starts_with('"') && s.ends_with('"') && s.len() > 1)
|| (s.starts_with('\'') && s.ends_with('\'') && s.len() > 1)
|| (s.starts_with('`') && s.ends_with('`') && s.len() > 1)
{
&s[1..(s.len() - 1)]
} else {
s
}
}
pub fn check_call(command: Span, sig: &Signature, call: &Call) -> Option<ParseError> {
2021-10-13 19:53:27 +02:00
// Allow the call to pass if they pass in the help flag
if call.named_iter().any(|(n, _, _)| n.item == "help") {
2021-10-13 19:53:27 +02:00
return None;
}
if call.positional_len() < sig.required_positional.len() {
// Comparing the types of all signature positional arguments against the parsed
// expressions found in the call. If one type is not found then it could be assumed
// that that positional argument is missing from the parsed call
for argument in &sig.required_positional {
let found = call.positional_iter().fold(false, |ac, expr| {
if argument.shape.to_type() == expr.ty || argument.shape == SyntaxShape::Any {
true
} else {
ac
}
});
if !found {
if let Some(last) = call.positional_iter().last() {
2022-01-04 00:14:33 +01:00
return Some(ParseError::MissingPositional(
argument.name.clone(),
Span {
start: last.span.end,
end: last.span.end,
},
sig.call_signature(),
));
} else {
return Some(ParseError::MissingPositional(
argument.name.clone(),
Span {
start: command.end,
end: command.end,
},
2022-01-04 00:14:33 +01:00
sig.call_signature(),
));
}
}
}
let missing = &sig.required_positional[call.positional_len()];
if let Some(last) = call.positional_iter().last() {
2022-01-04 00:14:33 +01:00
Some(ParseError::MissingPositional(
missing.name.clone(),
Span {
start: last.span.end,
end: last.span.end,
},
sig.call_signature(),
))
} else {
Some(ParseError::MissingPositional(
missing.name.clone(),
Span {
start: command.end,
end: command.end,
},
2022-01-04 00:14:33 +01:00
sig.call_signature(),
))
}
2021-07-02 04:22:54 +02:00
} else {
for req_flag in sig.named.iter().filter(|x| x.required) {
if call.named_iter().all(|(n, _, _)| n.item != req_flag.long) {
2021-07-02 04:22:54 +02:00
return Some(ParseError::MissingRequiredFlag(
req_flag.long.clone(),
command,
));
}
}
None
}
}
2021-09-26 20:39:19 +02:00
pub fn check_name<'a>(
2021-09-02 10:25:22 +02:00
working_set: &mut StateWorkingSet,
2021-09-13 21:59:11 +02:00
spans: &'a [Span],
) -> Option<(&'a Span, ParseError)> {
if spans.len() == 1 {
None
} else if spans.len() < 4 {
if working_set.get_span_contents(spans[1]) == b"=" {
let name = String::from_utf8_lossy(working_set.get_span_contents(spans[0]));
Some((
&spans[1],
ParseError::AssignmentMismatch(
format!("{} missing name", name),
"missing name".into(),
spans[1],
),
))
} else {
None
}
2021-09-10 09:28:43 +02:00
} else if working_set.get_span_contents(spans[2]) != b"=" {
2021-09-13 21:59:11 +02:00
let name = String::from_utf8_lossy(working_set.get_span_contents(spans[0]));
Some((
&spans[2],
ParseError::AssignmentMismatch(
format!("{} missing sign", name),
"missing equal sign".into(),
spans[2],
),
2021-09-10 09:28:43 +02:00
))
} else {
None
}
}
2021-09-02 10:25:22 +02:00
pub fn parse_external_call(
2021-10-08 23:51:47 +02:00
working_set: &mut StateWorkingSet,
2021-09-02 10:25:22 +02:00
spans: &[Span],
expand_aliases_denylist: &[usize],
2021-09-02 10:25:22 +02:00
) -> (Expression, Option<ParseError>) {
trace!("parse external");
2021-09-02 10:25:22 +02:00
let mut args = vec![];
let head_contents = working_set.get_span_contents(spans[0]);
let head_span = if head_contents.starts_with(b"^") {
Span {
start: spans[0].start + 1,
end: spans[0].end,
}
} else {
spans[0]
};
2022-03-03 20:05:55 +01:00
let head_contents = working_set.get_span_contents(head_span).to_vec();
2021-10-08 23:51:47 +02:00
let mut error = None;
let head = if head_contents.starts_with(b"$") || head_contents.starts_with(b"(") {
let (arg, err) = parse_expression(working_set, &[head_span], expand_aliases_denylist);
error = error.or(err);
Box::new(arg)
} else {
let (contents, err) = unescape_unquote_string(&head_contents, head_span);
error = error.or(err);
Box::new(Expression {
expr: Expr::String(contents),
span: head_span,
ty: Type::String,
custom_completion: None,
})
};
2021-09-02 10:25:22 +02:00
for span in &spans[1..] {
2021-10-08 23:51:47 +02:00
let contents = working_set.get_span_contents(*span);
if contents.starts_with(b"$") || contents.starts_with(b"(") {
let (arg, err) = parse_dollar_expr(working_set, *span, expand_aliases_denylist);
error = error.or(err);
args.push(arg);
} else if contents.starts_with(b"[") {
let (arg, err) = parse_list_expression(
working_set,
*span,
&SyntaxShape::Any,
expand_aliases_denylist,
);
2021-10-08 23:51:47 +02:00
error = error.or(err);
args.push(arg);
} else {
// Eval stage trims the quotes, so we don't have to do the same thing when parsing.
let contents = String::from_utf8_lossy(contents).to_string();
2021-10-08 23:51:47 +02:00
args.push(Expression {
expr: Expr::String(contents),
2021-10-08 23:51:47 +02:00
span: *span,
ty: Type::String,
custom_completion: None,
})
}
2021-07-01 02:01:04 +02:00
}
2021-09-02 10:25:22 +02:00
(
Expression {
expr: Expr::ExternalCall(head, args),
2021-09-02 10:25:22 +02:00
span: span(spans),
ty: Type::Any,
custom_completion: None,
2021-09-02 10:25:22 +02:00
},
2021-10-08 23:51:47 +02:00
error,
2021-09-02 10:25:22 +02:00
)
}
2021-07-01 02:01:04 +02:00
2021-09-02 10:25:22 +02:00
fn parse_long_flag(
working_set: &mut StateWorkingSet,
spans: &[Span],
spans_idx: &mut usize,
sig: &Signature,
expand_aliases_denylist: &[usize],
) -> (
Option<Spanned<String>>,
Option<Expression>,
Option<ParseError>,
) {
2021-09-02 10:25:22 +02:00
let arg_span = spans[*spans_idx];
let arg_contents = working_set.get_span_contents(arg_span);
if arg_contents.starts_with(b"--") {
2021-10-12 19:44:23 +02:00
// FIXME: only use the first flag you find?
2021-09-02 10:25:22 +02:00
let split: Vec<_> = arg_contents.split(|x| *x == b'=').collect();
let long_name = String::from_utf8(split[0].into());
if let Ok(long_name) = long_name {
2021-10-13 19:53:27 +02:00
let long_name = long_name[2..].to_string();
2021-09-02 10:25:22 +02:00
if let Some(flag) = sig.get_long_flag(&long_name) {
if let Some(arg_shape) = &flag.arg {
if split.len() > 1 {
// and we also have the argument
let long_name_len = long_name.len();
2021-09-02 10:25:22 +02:00
let mut span = arg_span;
span.start += long_name_len + 3; //offset by long flag and '='
let (arg, err) =
parse_value(working_set, span, arg_shape, expand_aliases_denylist);
2021-09-02 10:25:22 +02:00
(
Some(Spanned {
item: long_name,
span: Span {
start: arg_span.start,
end: arg_span.start + long_name_len + 2,
},
}),
Some(arg),
err,
)
2021-09-02 10:25:22 +02:00
} else if let Some(arg) = spans.get(*spans_idx + 1) {
let (arg, err) =
parse_value(working_set, *arg, arg_shape, expand_aliases_denylist);
2021-09-02 10:25:22 +02:00
*spans_idx += 1;
(
Some(Spanned {
item: long_name,
span: arg_span,
}),
Some(arg),
err,
)
2021-07-08 22:29:00 +02:00
} else {
2021-09-02 10:25:22 +02:00
(
Some(Spanned {
item: long_name,
span: arg_span,
}),
2021-09-02 10:25:22 +02:00
None,
2022-01-04 00:14:33 +01:00
Some(ParseError::MissingFlagParam(
arg_shape.to_string(),
arg_span,
)),
2021-09-02 10:25:22 +02:00
)
2021-07-08 22:29:00 +02:00
}
} else {
2021-09-02 10:25:22 +02:00
// A flag with no argument
(
Some(Spanned {
item: long_name,
span: arg_span,
}),
None,
None,
)
2021-07-08 22:29:00 +02:00
}
} else {
2021-09-02 10:25:22 +02:00
(
Some(Spanned {
item: long_name.clone(),
span: arg_span,
}),
2021-09-02 10:25:22 +02:00
None,
2021-09-21 06:03:06 +02:00
Some(ParseError::UnknownFlag(
sig.name.clone(),
long_name.clone(),
arg_span,
)),
2021-09-02 10:25:22 +02:00
)
2021-07-08 22:29:00 +02:00
}
} else {
(
Some(Spanned {
item: "--".into(),
span: arg_span,
}),
None,
Some(ParseError::NonUtf8(arg_span)),
)
2021-07-08 22:29:00 +02:00
}
2021-09-02 10:25:22 +02:00
} else {
(None, None, None)
2021-07-08 22:29:00 +02:00
}
2021-09-02 10:25:22 +02:00
}
2021-07-08 22:29:00 +02:00
2021-09-02 10:25:22 +02:00
fn parse_short_flags(
working_set: &mut StateWorkingSet,
spans: &[Span],
spans_idx: &mut usize,
positional_idx: usize,
sig: &Signature,
) -> (Option<Vec<Flag>>, Option<ParseError>) {
let mut error = None;
let arg_span = spans[*spans_idx];
let arg_contents = working_set.get_span_contents(arg_span);
if arg_contents.starts_with(b"-") && arg_contents.len() > 1 {
let short_flags = &arg_contents[1..];
let mut found_short_flags = vec![];
let mut unmatched_short_flags = vec![];
for short_flag in short_flags.iter().enumerate() {
let short_flag_char = char::from(*short_flag.1);
let orig = arg_span;
let short_flag_span = Span {
start: orig.start + 1 + short_flag.0,
end: orig.start + 1 + short_flag.0 + 1,
};
if let Some(flag) = sig.get_short_flag(short_flag_char) {
// If we require an arg and are in a batch of short flags, error
if !found_short_flags.is_empty() && flag.arg.is_some() {
error = error.or(Some(ParseError::ShortFlagBatchCantTakeArg(short_flag_span)))
2021-07-08 22:29:00 +02:00
}
2021-09-02 10:25:22 +02:00
found_short_flags.push(flag);
} else {
unmatched_short_flags.push(short_flag_span);
2021-07-08 22:29:00 +02:00
}
2021-09-02 10:25:22 +02:00
}
2021-07-08 22:29:00 +02:00
2021-09-02 10:25:22 +02:00
if found_short_flags.is_empty() {
// check to see if we have a negative number
if let Some(positional) = sig.get_positional(positional_idx) {
if positional.shape == SyntaxShape::Int || positional.shape == SyntaxShape::Number {
if String::from_utf8_lossy(arg_contents).parse::<f64>().is_ok() {
return (None, None);
2021-07-08 22:29:00 +02:00
} else if let Some(first) = unmatched_short_flags.first() {
2021-09-21 06:03:06 +02:00
let contents = working_set.get_span_contents(*first);
error = error.or_else(|| {
Some(ParseError::UnknownFlag(
sig.name.clone(),
format!("-{}", String::from_utf8_lossy(contents)),
2021-09-21 06:03:06 +02:00
*first,
))
});
2021-07-08 22:29:00 +02:00
}
} else if let Some(first) = unmatched_short_flags.first() {
2021-09-21 06:03:06 +02:00
let contents = working_set.get_span_contents(*first);
error = error.or_else(|| {
Some(ParseError::UnknownFlag(
sig.name.clone(),
format!("-{}", String::from_utf8_lossy(contents)),
2021-09-21 06:03:06 +02:00
*first,
))
});
2021-07-08 22:29:00 +02:00
}
2021-09-02 10:25:22 +02:00
} else if let Some(first) = unmatched_short_flags.first() {
2021-09-21 06:03:06 +02:00
let contents = working_set.get_span_contents(*first);
error = error.or_else(|| {
Some(ParseError::UnknownFlag(
sig.name.clone(),
format!("-{}", String::from_utf8_lossy(contents)),
2021-09-21 06:03:06 +02:00
*first,
))
});
2021-09-02 10:25:22 +02:00
}
} else if !unmatched_short_flags.is_empty() {
if let Some(first) = unmatched_short_flags.first() {
2021-09-21 06:03:06 +02:00
let contents = working_set.get_span_contents(*first);
error = error.or_else(|| {
Some(ParseError::UnknownFlag(
sig.name.clone(),
format!("-{}", String::from_utf8_lossy(contents)),
2021-09-21 06:03:06 +02:00
*first,
))
});
2021-07-08 22:29:00 +02:00
}
}
2021-09-02 10:25:22 +02:00
(Some(found_short_flags), error)
} else {
(None, None)
2021-07-08 22:29:00 +02:00
}
2021-09-02 10:25:22 +02:00
}
2021-07-08 22:29:00 +02:00
2021-09-02 10:25:22 +02:00
fn first_kw_idx(
working_set: &StateWorkingSet,
signature: &Signature,
spans: &[Span],
spans_idx: usize,
positional_idx: usize,
) -> (Option<usize>, usize) {
for idx in (positional_idx + 1)..signature.num_positionals() {
if let Some(PositionalArg {
shape: SyntaxShape::Keyword(kw, ..),
..
}) = signature.get_positional(idx)
{
#[allow(clippy::needless_range_loop)]
for span_idx in spans_idx..spans.len() {
let contents = working_set.get_span_contents(spans[span_idx]);
2021-08-26 23:48:27 +02:00
2021-09-02 10:25:22 +02:00
if contents == kw {
return (Some(idx), span_idx);
2021-08-26 23:48:27 +02:00
}
}
}
}
2021-09-02 10:25:22 +02:00
(None, spans.len())
}
2021-08-26 23:48:27 +02:00
2021-09-02 10:25:22 +02:00
fn calculate_end_span(
working_set: &StateWorkingSet,
signature: &Signature,
spans: &[Span],
spans_idx: usize,
positional_idx: usize,
) -> usize {
if signature.rest_positional.is_some() {
spans.len()
} else {
let (kw_pos, kw_idx) =
first_kw_idx(working_set, signature, spans, spans_idx, positional_idx);
2021-08-26 23:48:27 +02:00
2021-09-02 10:25:22 +02:00
if let Some(kw_pos) = kw_pos {
// We found a keyword. Keywords, once found, create a guidepost to
// show us where the positionals will lay into the arguments. Because they're
// keywords, they get to set this by being present
2021-08-26 23:48:27 +02:00
2021-09-02 10:25:22 +02:00
let positionals_between = kw_pos - positional_idx - 1;
if positionals_between > (kw_idx - spans_idx) {
kw_idx
2021-08-26 23:48:27 +02:00
} else {
2021-09-02 10:25:22 +02:00
kw_idx - positionals_between
}
} else {
// Make space for the remaining require positionals, if we can
if signature.num_positionals_after(positional_idx) == 0 {
spans.len()
} else if positional_idx < signature.required_positional.len()
2021-09-02 10:25:22 +02:00
&& spans.len() > (signature.required_positional.len() - positional_idx)
{
spans.len() - (signature.required_positional.len() - positional_idx - 1)
} else {
2021-09-04 09:59:38 +02:00
spans_idx + 1
2021-07-24 07:57:17 +02:00
}
}
}
2021-09-02 10:25:22 +02:00
}
2021-07-24 07:57:17 +02:00
pub fn parse_multispan_value(
2021-09-02 10:25:22 +02:00
working_set: &mut StateWorkingSet,
spans: &[Span],
spans_idx: &mut usize,
shape: &SyntaxShape,
expand_aliases_denylist: &[usize],
2021-09-02 10:25:22 +02:00
) -> (Expression, Option<ParseError>) {
let mut error = None;
match shape {
SyntaxShape::VarWithOptType => {
2022-01-01 22:42:50 +01:00
trace!("parsing: var with opt type");
2021-09-02 10:25:22 +02:00
let (arg, err) = parse_var_with_opt_type(working_set, spans, spans_idx);
error = error.or(err);
2021-07-08 23:16:25 +02:00
2021-09-02 10:25:22 +02:00
(arg, error)
}
SyntaxShape::RowCondition => {
2022-01-01 22:42:50 +01:00
trace!("parsing: row condition");
let (arg, err) =
parse_row_condition(working_set, &spans[*spans_idx..], expand_aliases_denylist);
2021-09-02 10:25:22 +02:00
error = error.or(err);
*spans_idx = spans.len() - 1;
2021-07-16 08:24:46 +02:00
2021-09-02 10:25:22 +02:00
(arg, error)
}
SyntaxShape::MathExpression => {
trace!("parsing: math expression");
let (arg, err) = parse_math_expression(
working_set,
&spans[*spans_idx..],
None,
expand_aliases_denylist,
);
error = error.or(err);
*spans_idx = spans.len() - 1;
(arg, error)
}
2021-09-02 10:25:22 +02:00
SyntaxShape::Expression => {
2022-01-01 22:42:50 +01:00
trace!("parsing: expression");
let (arg, err) =
parse_expression(working_set, &spans[*spans_idx..], expand_aliases_denylist);
2021-09-02 10:25:22 +02:00
error = error.or(err);
*spans_idx = spans.len() - 1;
2021-07-08 23:16:25 +02:00
2021-09-02 10:25:22 +02:00
(arg, error)
}
SyntaxShape::ImportPattern => {
trace!("parsing: import pattern");
let (arg, err) =
parse_import_pattern(working_set, &spans[*spans_idx..], expand_aliases_denylist);
error = error.or(err);
*spans_idx = spans.len() - 1;
(arg, error)
}
2021-09-02 10:25:22 +02:00
SyntaxShape::Keyword(keyword, arg) => {
2022-01-01 22:42:50 +01:00
trace!(
"parsing: keyword({}) {:?}",
String::from_utf8_lossy(keyword),
arg
);
2021-09-02 10:25:22 +02:00
let arg_span = spans[*spans_idx];
2021-07-08 23:16:25 +02:00
2021-09-02 10:25:22 +02:00
let arg_contents = working_set.get_span_contents(arg_span);
2021-07-17 07:28:25 +02:00
2021-09-02 10:25:22 +02:00
if arg_contents != keyword {
// When keywords mismatch, this is a strong indicator of something going wrong.
// We won't often override the current error, but as this is a strong indicator
// go ahead and override the current error and tell the user about the missing
// keyword/literal.
error = Some(ParseError::ExpectedKeyword(
String::from_utf8_lossy(keyword).into(),
arg_span,
))
}
2021-07-17 07:28:25 +02:00
2021-09-02 10:25:22 +02:00
*spans_idx += 1;
if *spans_idx >= spans.len() {
error = error.or_else(|| {
Some(ParseError::KeywordMissingArgument(
2022-01-04 00:14:33 +01:00
arg.to_string(),
2021-07-30 00:56:51 +02:00
String::from_utf8_lossy(keyword).into(),
2022-01-04 00:14:33 +01:00
Span {
start: spans[*spans_idx - 1].end,
end: spans[*spans_idx - 1].end,
},
2021-07-08 23:16:25 +02:00
))
2021-09-02 10:25:22 +02:00
});
return (
2021-07-08 23:16:25 +02:00
Expression {
2021-09-02 10:25:22 +02:00
expr: Expr::Keyword(
keyword.clone(),
spans[*spans_idx - 1],
Box::new(Expression::garbage(arg_span)),
),
2021-07-08 23:16:25 +02:00
span: arg_span,
ty: Type::Any,
custom_completion: None,
2021-07-08 23:16:25 +02:00
},
error,
2021-09-02 10:25:22 +02:00
);
2021-07-08 23:16:25 +02:00
}
2021-09-02 10:25:22 +02:00
let keyword_span = spans[*spans_idx - 1];
let (expr, err) =
parse_multispan_value(working_set, spans, spans_idx, arg, expand_aliases_denylist);
2021-09-02 10:25:22 +02:00
error = error.or(err);
let ty = expr.ty.clone();
2021-07-17 07:28:25 +02:00
2021-09-02 10:25:22 +02:00
(
Expression {
expr: Expr::Keyword(keyword.clone(), keyword_span, Box::new(expr)),
span: arg_span,
ty,
custom_completion: None,
2021-09-02 10:25:22 +02:00
},
error,
)
}
_ => {
// All other cases are single-span values
let arg_span = spans[*spans_idx];
2021-07-08 23:16:25 +02:00
let (arg, err) = parse_value(working_set, arg_span, shape, expand_aliases_denylist);
2021-09-02 10:25:22 +02:00
error = error.or(err);
(arg, error)
2021-07-08 23:16:25 +02:00
}
}
2021-09-02 10:25:22 +02:00
}
2021-07-08 23:16:25 +02:00
pub struct ParsedInternalCall {
pub call: Box<Call>,
pub output: Type,
pub error: Option<ParseError>,
}
2021-09-02 10:25:22 +02:00
pub fn parse_internal_call(
working_set: &mut StateWorkingSet,
command_span: Span,
spans: &[Span],
decl_id: usize,
expand_aliases_denylist: &[usize],
) -> ParsedInternalCall {
2022-01-01 22:42:50 +01:00
trace!("parsing: internal call (decl id: {})", decl_id);
2021-09-02 10:25:22 +02:00
let mut error = None;
2021-07-02 00:40:08 +02:00
let mut call = Call::new(command_span);
2021-09-02 10:25:22 +02:00
call.decl_id = decl_id;
call.head = command_span;
2021-07-08 08:19:38 +02:00
let decl = working_set.get_decl(decl_id);
let signature = decl.signature();
let output = signature.output_type.clone();
working_set.type_scope.add_type(output.clone());
2021-07-08 08:19:38 +02:00
2021-10-09 18:10:46 +02:00
if signature.creates_scope {
working_set.enter_scope();
}
2021-09-02 10:25:22 +02:00
// The index into the positional parameter in the definition
let mut positional_idx = 0;
2021-07-08 08:19:38 +02:00
2021-09-02 10:25:22 +02:00
// The index into the spans of argument data given to parse
// Starting at the first argument
let mut spans_idx = 0;
2021-07-02 00:40:08 +02:00
2021-09-02 10:25:22 +02:00
while spans_idx < spans.len() {
let arg_span = spans[spans_idx];
2021-07-08 23:16:25 +02:00
2021-09-02 10:25:22 +02:00
// Check if we're on a long flag, if so, parse
let (long_name, arg, err) = parse_long_flag(
working_set,
spans,
&mut spans_idx,
&signature,
expand_aliases_denylist,
);
2021-09-02 10:25:22 +02:00
if let Some(long_name) = long_name {
// We found a long flag, like --bar
error = error.or(err);
call.add_named((long_name, None, arg));
2021-09-02 10:25:22 +02:00
spans_idx += 1;
continue;
}
2021-07-02 00:40:08 +02:00
2021-09-02 10:25:22 +02:00
// Check if we're on a short flag or group of short flags, if so, parse
let (short_flags, err) = parse_short_flags(
working_set,
spans,
&mut spans_idx,
positional_idx,
&signature,
);
2021-07-08 22:29:00 +02:00
2022-07-17 14:46:40 +02:00
if let Some(mut short_flags) = short_flags {
if short_flags.is_empty() {
short_flags.push(Flag {
long: "".to_string(),
short: Some('a'),
arg: None,
required: false,
desc: "".to_string(),
var_id: None,
default_value: None,
})
}
2021-09-02 10:25:22 +02:00
error = error.or(err);
for flag in short_flags {
if let Some(arg_shape) = flag.arg {
if let Some(arg) = spans.get(spans_idx + 1) {
let (arg, err) =
parse_value(working_set, *arg, &arg_shape, expand_aliases_denylist);
2021-09-02 10:25:22 +02:00
error = error.or(err);
if flag.long.is_empty() {
if let Some(short) = flag.short {
call.add_named((
Spanned {
item: String::new(),
span: spans[spans_idx],
},
Some(Spanned {
item: short.to_string(),
span: spans[spans_idx],
}),
Some(arg),
));
}
} else {
call.add_named((
Spanned {
item: flag.long.clone(),
span: spans[spans_idx],
},
None,
Some(arg),
));
}
2021-09-02 10:25:22 +02:00
spans_idx += 1;
2021-07-08 08:19:38 +02:00
} else {
2022-01-04 00:14:33 +01:00
error = error.or_else(|| {
Some(ParseError::MissingFlagParam(
arg_shape.to_string(),
arg_span,
))
})
2021-07-02 00:40:08 +02:00
}
} else if flag.long.is_empty() {
if let Some(short) = flag.short {
call.add_named((
Spanned {
item: String::new(),
span: spans[spans_idx],
},
Some(Spanned {
item: short.to_string(),
span: spans[spans_idx],
}),
None,
));
}
2021-09-02 10:25:22 +02:00
} else {
call.add_named((
2021-10-11 23:17:45 +02:00
Spanned {
item: flag.long.clone(),
span: spans[spans_idx],
},
None,
None,
2021-10-11 23:17:45 +02:00
));
2021-07-08 08:19:38 +02:00
}
2021-07-08 22:29:00 +02:00
}
2021-09-02 10:25:22 +02:00
spans_idx += 1;
continue;
}
2021-07-08 22:29:00 +02:00
2021-09-02 10:25:22 +02:00
// Parse a positional arg if there is one
if let Some(positional) = signature.get_positional(positional_idx) {
let end = calculate_end_span(working_set, &signature, spans, spans_idx, positional_idx);
2021-07-17 01:22:01 +02:00
let end = if spans.len() > spans_idx && end == spans_idx {
end + 1
} else {
end
};
if spans[..end].is_empty() || spans_idx == end {
error = error.or_else(|| {
Some(ParseError::MissingPositional(
positional.name.clone(),
Span {
start: spans[spans_idx].end,
end: spans[spans_idx].end,
},
2022-01-04 00:14:33 +01:00
signature.call_signature(),
))
});
positional_idx += 1;
continue;
}
2021-09-02 10:25:22 +02:00
let orig_idx = spans_idx;
let (arg, err) = parse_multispan_value(
working_set,
&spans[..end],
&mut spans_idx,
&positional.shape,
expand_aliases_denylist,
2021-09-02 10:25:22 +02:00
);
error = error.or(err);
2021-07-23 23:46:55 +02:00
2021-09-02 10:25:22 +02:00
let arg = if !type_compatible(&positional.shape.to_type(), &arg.ty) {
let span = span(&spans[orig_idx..spans_idx]);
error = error.or_else(|| {
Some(ParseError::TypeMismatch(
positional.shape.to_type(),
arg.ty,
arg.span,
))
});
Expression::garbage(span)
2021-07-08 08:19:38 +02:00
} else {
2021-09-02 10:25:22 +02:00
arg
};
call.add_positional(arg);
2021-09-02 10:25:22 +02:00
positional_idx += 1;
} else {
call.add_positional(Expression::garbage(arg_span));
2022-01-04 00:14:33 +01:00
error = error.or_else(|| {
Some(ParseError::ExtraPositional(
signature.call_signature(),
arg_span,
))
})
2021-07-08 08:19:38 +02:00
}
2021-07-02 00:40:08 +02:00
2021-07-08 08:19:38 +02:00
error = error.or(err);
2021-09-02 10:25:22 +02:00
spans_idx += 1;
2021-07-08 08:19:38 +02:00
}
2021-09-02 10:25:22 +02:00
let err = check_call(command_span, &signature, &call);
error = error.or(err);
2021-07-31 07:20:40 +02:00
2021-10-09 18:10:46 +02:00
if signature.creates_scope {
working_set.exit_scope();
}
ParsedInternalCall {
call: Box::new(call),
output,
error,
}
2021-09-02 10:25:22 +02:00
}
2021-07-31 07:20:40 +02:00
2021-09-02 10:25:22 +02:00
pub fn parse_call(
working_set: &mut StateWorkingSet,
spans: &[Span],
2021-12-19 08:46:13 +01:00
head: Span,
expand_aliases_denylist: &[usize],
2021-09-02 10:25:22 +02:00
) -> (Expression, Option<ParseError>) {
2022-01-01 22:42:50 +01:00
trace!("parsing: call");
2021-10-29 22:50:28 +02:00
if spans.is_empty() {
return (
2021-12-19 08:46:13 +01:00
garbage(head),
Some(ParseError::UnknownState(
"Encountered command with zero spans".into(),
span(spans),
)),
2021-10-29 22:50:28 +02:00
);
}
2021-09-02 10:25:22 +02:00
let mut pos = 0;
let cmd_start = pos;
2021-10-29 22:50:28 +02:00
let mut name_spans = vec![];
2022-01-10 03:52:01 +01:00
let mut name = vec![];
2021-08-17 01:00:00 +02:00
2021-10-29 22:50:28 +02:00
for word_span in spans[cmd_start..].iter() {
// Find the longest group of words that could form a command
if is_math_expression_like(working_set, *word_span, expand_aliases_denylist) {
let bytes = working_set.get_span_contents(*word_span);
if bytes != b"true" && bytes != b"false" && bytes != b"null" && bytes != b"not" {
break;
}
2021-08-09 02:19:07 +02:00
}
2021-10-29 22:50:28 +02:00
name_spans.push(*word_span);
2021-09-02 10:25:22 +02:00
2022-01-10 03:52:01 +01:00
let name_part = working_set.get_span_contents(*word_span);
if name.is_empty() {
name.extend(name_part);
} else {
name.push(b' ');
name.extend(name_part);
}
2021-09-02 10:25:22 +02:00
// If the word is an alias, expand it and re-parse the expression
if let Some(alias_id) = working_set.find_alias(&name) {
if !expand_aliases_denylist.contains(&alias_id) {
2022-01-01 22:42:50 +01:00
trace!("expanding alias");
let expansion = working_set.get_alias(alias_id);
2022-02-15 03:09:21 +01:00
let expansion_span = span(expansion);
let orig_span = span(&[spans[cmd_start], spans[pos]]);
2021-10-29 22:50:28 +02:00
let mut new_spans: Vec<Span> = vec![];
2022-02-15 03:09:21 +01:00
new_spans.extend(&spans[0..cmd_start]);
2021-10-29 22:50:28 +02:00
new_spans.extend(expansion);
2022-03-03 20:05:55 +01:00
// TODO: This seems like it should be `pos + 1`. `pos` starts as 0
2021-10-29 22:50:28 +02:00
if spans.len() > pos {
new_spans.extend(&spans[(pos + 1)..]);
}
2021-08-17 01:00:00 +02:00
let mut expand_aliases_denylist = expand_aliases_denylist.to_vec();
expand_aliases_denylist.push(alias_id);
let lite_command = LiteCommand {
comments: vec![],
parts: new_spans.clone(),
};
let (mut result, err) =
parse_builtin_commands(working_set, &lite_command, &expand_aliases_denylist);
let mut result = result.expressions.remove(0);
2021-08-17 01:00:00 +02:00
2022-02-15 03:09:21 +01:00
result.replace_span(working_set, expansion_span, orig_span);
2021-08-17 01:00:00 +02:00
2022-02-15 03:09:21 +01:00
return (result, err);
2021-09-02 10:25:22 +02:00
}
2021-10-29 22:50:28 +02:00
}
2021-08-17 01:00:00 +02:00
2021-10-29 22:50:28 +02:00
pos += 1;
}
let input = working_set.type_scope.get_previous();
let mut maybe_decl_id = working_set.find_decl(&name, input);
2021-10-29 22:50:28 +02:00
while maybe_decl_id.is_none() {
// Find the longest command match
if name_spans.len() <= 1 {
// Keep the first word even if it does not match -- could be external command
break;
2021-06-30 03:42:56 +02:00
}
2021-09-11 14:07:19 +02:00
2021-10-29 22:50:28 +02:00
name_spans.pop();
pos -= 1;
2022-01-10 03:52:01 +01:00
let mut name = vec![];
for name_span in &name_spans {
let name_part = working_set.get_span_contents(*name_span);
if name.is_empty() {
name.extend(name_part);
} else {
name.push(b' ');
name.extend(name_part);
}
}
maybe_decl_id = working_set.find_decl(&name, input);
2021-10-29 22:50:28 +02:00
}
if let Some(decl_id) = maybe_decl_id {
2021-09-11 14:07:19 +02:00
// Before the internal parsing we check if there is no let or alias declarations
// that are missing their name, e.g.: let = 1 or alias = 2
if spans.len() > 1 {
let test_equal = working_set.get_span_contents(spans[1]);
2021-09-11 14:16:40 +02:00
if test_equal == [b'='] {
2022-01-01 22:42:50 +01:00
trace!("incomplete statement");
2021-09-11 14:07:19 +02:00
return (
2021-12-19 08:46:13 +01:00
garbage(span(spans)),
2021-09-11 14:07:19 +02:00
Some(ParseError::UnknownState(
2021-09-12 17:36:16 +02:00
"Incomplete statement".into(),
2021-09-11 14:07:19 +02:00
span(spans),
)),
);
}
}
trace!("parsing: internal call");
2022-01-01 22:42:50 +01:00
// parse internal command
let parsed_call = parse_internal_call(
working_set,
span(&spans[cmd_start..pos]),
&spans[pos..],
decl_id,
expand_aliases_denylist,
);
(
Expression {
expr: Expr::Call(parsed_call.call),
span: span(spans),
ty: parsed_call.output,
custom_completion: None,
},
parsed_call.error,
)
2021-09-02 10:25:22 +02:00
} else {
// We might be parsing left-unbounded range ("..10")
let bytes = working_set.get_span_contents(spans[0]);
2022-01-01 22:42:50 +01:00
trace!("parsing: range {:?} ", bytes);
if let (Some(b'.'), Some(b'.')) = (bytes.get(0), bytes.get(1)) {
2022-01-01 22:42:50 +01:00
trace!("-- found leading range indicator");
let (range_expr, range_err) =
parse_range(working_set, spans[0], expand_aliases_denylist);
if range_err.is_none() {
2022-01-01 22:42:50 +01:00
trace!("-- successfully parsed range");
return (range_expr, range_err);
}
}
2022-01-01 22:42:50 +01:00
trace!("parsing: external call");
2021-10-29 22:50:28 +02:00
// Otherwise, try external command
parse_external_call(working_set, spans, expand_aliases_denylist)
2021-09-02 10:25:22 +02:00
}
}
2022-03-01 00:31:53 +01:00
pub fn parse_binary(
working_set: &mut StateWorkingSet,
span: Span,
) -> (Expression, Option<ParseError>) {
let (hex_value, err) = parse_binary_with_base(working_set, span, 16, 2, b"0x[", b"]");
if err.is_some() {
let (octal_value, err) = parse_binary_with_base(working_set, span, 8, 3, b"0o[", b"]");
if err.is_some() {
return parse_binary_with_base(working_set, span, 2, 8, b"0b[", b"]");
}
return (octal_value, err);
2022-03-01 00:31:53 +01:00
}
(hex_value, err)
}
2022-03-01 00:31:53 +01:00
fn parse_binary_with_base(
working_set: &mut StateWorkingSet,
span: Span,
base: u32,
min_digits_per_byte: usize,
prefix: &[u8],
suffix: &[u8],
) -> (Expression, Option<ParseError>) {
2022-03-01 00:31:53 +01:00
let token = working_set.get_span_contents(span);
if let Some(token) = token.strip_prefix(prefix) {
if let Some(token) = token.strip_suffix(suffix) {
let (lexed, err) = lex(
token,
span.start + prefix.len(),
&[b',', b'\r', b'\n'],
&[],
true,
);
2022-03-01 00:31:53 +01:00
let mut binary_value = vec![];
2022-03-01 00:31:53 +01:00
for token in lexed {
match token.contents {
TokenContents::Item => {
let contents = working_set.get_span_contents(token.span);
binary_value.extend_from_slice(contents);
2022-03-01 00:31:53 +01:00
}
TokenContents::Pipe => {
return (
garbage(span),
Some(ParseError::Expected("binary".into(), span)),
);
}
TokenContents::Comment | TokenContents::Semicolon | TokenContents::Eol => {}
}
}
let required_padding = (min_digits_per_byte - binary_value.len() % min_digits_per_byte)
% min_digits_per_byte;
if required_padding != 0 {
binary_value = {
let mut tail = binary_value;
let mut binary_value: Vec<u8> = vec![b'0'; required_padding];
binary_value.append(&mut tail);
binary_value
};
2022-03-01 00:31:53 +01:00
}
let str = String::from_utf8_lossy(&binary_value).to_string();
2022-03-01 00:31:53 +01:00
match decode_with_base(&str, base, min_digits_per_byte) {
2022-03-01 00:31:53 +01:00
Ok(v) => {
return (
Expression {
expr: Expr::Binary(v),
span,
ty: Type::Binary,
custom_completion: None,
},
err,
)
}
Err(x) => {
return (
garbage(span),
Some(ParseError::IncorrectValue(
"not a binary value".into(),
span,
x.to_string(),
)),
)
}
}
}
}
(
garbage(span),
Some(ParseError::Expected("binary".into(), span)),
)
}
fn decode_with_base(s: &str, base: u32, digits_per_byte: usize) -> Result<Vec<u8>, ParseIntError> {
2022-06-17 20:11:48 +02:00
s.chars()
.chunks(digits_per_byte)
.into_iter()
.map(|chunk| {
let str: String = chunk.collect();
u8::from_str_radix(&str, base)
})
.collect()
}
2021-09-07 00:02:24 +02:00
pub fn parse_int(token: &[u8], span: Span) -> (Expression, Option<ParseError>) {
if let Some(token) = token.strip_prefix(b"0x") {
if let Ok(v) = i64::from_str_radix(&String::from_utf8_lossy(token), 16) {
2021-07-01 02:01:04 +02:00
(
Expression {
2021-09-02 10:25:22 +02:00
expr: Expr::Int(v),
2021-07-01 02:01:04 +02:00
span,
2021-07-23 23:19:30 +02:00
ty: Type::Int,
custom_completion: None,
2021-07-01 02:01:04 +02:00
},
None,
)
} else {
(
garbage(span),
2021-09-02 10:25:22 +02:00
Some(ParseError::Mismatch(
"int".into(),
"incompatible int".into(),
span,
)),
2021-07-01 02:01:04 +02:00
)
}
2021-09-07 00:02:24 +02:00
} else if let Some(token) = token.strip_prefix(b"0b") {
if let Ok(v) = i64::from_str_radix(&String::from_utf8_lossy(token), 2) {
2021-08-08 22:21:21 +02:00
(
Expression {
2021-09-02 10:25:22 +02:00
expr: Expr::Int(v),
2021-08-08 22:21:21 +02:00
span,
2021-09-02 10:25:22 +02:00
ty: Type::Int,
custom_completion: None,
2021-08-08 22:21:21 +02:00
},
None,
)
} else {
(
garbage(span),
2021-09-02 10:25:22 +02:00
Some(ParseError::Mismatch(
"int".into(),
"incompatible int".into(),
span,
)),
2021-08-08 22:21:21 +02:00
)
}
2021-09-07 00:02:24 +02:00
} else if let Some(token) = token.strip_prefix(b"0o") {
if let Ok(v) = i64::from_str_radix(&String::from_utf8_lossy(token), 8) {
2021-09-02 10:25:22 +02:00
(
Expression {
expr: Expr::Int(v),
span,
ty: Type::Int,
custom_completion: None,
2021-09-02 10:25:22 +02:00
},
None,
)
2021-07-01 02:01:04 +02:00
} else {
(
garbage(span),
2021-09-02 10:25:22 +02:00
Some(ParseError::Mismatch(
"int".into(),
"incompatible int".into(),
span,
)),
2021-07-01 02:01:04 +02:00
)
}
2021-09-07 00:02:24 +02:00
} else if let Ok(x) = String::from_utf8_lossy(token).parse::<i64>() {
2021-09-02 10:25:22 +02:00
(
Expression {
expr: Expr::Int(x),
span,
ty: Type::Int,
custom_completion: None,
2021-09-02 10:25:22 +02:00
},
None,
)
} else {
(
garbage(span),
Some(ParseError::Expected("int".into(), span)),
)
2021-07-01 02:01:04 +02:00
}
2021-09-02 10:25:22 +02:00
}
2021-07-01 02:01:04 +02:00
2021-09-07 00:02:24 +02:00
pub fn parse_float(token: &[u8], span: Span) -> (Expression, Option<ParseError>) {
if let Ok(x) = String::from_utf8_lossy(token).parse::<f64>() {
2021-09-02 10:25:22 +02:00
(
Expression {
expr: Expr::Float(x),
span,
ty: Type::Float,
custom_completion: None,
2021-09-02 10:25:22 +02:00
},
None,
)
} else {
(
garbage(span),
Some(ParseError::Expected("float".into(), span)),
)
}
}
2021-07-30 05:26:06 +02:00
2021-09-07 00:02:24 +02:00
pub fn parse_number(token: &[u8], span: Span) -> (Expression, Option<ParseError>) {
2021-09-03 09:35:29 +02:00
if let (x, None) = parse_int(token, span) {
2021-09-02 10:25:22 +02:00
(x, None)
2021-09-03 09:35:29 +02:00
} else if let (x, None) = parse_float(token, span) {
2021-09-02 10:25:22 +02:00
(x, None)
} else {
(
garbage(span),
Some(ParseError::Expected("number".into(), span)),
)
2021-07-30 05:26:06 +02:00
}
2021-09-02 10:25:22 +02:00
}
2021-07-30 05:26:06 +02:00
pub fn parse_range(
working_set: &mut StateWorkingSet,
span: Span,
expand_aliases_denylist: &[usize],
) -> (Expression, Option<ParseError>) {
2022-01-01 22:42:50 +01:00
trace!("parsing: range");
// Range follows the following syntax: [<from>][<next_operator><next>]<range_operator>[<to>]
// where <next_operator> is ".."
// and <range_operator> is ".." or "..<"
// and one of the <from> or <to> bounds must be present (just '..' is not allowed since it
// looks like parent directory)
let contents = working_set.get_span_contents(span);
let token = if let Ok(s) = String::from_utf8(contents.into()) {
s
} else {
return (garbage(span), Some(ParseError::NonUtf8(span)));
};
if !token.contains("..") {
return (
garbage(span),
Some(ParseError::Expected(
"at least one range bound set".into(),
span,
)),
);
}
// First, figure out what exact operators are used and determine their positions
let dotdot_pos: Vec<_> = token.match_indices("..").map(|(pos, _)| pos).collect();
let (next_op_pos, range_op_pos) =
match dotdot_pos.len() {
1 => (None, dotdot_pos[0]),
2 => (Some(dotdot_pos[0]), dotdot_pos[1]),
_ => return (
garbage(span),
Some(ParseError::Expected(
"one range operator ('..' or '..<') and optionally one next operator ('..')"
.into(),
span,
)),
),
};
let (inclusion, range_op_str, range_op_span) = if let Some(pos) = token.find("..<") {
if pos == range_op_pos {
let op_str = "..<";
let op_span = Span::new(
span.start + range_op_pos,
span.start + range_op_pos + op_str.len(),
);
(RangeInclusion::RightExclusive, "..<", op_span)
} else {
return (
garbage(span),
Some(ParseError::Expected(
"inclusive operator preceding second range bound".into(),
span,
)),
);
}
} else {
let op_str = "..";
let op_span = Span::new(
span.start + range_op_pos,
span.start + range_op_pos + op_str.len(),
);
(RangeInclusion::Inclusive, "..", op_span)
};
// Now, based on the operator positions, figure out where the bounds & next are located and
// parse them
2021-10-12 19:44:23 +02:00
// TODO: Actually parse the next number in the range
let from = if token.starts_with("..") {
// token starts with either next operator, or range operator -- we don't care which one
None
} else {
let from_span = Span::new(span.start, span.start + dotdot_pos[0]);
match parse_value(
working_set,
from_span,
&SyntaxShape::Number,
expand_aliases_denylist,
) {
(expression, None) => Some(Box::new(expression)),
_ => {
return (
garbage(span),
Some(ParseError::Expected("number".into(), span)),
)
}
}
};
let to = if token.ends_with(range_op_str) {
None
} else {
let to_span = Span::new(range_op_span.end, span.end);
match parse_value(
working_set,
to_span,
&SyntaxShape::Number,
expand_aliases_denylist,
) {
(expression, None) => Some(Box::new(expression)),
_ => {
return (
garbage(span),
Some(ParseError::Expected("number".into(), span)),
)
}
}
};
2022-01-01 22:42:50 +01:00
trace!("-- from: {:?} to: {:?}", from, to);
if let (None, None) = (&from, &to) {
return (
garbage(span),
Some(ParseError::Expected(
"at least one range bound set".into(),
span,
)),
);
}
let (next, next_op_span) = if let Some(pos) = next_op_pos {
let next_op_span = Span::new(span.start + pos, span.start + pos + "..".len());
let next_span = Span::new(next_op_span.end, range_op_span.start);
match parse_value(
working_set,
next_span,
&SyntaxShape::Number,
expand_aliases_denylist,
) {
(expression, None) => (Some(Box::new(expression)), next_op_span),
_ => {
return (
garbage(span),
Some(ParseError::Expected("number".into(), span)),
)
}
}
} else {
2021-12-19 08:46:13 +01:00
(None, span)
};
let range_op = RangeOperator {
inclusion,
span: range_op_span,
next_op_span,
};
(
Expression {
expr: Expr::Range(from, next, to, range_op),
span,
ty: Type::Range,
custom_completion: None,
},
None,
)
}
2021-09-02 10:25:22 +02:00
pub(crate) fn parse_dollar_expr(
working_set: &mut StateWorkingSet,
span: Span,
expand_aliases_denylist: &[usize],
2021-09-02 10:25:22 +02:00
) -> (Expression, Option<ParseError>) {
trace!("parsing: dollar expression");
2021-09-02 10:25:22 +02:00
let contents = working_set.get_span_contents(span);
2021-07-30 05:26:06 +02:00
if contents.starts_with(b"$\"") || contents.starts_with(b"$'") {
parse_string_interpolation(working_set, span, expand_aliases_denylist)
} else if let (expr, None) = parse_range(working_set, span, expand_aliases_denylist) {
2021-09-05 00:40:15 +02:00
(expr, None)
2021-09-02 10:25:22 +02:00
} else {
parse_full_cell_path(working_set, None, span, expand_aliases_denylist)
2021-09-02 10:25:22 +02:00
}
}
2021-07-30 05:26:06 +02:00
2021-09-02 10:25:22 +02:00
pub fn parse_string_interpolation(
working_set: &mut StateWorkingSet,
span: Span,
expand_aliases_denylist: &[usize],
2021-09-02 10:25:22 +02:00
) -> (Expression, Option<ParseError>) {
#[derive(PartialEq, Eq, Debug)]
enum InterpolationMode {
String,
Expression,
}
let mut error = None;
2021-07-30 05:26:06 +02:00
2021-09-02 10:25:22 +02:00
let contents = working_set.get_span_contents(span);
2021-07-30 05:26:06 +02:00
let mut double_quote = false;
let (start, end) = if contents.starts_with(b"$\"") {
double_quote = true;
let end = if contents.ends_with(b"\"") && contents.len() > 2 {
span.end - 1
} else {
span.end
};
(span.start + 2, end)
} else if contents.starts_with(b"$'") {
let end = if contents.ends_with(b"'") && contents.len() > 2 {
span.end - 1
} else {
span.end
};
(span.start + 2, end)
2021-09-02 10:25:22 +02:00
} else {
(span.start, span.end)
2021-09-02 10:25:22 +02:00
};
let inner_span = Span { start, end };
let contents = working_set.get_span_contents(inner_span).to_vec();
let mut output = vec![];
let mut mode = InterpolationMode::String;
let mut token_start = start;
let mut delimiter_stack = vec![];
2021-09-02 10:25:22 +02:00
let mut b = start;
#[allow(clippy::needless_range_loop)]
while b != end {
if contents[b - start] == b'('
&& (if double_quote && (b - start) > 0 {
contents[b - start - 1] != b'\\'
} else {
true
})
&& mode == InterpolationMode::String
{
2021-09-02 10:25:22 +02:00
mode = InterpolationMode::Expression;
if token_start < b {
let span = Span {
start: token_start,
end: b,
};
let str_contents = working_set.get_span_contents(span);
let str_contents = if double_quote {
let (str_contents, err) = unescape_string(str_contents, span);
error = error.or(err);
str_contents
} else {
str_contents.to_vec()
};
2021-09-02 10:25:22 +02:00
output.push(Expression {
expr: Expr::String(String::from_utf8_lossy(&str_contents).to_string()),
2021-09-02 10:25:22 +02:00
span,
ty: Type::String,
custom_completion: None,
2021-09-02 10:25:22 +02:00
});
token_start = b;
2021-07-30 05:26:06 +02:00
}
}
if mode == InterpolationMode::Expression {
let byte = contents[b - start];
if let Some(b'\'') = delimiter_stack.last() {
if byte == b'\'' {
delimiter_stack.pop();
}
} else if let Some(b'"') = delimiter_stack.last() {
if byte == b'"' {
delimiter_stack.pop();
}
} else if let Some(b'`') = delimiter_stack.last() {
if byte == b'`' {
delimiter_stack.pop();
}
} else if byte == b'\'' {
delimiter_stack.push(b'\'')
} else if byte == b'"' {
delimiter_stack.push(b'"');
} else if byte == b'`' {
delimiter_stack.push(b'`')
} else if byte == b'(' {
delimiter_stack.push(b')');
} else if byte == b')' {
if let Some(b')') = delimiter_stack.last() {
delimiter_stack.pop();
}
if delimiter_stack.is_empty() {
2021-09-02 10:25:22 +02:00
mode = InterpolationMode::String;
if token_start < b {
let span = Span {
start: token_start,
end: b + 1,
};
2021-07-30 05:26:06 +02:00
let (expr, err) =
parse_full_cell_path(working_set, None, span, expand_aliases_denylist);
2021-09-02 10:25:22 +02:00
error = error.or(err);
output.push(expr);
}
token_start = b + 1;
continue;
2021-07-30 05:26:06 +02:00
}
}
}
2021-09-02 10:25:22 +02:00
b += 1;
}
2021-07-30 05:26:06 +02:00
2021-09-02 10:25:22 +02:00
match mode {
InterpolationMode::String => {
if token_start < end {
let span = Span {
start: token_start,
end,
};
let str_contents = working_set.get_span_contents(span);
let str_contents = if double_quote {
let (str_contents, err) = unescape_string(str_contents, span);
error = error.or(err);
str_contents
} else {
str_contents.to_vec()
};
2021-09-02 10:25:22 +02:00
output.push(Expression {
expr: Expr::String(String::from_utf8_lossy(&str_contents).to_string()),
2021-07-30 05:26:06 +02:00
span,
ty: Type::String,
custom_completion: None,
2021-09-02 10:25:22 +02:00
});
}
}
InterpolationMode::Expression => {
if token_start < end {
let span = Span {
start: token_start,
end,
};
let (expr, err) =
parse_full_cell_path(working_set, None, span, expand_aliases_denylist);
2021-09-02 10:25:22 +02:00
error = error.or(err);
output.push(expr);
}
2021-07-30 05:26:06 +02:00
}
2021-07-24 07:57:17 +02:00
}
2021-07-02 09:15:30 +02:00
(
Expression {
expr: Expr::StringInterpolation(output),
span,
ty: Type::String,
custom_completion: None,
},
error,
)
2021-09-02 10:25:22 +02:00
}
2021-07-24 07:57:17 +02:00
2021-09-02 10:25:22 +02:00
pub fn parse_variable_expr(
working_set: &mut StateWorkingSet,
span: Span,
) -> (Expression, Option<ParseError>) {
let contents = working_set.get_span_contents(span);
2022-03-19 20:12:10 +01:00
if contents == b"$nothing" {
return (
Expression {
expr: Expr::Nothing,
span,
ty: Type::Nothing,
custom_completion: None,
},
None,
);
2021-10-29 20:15:17 +02:00
} else if contents == b"$nu" {
return (
Expression {
2021-11-02 04:08:05 +01:00
expr: Expr::Var(nu_protocol::NU_VARIABLE_ID),
span,
ty: Type::Any,
2021-11-02 04:08:05 +01:00
custom_completion: None,
},
None,
);
} else if contents == b"$in" {
return (
Expression {
expr: Expr::Var(nu_protocol::IN_VARIABLE_ID),
span,
ty: Type::Any,
custom_completion: None,
},
None,
);
} else if contents == b"$env" {
return (
Expression {
expr: Expr::Var(nu_protocol::ENV_VARIABLE_ID),
span,
ty: Type::Any,
custom_completion: None,
},
None,
);
2021-09-02 10:25:22 +02:00
}
let (id, err) = parse_variable(working_set, span);
if err.is_none() {
if let Some(id) = id {
(
2021-07-02 09:15:30 +02:00
Expression {
2021-09-02 10:25:22 +02:00
expr: Expr::Var(id),
2021-07-02 09:15:30 +02:00
span,
2022-03-09 10:42:19 +01:00
ty: working_set.get_variable(id).ty.clone(),
custom_completion: None,
2021-07-02 09:15:30 +02:00
},
None,
2021-09-02 10:25:22 +02:00
)
} else {
(garbage(span), Some(ParseError::VariableNotFound(span)))
2021-07-02 09:15:30 +02:00
}
2021-09-02 10:25:22 +02:00
} else {
(garbage(span), err)
}
}
2021-07-02 09:15:30 +02:00
2021-10-02 04:59:11 +02:00
pub fn parse_cell_path(
working_set: &mut StateWorkingSet,
tokens: impl Iterator<Item = Token>,
mut expect_dot: bool,
expand_aliases_denylist: &[usize],
2021-10-02 04:59:11 +02:00
span: Span,
) -> (Vec<PathMember>, Option<ParseError>) {
let mut error = None;
let mut tail = vec![];
for path_element in tokens {
let bytes = working_set.get_span_contents(path_element.span);
if expect_dot {
expect_dot = false;
if bytes.len() != 1 || bytes[0] != b'.' {
error = error.or_else(|| Some(ParseError::Expected('.'.into(), path_element.span)));
}
} else {
expect_dot = true;
match parse_int(bytes, path_element.span) {
(
Expression {
expr: Expr::Int(val),
span,
..
},
None,
) => tail.push(PathMember::Int {
val: val as usize,
span,
}),
_ => {
let (result, err) =
parse_string(working_set, path_element.span, expand_aliases_denylist);
2021-10-02 04:59:11 +02:00
error = error.or(err);
match result {
Expression {
expr: Expr::String(string),
span,
..
} => {
tail.push(PathMember::String { val: string, span });
}
_ => {
error =
error.or_else(|| Some(ParseError::Expected("string".into(), span)));
}
}
}
}
}
}
(tail, error)
}
2021-09-26 20:39:19 +02:00
pub fn parse_full_cell_path(
2021-09-02 10:25:22 +02:00
working_set: &mut StateWorkingSet,
2021-09-09 23:47:20 +02:00
implicit_head: Option<VarId>,
2021-09-02 10:25:22 +02:00
span: Span,
expand_aliases_denylist: &[usize],
2021-09-02 10:25:22 +02:00
) -> (Expression, Option<ParseError>) {
2021-09-26 20:39:19 +02:00
let full_cell_span = span;
2021-09-07 00:02:24 +02:00
let source = working_set.get_span_contents(span);
2021-09-02 10:25:22 +02:00
let mut error = None;
2021-07-08 08:19:38 +02:00
2021-11-21 19:13:09 +01:00
let (tokens, err) = lex(source, span.start, &[b'\n', b'\r'], &[b'.'], true);
2021-09-07 00:02:24 +02:00
error = error.or(err);
2021-09-02 10:25:22 +02:00
2021-09-09 23:47:20 +02:00
let mut tokens = tokens.into_iter().peekable();
if let Some(head) = tokens.peek() {
2021-09-07 00:02:24 +02:00
let bytes = working_set.get_span_contents(head.span);
2021-10-02 04:59:11 +02:00
let (head, expect_dot) = if bytes.starts_with(b"(") {
2022-01-01 22:42:50 +01:00
trace!("parsing: paren-head of full cell path");
let head_span = head.span;
2021-09-07 00:02:24 +02:00
let mut start = head.span.start;
let mut end = head.span.end;
2021-07-08 08:19:38 +02:00
2021-09-07 00:02:24 +02:00
if bytes.starts_with(b"(") {
start += 1;
}
if bytes.ends_with(b")") {
end -= 1;
} else {
error = error
.or_else(|| Some(ParseError::Unclosed(")".into(), Span { start: end, end })));
2021-09-07 00:02:24 +02:00
}
2021-07-02 09:15:30 +02:00
2021-09-07 00:02:24 +02:00
let span = Span { start, end };
2021-07-02 09:15:30 +02:00
2021-09-07 00:02:24 +02:00
let source = working_set.get_span_contents(span);
2021-07-02 09:15:30 +02:00
2021-11-21 19:13:09 +01:00
let (output, err) = lex(source, span.start, &[b'\n', b'\r'], &[], true);
2021-09-07 00:02:24 +02:00
error = error.or(err);
2021-07-02 09:15:30 +02:00
2021-09-09 23:47:20 +02:00
let (output, err) = lite_parse(&output);
2021-09-07 00:02:24 +02:00
error = error.or(err);
2021-07-02 09:15:30 +02:00
// Creating a Type scope to parse the new block. This will keep track of
// the previous input type found in that block
let (output, err) =
parse_block(working_set, &output, true, expand_aliases_denylist, true);
working_set
.type_scope
.add_type(working_set.type_scope.get_last_output());
let ty = output
.pipelines
.last()
.and_then(|Pipeline { expressions, .. }| expressions.last())
.map(|expr| match expr.expr {
Expr::BinaryOp(..) => expr.ty.clone(),
_ => working_set.type_scope.get_last_output(),
})
.unwrap_or_else(|| working_set.type_scope.get_last_output());
2021-09-07 00:02:24 +02:00
error = error.or(err);
2021-07-02 09:15:30 +02:00
2021-09-07 00:02:24 +02:00
let block_id = working_set.add_block(output);
2021-09-09 23:47:20 +02:00
tokens.next();
2021-09-07 00:02:24 +02:00
2021-09-09 23:47:20 +02:00
(
Expression {
expr: Expr::Subexpression(block_id),
span: head_span,
ty,
custom_completion: None,
2021-09-09 23:47:20 +02:00
},
true,
)
} else if bytes.starts_with(b"[") {
2022-01-01 22:42:50 +01:00
trace!("parsing: table head of full cell path");
let (output, err) =
parse_table_expression(working_set, head.span, expand_aliases_denylist);
error = error.or(err);
tokens.next();
2021-11-11 00:14:00 +01:00
(output, true)
} else if bytes.starts_with(b"{") {
2022-01-01 22:42:50 +01:00
trace!("parsing: record head of full cell path");
let (output, err) = parse_record(working_set, head.span, expand_aliases_denylist);
2021-11-11 00:14:00 +01:00
error = error.or(err);
tokens.next();
(output, true)
2021-09-07 00:02:24 +02:00
} else if bytes.starts_with(b"$") {
2022-01-01 22:42:50 +01:00
trace!("parsing: $variable head of full cell path");
2021-09-07 00:02:24 +02:00
let (out, err) = parse_variable_expr(working_set, head.span);
error = error.or(err);
2021-09-09 23:47:20 +02:00
tokens.next();
(out, true)
} else if let Some(var_id) = implicit_head {
(
Expression {
expr: Expr::Var(var_id),
span: Span::new(0, 0),
ty: Type::Any,
custom_completion: None,
2021-09-09 23:47:20 +02:00
},
false,
)
2021-09-07 00:02:24 +02:00
} else {
return (
garbage(span),
Some(ParseError::Mismatch(
"variable or subexpression".into(),
String::from_utf8_lossy(bytes).to_string(),
span,
)),
);
};
let (tail, err) = parse_cell_path(
working_set,
tokens,
expect_dot,
expand_aliases_denylist,
span,
);
2021-10-02 04:59:11 +02:00
error = error.or(err);
2021-09-07 00:02:24 +02:00
if !tail.is_empty() {
(
Expression {
ty: head.ty.clone(), // FIXME. How to access the last type of tail?
expr: Expr::FullCellPath(Box::new(FullCellPath { head, tail })),
span: full_cell_span,
custom_completion: None,
},
error,
)
} else {
let ty = head.ty.clone();
(
Expression {
expr: Expr::FullCellPath(Box::new(FullCellPath { head, tail })),
ty,
span: full_cell_span,
custom_completion: None,
},
error,
)
}
2021-09-07 00:02:24 +02:00
} else {
(garbage(span), error)
}
2021-09-02 10:25:22 +02:00
}
2021-07-02 09:15:30 +02:00
pub fn parse_directory(
working_set: &mut StateWorkingSet,
span: Span,
) -> (Expression, Option<ParseError>) {
let bytes = working_set.get_span_contents(span);
let (token, err) = unescape_unquote_string(bytes, span);
trace!("parsing: directory");
if err.is_none() {
trace!("-- found {}", token);
(
Expression {
expr: Expr::Directory(token),
span,
ty: Type::String,
custom_completion: None,
},
None,
)
} else {
(
garbage(span),
Some(ParseError::Expected("directory".into(), span)),
)
}
}
2021-10-04 21:21:31 +02:00
pub fn parse_filepath(
working_set: &mut StateWorkingSet,
span: Span,
) -> (Expression, Option<ParseError>) {
let bytes = working_set.get_span_contents(span);
let (token, err) = unescape_unquote_string(bytes, span);
2022-01-01 22:42:50 +01:00
trace!("parsing: filepath");
2021-10-04 21:21:31 +02:00
if err.is_none() {
trace!("-- found {}", token);
2021-10-04 21:21:31 +02:00
(
Expression {
expr: Expr::Filepath(token),
2021-10-04 21:21:31 +02:00
span,
ty: Type::String,
custom_completion: None,
},
None,
)
} else {
(
garbage(span),
2021-11-18 20:32:27 +01:00
Some(ParseError::Expected("filepath".into(), span)),
2021-10-04 21:21:31 +02:00
)
}
}
/// Parse a datetime type, eg '2022-02-02'
pub fn parse_datetime(
working_set: &mut StateWorkingSet,
span: Span,
) -> (Expression, Option<ParseError>) {
trace!("parsing: datetime");
let bytes = working_set.get_span_contents(span);
if bytes.is_empty() || !bytes[0].is_ascii_digit() {
return (
garbage(span),
Some(ParseError::Mismatch(
"datetime".into(),
"non-datetime".into(),
span,
)),
);
}
let token = String::from_utf8_lossy(bytes).to_string();
if let Ok(datetime) = chrono::DateTime::parse_from_rfc3339(&token) {
return (
Expression {
expr: Expr::DateTime(datetime),
span,
ty: Type::Date,
custom_completion: None,
},
None,
);
}
// Just the date
let just_date = token.clone() + "T00:00:00+00:00";
if let Ok(datetime) = chrono::DateTime::parse_from_rfc3339(&just_date) {
return (
Expression {
expr: Expr::DateTime(datetime),
span,
ty: Type::Date,
custom_completion: None,
},
None,
);
}
// Date and time, assume UTC
let datetime = token + "+00:00";
if let Ok(datetime) = chrono::DateTime::parse_from_rfc3339(&datetime) {
return (
Expression {
expr: Expr::DateTime(datetime),
span,
ty: Type::Date,
custom_completion: None,
},
None,
);
}
(
garbage(span),
Some(ParseError::Mismatch(
"datetime".into(),
"non-datetime".into(),
span,
)),
)
}
2021-10-05 04:27:39 +02:00
/// Parse a duration type, eg '10day'
pub fn parse_duration(
working_set: &StateWorkingSet,
2021-10-05 04:27:39 +02:00
span: Span,
) -> (Expression, Option<ParseError>) {
2022-01-01 22:42:50 +01:00
trace!("parsing: duration");
let bytes = working_set.get_span_contents(span);
match parse_duration_bytes(bytes, span) {
Some(expression) => (expression, None),
None => (
garbage(span),
Some(ParseError::Mismatch(
"duration".into(),
"non-duration unit".into(),
span,
)),
),
}
}
pub fn parse_duration_bytes(bytes: &[u8], span: Span) -> Option<Expression> {
2021-10-05 04:27:39 +02:00
fn parse_decimal_str_to_number(decimal: &str) -> Option<i64> {
let string_to_parse = format!("0.{}", decimal);
if let Ok(x) = string_to_parse.parse::<f64>() {
return Some((1_f64 / x) as i64);
}
None
}
if bytes.is_empty() || (!bytes[0].is_ascii_digit() && bytes[0] != b'-') {
return None;
}
2021-10-05 04:27:39 +02:00
let token = String::from_utf8_lossy(bytes).to_string();
let upper = token.to_uppercase();
2021-10-05 04:27:39 +02:00
let unit_groups = [
(Unit::Nanosecond, "NS", None),
(Unit::Microsecond, "US", Some((Unit::Nanosecond, 1000))),
(Unit::Millisecond, "MS", Some((Unit::Microsecond, 1000))),
(Unit::Second, "SEC", Some((Unit::Millisecond, 1000))),
(Unit::Minute, "MIN", Some((Unit::Second, 60))),
(Unit::Hour, "HR", Some((Unit::Minute, 60))),
(Unit::Day, "DAY", Some((Unit::Minute, 1440))),
(Unit::Week, "WK", Some((Unit::Day, 7))),
(Unit::Month, "MONTH", Some((Unit::Day, 30))), //30 day month
(Unit::Year, "YR", Some((Unit::Day, 365))), //365 day year
(Unit::Decade, "DEC", Some((Unit::Year, 10))), //365 day years
2021-10-05 04:27:39 +02:00
];
if let Some(unit) = unit_groups.iter().find(|&x| upper.ends_with(x.1)) {
let mut lhs = token;
2021-10-05 04:27:39 +02:00
for _ in 0..unit.1.len() {
lhs.pop();
}
let input: Vec<&str> = lhs.split('.').collect();
let (value, unit_to_use) = match &input[..] {
[number_str] => (number_str.parse::<i64>().ok(), unit.0),
[number_str, decimal_part_str] => match unit.2 {
Some(unit_to_convert_to) => match (
number_str.parse::<i64>(),
parse_decimal_str_to_number(decimal_part_str),
) {
(Ok(number), Some(decimal_part)) => (
Some(
(number * unit_to_convert_to.1) + (unit_to_convert_to.1 / decimal_part),
),
unit_to_convert_to.0,
),
_ => (None, unit.0),
},
None => (None, unit.0),
},
_ => (None, unit.0),
};
if let Some(x) = value {
2022-01-01 22:42:50 +01:00
trace!("-- found {} {:?}", x, unit_to_use);
2021-10-05 04:27:39 +02:00
let lhs_span = Span::new(span.start, span.start + lhs.len());
let unit_span = Span::new(span.start + lhs.len(), span.end);
return Some(Expression {
expr: Expr::ValueWithUnit(
Box::new(Expression {
expr: Expr::Int(x),
span: lhs_span,
ty: Type::Number,
custom_completion: None,
}),
Spanned {
item: unit_to_use,
span: unit_span,
},
),
span,
ty: Type::Duration,
custom_completion: None,
});
2021-10-05 04:27:39 +02:00
}
}
None
2021-10-05 04:27:39 +02:00
}
/// Parse a unit type, eg '10kb'
pub fn parse_filesize(
working_set: &StateWorkingSet,
2021-10-05 04:27:39 +02:00
span: Span,
) -> (Expression, Option<ParseError>) {
2022-01-01 22:42:50 +01:00
trace!("parsing: duration");
2021-10-05 04:27:39 +02:00
fn parse_decimal_str_to_number(decimal: &str) -> Option<i64> {
let string_to_parse = format!("0.{}", decimal);
if let Ok(x) = string_to_parse.parse::<f64>() {
return Some((1_f64 / x) as i64);
}
None
}
let bytes = working_set.get_span_contents(span);
if bytes.is_empty() || (!bytes[0].is_ascii_digit() && bytes[0] != b'-') {
return (
garbage(span),
Some(ParseError::Mismatch(
"filesize".into(),
"non-filesize unit".into(),
span,
)),
);
}
2021-10-05 04:27:39 +02:00
let token = String::from_utf8_lossy(bytes).to_string();
let upper = token.to_uppercase();
2021-10-05 04:27:39 +02:00
let unit_groups = [
(Unit::Kilobyte, "KB", Some((Unit::Byte, 1000))),
(Unit::Megabyte, "MB", Some((Unit::Kilobyte, 1000))),
(Unit::Gigabyte, "GB", Some((Unit::Megabyte, 1000))),
(Unit::Terabyte, "TB", Some((Unit::Gigabyte, 1000))),
(Unit::Petabyte, "PB", Some((Unit::Terabyte, 1000))),
(Unit::Exabyte, "EB", Some((Unit::Petabyte, 1000))),
(Unit::Zettabyte, "ZB", Some((Unit::Exabyte, 1000))),
2021-10-05 04:27:39 +02:00
(Unit::Kibibyte, "KIB", Some((Unit::Byte, 1024))),
(Unit::Mebibyte, "MIB", Some((Unit::Kibibyte, 1024))),
(Unit::Gibibyte, "GIB", Some((Unit::Mebibyte, 1024))),
(Unit::Tebibyte, "TIB", Some((Unit::Gibibyte, 1024))),
(Unit::Pebibyte, "PIB", Some((Unit::Tebibyte, 1024))),
(Unit::Exbibyte, "EIB", Some((Unit::Pebibyte, 1024))),
(Unit::Zebibyte, "ZIB", Some((Unit::Exbibyte, 1024))),
2021-10-05 04:27:39 +02:00
(Unit::Byte, "B", None),
];
if let Some(unit) = unit_groups.iter().find(|&x| upper.ends_with(x.1)) {
let mut lhs = token;
2021-10-05 04:27:39 +02:00
for _ in 0..unit.1.len() {
lhs.pop();
}
let input: Vec<&str> = lhs.split('.').collect();
let (value, unit_to_use) = match &input[..] {
[number_str] => (number_str.parse::<i64>().ok(), unit.0),
[number_str, decimal_part_str] => match unit.2 {
Some(unit_to_convert_to) => match (
number_str.parse::<i64>(),
parse_decimal_str_to_number(decimal_part_str),
) {
(Ok(number), Some(decimal_part)) => (
Some(
(number * unit_to_convert_to.1) + (unit_to_convert_to.1 / decimal_part),
),
unit_to_convert_to.0,
),
_ => (None, unit.0),
},
None => (None, unit.0),
},
_ => (None, unit.0),
};
if let Some(x) = value {
2022-01-01 22:42:50 +01:00
trace!("-- found {} {:?}", x, unit_to_use);
2021-10-05 04:27:39 +02:00
let lhs_span = Span::new(span.start, span.start + lhs.len());
let unit_span = Span::new(span.start + lhs.len(), span.end);
return (
Expression {
expr: Expr::ValueWithUnit(
Box::new(Expression {
expr: Expr::Int(x),
span: lhs_span,
ty: Type::Number,
custom_completion: None,
}),
Spanned {
item: unit_to_use,
span: unit_span,
},
),
span,
ty: Type::Filesize,
custom_completion: None,
},
None,
);
}
}
(
garbage(span),
Some(ParseError::Mismatch(
"filesize".into(),
"non-filesize unit".into(),
span,
)),
)
}
2021-10-04 21:21:31 +02:00
pub fn parse_glob_pattern(
working_set: &mut StateWorkingSet,
span: Span,
) -> (Expression, Option<ParseError>) {
let bytes = working_set.get_span_contents(span);
let (token, err) = unescape_unquote_string(bytes, span);
trace!("parsing: glob pattern");
2021-10-04 21:21:31 +02:00
if err.is_none() {
2022-01-01 22:42:50 +01:00
trace!("-- found {}", token);
2021-10-04 21:21:31 +02:00
(
Expression {
expr: Expr::GlobPattern(token),
2021-10-04 21:21:31 +02:00
span,
ty: Type::String,
custom_completion: None,
},
None,
)
} else {
(
garbage(span),
Some(ParseError::Expected("string".into(), span)),
)
}
}
pub fn unescape_string(bytes: &[u8], span: Span) -> (Vec<u8>, Option<ParseError>) {
let mut output = Vec::new();
let mut idx = 0;
let mut err = None;
while idx < bytes.len() {
if bytes[idx] == b'\\' {
// We're in an escape
idx += 1;
match bytes.get(idx) {
Some(b'"') => {
output.push(b'"');
idx += 1;
}
Some(b'\'') => {
output.push(b'\'');
idx += 1;
}
Some(b'\\') => {
output.push(b'\\');
idx += 1;
}
Some(b'/') => {
output.push(b'/');
idx += 1;
}
Some(b'(') => {
output.push(b'(');
idx += 1;
}
Some(b')') => {
output.push(b')');
idx += 1;
}
Some(b'{') => {
output.push(b'{');
idx += 1;
}
Some(b'}') => {
output.push(b'}');
idx += 1;
}
Some(b'$') => {
output.push(b'$');
idx += 1;
}
Some(b'^') => {
output.push(b'^');
idx += 1;
}
Some(b'#') => {
output.push(b'#');
idx += 1;
}
Some(b'|') => {
output.push(b'|');
idx += 1;
}
Some(b'~') => {
output.push(b'~');
idx += 1;
}
Some(b'a') => {
output.push(0x7);
idx += 1;
}
Some(b'b') => {
output.push(0x8);
idx += 1;
}
Some(b'e') => {
output.push(0x1b);
idx += 1;
}
Some(b'f') => {
output.push(0xc);
idx += 1;
}
Some(b'n') => {
output.push(b'\n');
idx += 1;
}
Some(b'r') => {
output.push(b'\r');
idx += 1;
}
Some(b't') => {
output.push(b'\t');
idx += 1;
}
Some(b'u') => {
match (
bytes.get(idx + 1),
bytes.get(idx + 2),
bytes.get(idx + 3),
bytes.get(idx + 4),
) {
(Some(h1), Some(h2), Some(h3), Some(h4)) => {
let s = String::from_utf8(vec![*h1, *h2, *h3, *h4]);
if let Ok(s) = s {
let int = u32::from_str_radix(&s, 16);
if let Ok(int) = int {
let result = char::from_u32(int);
if let Some(result) = result {
let mut buffer = vec![0; 4];
let result = result.encode_utf8(&mut buffer);
for elem in result.bytes() {
output.push(elem);
}
idx += 5;
continue;
}
}
}
err = Some(ParseError::Expected(
"unicode hex value".into(),
Span {
start: (span.start + idx),
end: span.end,
},
));
}
_ => {
err = Some(ParseError::Expected(
"unicode hex value".into(),
Span {
start: (span.start + idx),
end: span.end,
},
));
}
}
idx += 5;
}
_ => {
err = Some(ParseError::Expected(
"supported escape character".into(),
Span {
start: (span.start + idx),
end: span.end,
},
));
}
}
} else {
output.push(bytes[idx]);
idx += 1;
}
}
(output, err)
}
pub fn unescape_unquote_string(bytes: &[u8], span: Span) -> (String, Option<ParseError>) {
if bytes.starts_with(b"\"") {
// Needs unescaping
let bytes = trim_quotes(bytes);
let (bytes, err) = unescape_string(bytes, span);
if let Ok(token) = String::from_utf8(bytes) {
(token, err)
} else {
(
String::new(),
Some(ParseError::Expected("string".into(), span)),
)
}
} else {
let bytes = trim_quotes(bytes);
if let Ok(token) = String::from_utf8(bytes.into()) {
(token, None)
} else {
(
String::new(),
Some(ParseError::Expected("string".into(), span)),
)
}
}
}
2021-09-02 10:25:22 +02:00
pub fn parse_string(
working_set: &mut StateWorkingSet,
span: Span,
expand_aliases_denylist: &[usize],
2021-09-02 10:25:22 +02:00
) -> (Expression, Option<ParseError>) {
2022-01-01 22:42:50 +01:00
trace!("parsing: string");
2021-09-02 10:25:22 +02:00
let bytes = working_set.get_span_contents(span);
2022-01-19 15:58:12 +01:00
// Check for bare word interpolation
if bytes[0] != b'\'' && bytes[0] != b'"' && bytes[0] != b'`' && bytes.contains(&b'(') {
return parse_string_interpolation(working_set, span, expand_aliases_denylist);
}
let (s, err) = unescape_unquote_string(bytes, span);
2021-07-16 22:26:40 +02:00
(
Expression {
expr: Expr::String(s),
span,
ty: Type::String,
custom_completion: None,
},
err,
)
2021-09-02 10:25:22 +02:00
}
2021-07-02 09:15:30 +02:00
2021-11-04 03:32:35 +01:00
pub fn parse_string_strict(
working_set: &mut StateWorkingSet,
span: Span,
) -> (Expression, Option<ParseError>) {
2022-01-01 22:42:50 +01:00
trace!("parsing: string, with required delimiters");
2021-11-04 03:32:35 +01:00
let bytes = working_set.get_span_contents(span);
2022-01-19 15:58:12 +01:00
// Check for unbalanced quotes:
{
let bytes = if bytes.starts_with(b"$") {
&bytes[1..]
} else {
bytes
};
if bytes.starts_with(b"\"") && (bytes.len() == 1 || !bytes.ends_with(b"\"")) {
return (garbage(span), Some(ParseError::Unclosed("\"".into(), span)));
}
if bytes.starts_with(b"\'") && (bytes.len() == 1 || !bytes.ends_with(b"\'")) {
return (garbage(span), Some(ParseError::Unclosed("\'".into(), span)));
}
2022-01-19 15:58:12 +01:00
}
2021-11-04 03:32:35 +01:00
let (bytes, quoted) = if (bytes.starts_with(b"\"") && bytes.ends_with(b"\"") && bytes.len() > 1)
|| (bytes.starts_with(b"\'") && bytes.ends_with(b"\'") && bytes.len() > 1)
{
(&bytes[1..(bytes.len() - 1)], true)
} else if (bytes.starts_with(b"$\"") && bytes.ends_with(b"\"") && bytes.len() > 2)
|| (bytes.starts_with(b"$\'") && bytes.ends_with(b"\'") && bytes.len() > 2)
{
(&bytes[2..(bytes.len() - 1)], true)
2021-11-04 03:32:35 +01:00
} else {
(bytes, false)
};
if let Ok(token) = String::from_utf8(bytes.into()) {
2022-01-01 22:42:50 +01:00
trace!("-- found {}", token);
2021-11-04 03:32:35 +01:00
if quoted {
(
Expression {
expr: Expr::String(token),
span,
ty: Type::String,
custom_completion: None,
},
None,
)
} else if token.contains(' ') {
(
garbage(span),
Some(ParseError::Expected("string".into(), span)),
)
} else {
(
Expression {
expr: Expr::String(token),
span,
ty: Type::String,
custom_completion: None,
},
None,
)
}
} else {
(
garbage(span),
Some(ParseError::Expected("string".into(), span)),
)
}
}
2021-10-12 19:44:23 +02:00
//TODO: Handle error case for unknown shapes
2021-09-02 10:25:22 +02:00
pub fn parse_shape_name(
working_set: &StateWorkingSet,
2021-09-02 10:25:22 +02:00
bytes: &[u8],
span: Span,
) -> (SyntaxShape, Option<ParseError>) {
let result = match bytes {
b"any" => SyntaxShape::Any,
2022-03-01 00:31:53 +01:00
b"binary" => SyntaxShape::Binary,
b"block" => SyntaxShape::Block(None), //FIXME: Blocks should have known output types
2021-09-07 00:02:24 +02:00
b"cell-path" => SyntaxShape::CellPath,
b"duration" => SyntaxShape::Duration,
2021-10-04 21:21:31 +02:00
b"path" => SyntaxShape::Filepath,
b"directory" => SyntaxShape::Directory,
b"expr" => SyntaxShape::Expression,
b"filesize" => SyntaxShape::Filesize,
2021-09-02 10:25:22 +02:00
b"glob" => SyntaxShape::GlobPattern,
b"int" => SyntaxShape::Int,
2021-09-02 10:25:22 +02:00
b"math" => SyntaxShape::MathExpression,
b"number" => SyntaxShape::Number,
b"operator" => SyntaxShape::Operator,
b"range" => SyntaxShape::Range,
b"cond" => SyntaxShape::RowCondition,
2021-10-12 06:49:17 +02:00
b"bool" => SyntaxShape::Boolean,
b"signature" => SyntaxShape::Signature,
b"string" => SyntaxShape::String,
b"variable" => SyntaxShape::Variable,
b"record" => SyntaxShape::Record,
b"list" => SyntaxShape::List(Box::new(SyntaxShape::Any)),
b"table" => SyntaxShape::Table,
b"error" => SyntaxShape::Error,
_ => {
if bytes.contains(&b'@') {
let str = String::from_utf8_lossy(bytes);
let split: Vec<_> = str.split('@').collect();
let (shape, err) = parse_shape_name(
working_set,
split[0].as_bytes(),
Span {
start: span.start,
end: span.start + split[0].len(),
},
);
let command_name = trim_quotes(split[1].as_bytes());
let decl_id = working_set.find_decl(command_name, &Type::Any);
if let Some(decl_id) = decl_id {
return (SyntaxShape::Custom(Box::new(shape), decl_id), err);
} else {
return (
shape,
Some(ParseError::UnknownCommand(Span {
start: span.start + split[0].len() + 1,
end: span.end,
})),
);
}
} else {
return (SyntaxShape::Any, Some(ParseError::UnknownType(span)));
}
}
2021-09-02 10:25:22 +02:00
};
(result, None)
}
2021-07-16 23:55:12 +02:00
2021-09-04 09:59:38 +02:00
pub fn parse_type(_working_set: &StateWorkingSet, bytes: &[u8]) -> Type {
2021-10-12 06:49:17 +02:00
match bytes {
b"int" => Type::Int,
b"float" => Type::Float,
b"range" => Type::Range,
2021-10-12 06:49:17 +02:00
b"bool" => Type::Bool,
b"string" => Type::String,
b"block" => Type::Block,
b"duration" => Type::Duration,
b"date" => Type::Date,
2021-10-12 06:49:17 +02:00
b"filesize" => Type::Filesize,
b"number" => Type::Number,
b"table" => Type::Table(vec![]), //FIXME
b"error" => Type::Error,
2021-10-12 06:49:17 +02:00
b"binary" => Type::Binary,
_ => Type::Any,
2021-07-16 08:24:46 +02:00
}
2021-09-02 10:25:22 +02:00
}
2021-07-16 08:24:46 +02:00
2021-09-26 20:39:19 +02:00
pub fn parse_import_pattern(
2021-09-27 02:23:22 +02:00
working_set: &mut StateWorkingSet,
spans: &[Span],
expand_aliases_denylist: &[usize],
) -> (Expression, Option<ParseError>) {
2021-09-26 20:39:19 +02:00
let mut error = None;
let (head, head_span) = if let Some(head_span) = spans.get(0) {
(
working_set.get_span_contents(*head_span).to_vec(),
head_span,
)
} else {
2021-09-26 20:39:19 +02:00
return (
garbage(span(spans)),
Some(ParseError::WrongImportPattern(span(spans))),
2021-09-26 20:39:19 +02:00
);
};
2021-09-26 20:39:19 +02:00
Overlays (#5375) * WIP: Start laying overlays * Rename Overlay->Module; Start adding overlay * Revamp adding overlay * Add overlay add tests; Disable debug print * Fix overlay add; Add overlay remove * Add overlay remove tests * Add missing overlay remove file * Add overlay list command * (WIP?) Enable overlays for env vars * Move OverlayFrames to ScopeFrames * (WIP) Move everything to overlays only ScopeFrame contains nothing but overlays now * Fix predecls * Fix wrong overlay id translation and aliases * Fix broken env lookup logic * Remove TODOs * Add overlay add + remove for environment * Add a few overlay tests; Fix overlay add name * Some cleanup; Fix overlay add/remove names * Clippy * Fmt * Remove walls of comments * List overlays from stack; Add debugging flag Currently, the engine state ordering is somehow broken. * Fix (?) overlay list test * Fix tests on Windows * Fix activated overlay ordering * Check for active overlays equality in overlay list This removes the -p flag: Either both parser and engine will have the same overlays, or the command will fail. * Add merging on overlay remove * Change help message and comment * Add some remove-merge/discard tests * (WIP) Track removed overlays properly * Clippy; Fmt * Fix getting last overlay; Fix predecls in overlays * Remove merging; Fix re-add overwriting stuff Also some error message tweaks. * Fix overlay error in the engine * Update variable_completions.rs * Adds flags and optional arguments to view-source (#5446) * added flags and optional arguments to view-source * removed redundant code * removed redundant code * fmt * fix bug in shell_integration (#5450) * fix bug in shell_integration * add some comments * enable cd to work with directory abbreviations (#5452) * enable cd to work with abbreviations * add abbreviation example * fix tests * make it configurable * make cd recornize symblic link (#5454) * implement seq char command to generate single character sequence (#5453) * add tmp code * add seq char command * Add split number flag in `split row` (#5434) Signed-off-by: Yuheng Su <gipsyh.icu@gmail.com> * Add two more overlay tests * Add ModuleId to OverlayFrame * Fix env conversion accidentally activating overlay It activated overlay from permanent state prematurely which would cause `overlay add` to misbehave. * Remove unused parameter; Add overlay list test * Remove added traces * Add overlay commands examples * Modify TODO * Fix $nu.scope iteration * Disallow removing default overlay * Refactor some parser errors * Remove last overlay if no argument * Diversify overlay examples * Make it possible to update overlay's module In case the origin module updates, the overlay add loads the new module, makes it overlay's origin and applies the changes. Before, it was impossible to update the overlay if the module changed. Co-authored-by: JT <547158+jntrnr@users.noreply.github.com> Co-authored-by: pwygab <88221256+merelymyself@users.noreply.github.com> Co-authored-by: Darren Schroeder <343840+fdncred@users.noreply.github.com> Co-authored-by: WindSoilder <WindSoilder@outlook.com> Co-authored-by: Yuheng Su <gipsyh.icu@gmail.com>
2022-05-07 21:39:22 +02:00
let maybe_module_id = working_set.find_module(&head);
let (import_pattern, err) = if let Some(tail_span) = spans.get(1) {
2021-09-26 20:39:19 +02:00
// FIXME: expand this to handle deeper imports once we support module imports
let tail = working_set.get_span_contents(*tail_span);
2021-09-26 20:39:19 +02:00
if tail == b"*" {
(
ImportPattern {
head: ImportPatternHead {
name: head,
Overlays (#5375) * WIP: Start laying overlays * Rename Overlay->Module; Start adding overlay * Revamp adding overlay * Add overlay add tests; Disable debug print * Fix overlay add; Add overlay remove * Add overlay remove tests * Add missing overlay remove file * Add overlay list command * (WIP?) Enable overlays for env vars * Move OverlayFrames to ScopeFrames * (WIP) Move everything to overlays only ScopeFrame contains nothing but overlays now * Fix predecls * Fix wrong overlay id translation and aliases * Fix broken env lookup logic * Remove TODOs * Add overlay add + remove for environment * Add a few overlay tests; Fix overlay add name * Some cleanup; Fix overlay add/remove names * Clippy * Fmt * Remove walls of comments * List overlays from stack; Add debugging flag Currently, the engine state ordering is somehow broken. * Fix (?) overlay list test * Fix tests on Windows * Fix activated overlay ordering * Check for active overlays equality in overlay list This removes the -p flag: Either both parser and engine will have the same overlays, or the command will fail. * Add merging on overlay remove * Change help message and comment * Add some remove-merge/discard tests * (WIP) Track removed overlays properly * Clippy; Fmt * Fix getting last overlay; Fix predecls in overlays * Remove merging; Fix re-add overwriting stuff Also some error message tweaks. * Fix overlay error in the engine * Update variable_completions.rs * Adds flags and optional arguments to view-source (#5446) * added flags and optional arguments to view-source * removed redundant code * removed redundant code * fmt * fix bug in shell_integration (#5450) * fix bug in shell_integration * add some comments * enable cd to work with directory abbreviations (#5452) * enable cd to work with abbreviations * add abbreviation example * fix tests * make it configurable * make cd recornize symblic link (#5454) * implement seq char command to generate single character sequence (#5453) * add tmp code * add seq char command * Add split number flag in `split row` (#5434) Signed-off-by: Yuheng Su <gipsyh.icu@gmail.com> * Add two more overlay tests * Add ModuleId to OverlayFrame * Fix env conversion accidentally activating overlay It activated overlay from permanent state prematurely which would cause `overlay add` to misbehave. * Remove unused parameter; Add overlay list test * Remove added traces * Add overlay commands examples * Modify TODO * Fix $nu.scope iteration * Disallow removing default overlay * Refactor some parser errors * Remove last overlay if no argument * Diversify overlay examples * Make it possible to update overlay's module In case the origin module updates, the overlay add loads the new module, makes it overlay's origin and applies the changes. Before, it was impossible to update the overlay if the module changed. Co-authored-by: JT <547158+jntrnr@users.noreply.github.com> Co-authored-by: pwygab <88221256+merelymyself@users.noreply.github.com> Co-authored-by: Darren Schroeder <343840+fdncred@users.noreply.github.com> Co-authored-by: WindSoilder <WindSoilder@outlook.com> Co-authored-by: Yuheng Su <gipsyh.icu@gmail.com>
2022-05-07 21:39:22 +02:00
id: maybe_module_id,
span: *head_span,
},
members: vec![ImportPatternMember::Glob { span: *tail_span }],
hidden: HashSet::new(),
2021-09-26 20:39:19 +02:00
},
None,
2021-09-26 20:39:19 +02:00
)
2021-09-27 02:23:22 +02:00
} else if tail.starts_with(b"[") {
let (result, err) = parse_list_expression(
working_set,
*tail_span,
&SyntaxShape::String,
expand_aliases_denylist,
);
2021-09-27 02:23:22 +02:00
error = error.or(err);
let mut output = vec![];
match result {
Expression {
expr: Expr::List(list),
..
} => {
for l in list {
let contents = working_set.get_span_contents(l.span);
output.push((contents.to_vec(), l.span));
}
(
ImportPattern {
head: ImportPatternHead {
name: head,
Overlays (#5375) * WIP: Start laying overlays * Rename Overlay->Module; Start adding overlay * Revamp adding overlay * Add overlay add tests; Disable debug print * Fix overlay add; Add overlay remove * Add overlay remove tests * Add missing overlay remove file * Add overlay list command * (WIP?) Enable overlays for env vars * Move OverlayFrames to ScopeFrames * (WIP) Move everything to overlays only ScopeFrame contains nothing but overlays now * Fix predecls * Fix wrong overlay id translation and aliases * Fix broken env lookup logic * Remove TODOs * Add overlay add + remove for environment * Add a few overlay tests; Fix overlay add name * Some cleanup; Fix overlay add/remove names * Clippy * Fmt * Remove walls of comments * List overlays from stack; Add debugging flag Currently, the engine state ordering is somehow broken. * Fix (?) overlay list test * Fix tests on Windows * Fix activated overlay ordering * Check for active overlays equality in overlay list This removes the -p flag: Either both parser and engine will have the same overlays, or the command will fail. * Add merging on overlay remove * Change help message and comment * Add some remove-merge/discard tests * (WIP) Track removed overlays properly * Clippy; Fmt * Fix getting last overlay; Fix predecls in overlays * Remove merging; Fix re-add overwriting stuff Also some error message tweaks. * Fix overlay error in the engine * Update variable_completions.rs * Adds flags and optional arguments to view-source (#5446) * added flags and optional arguments to view-source * removed redundant code * removed redundant code * fmt * fix bug in shell_integration (#5450) * fix bug in shell_integration * add some comments * enable cd to work with directory abbreviations (#5452) * enable cd to work with abbreviations * add abbreviation example * fix tests * make it configurable * make cd recornize symblic link (#5454) * implement seq char command to generate single character sequence (#5453) * add tmp code * add seq char command * Add split number flag in `split row` (#5434) Signed-off-by: Yuheng Su <gipsyh.icu@gmail.com> * Add two more overlay tests * Add ModuleId to OverlayFrame * Fix env conversion accidentally activating overlay It activated overlay from permanent state prematurely which would cause `overlay add` to misbehave. * Remove unused parameter; Add overlay list test * Remove added traces * Add overlay commands examples * Modify TODO * Fix $nu.scope iteration * Disallow removing default overlay * Refactor some parser errors * Remove last overlay if no argument * Diversify overlay examples * Make it possible to update overlay's module In case the origin module updates, the overlay add loads the new module, makes it overlay's origin and applies the changes. Before, it was impossible to update the overlay if the module changed. Co-authored-by: JT <547158+jntrnr@users.noreply.github.com> Co-authored-by: pwygab <88221256+merelymyself@users.noreply.github.com> Co-authored-by: Darren Schroeder <343840+fdncred@users.noreply.github.com> Co-authored-by: WindSoilder <WindSoilder@outlook.com> Co-authored-by: Yuheng Su <gipsyh.icu@gmail.com>
2022-05-07 21:39:22 +02:00
id: maybe_module_id,
span: *head_span,
},
2021-09-27 02:23:22 +02:00
members: vec![ImportPatternMember::List { names: output }],
hidden: HashSet::new(),
2021-09-27 02:23:22 +02:00
},
None,
2021-09-27 02:23:22 +02:00
)
}
_ => (
ImportPattern {
head: ImportPatternHead {
name: head,
Overlays (#5375) * WIP: Start laying overlays * Rename Overlay->Module; Start adding overlay * Revamp adding overlay * Add overlay add tests; Disable debug print * Fix overlay add; Add overlay remove * Add overlay remove tests * Add missing overlay remove file * Add overlay list command * (WIP?) Enable overlays for env vars * Move OverlayFrames to ScopeFrames * (WIP) Move everything to overlays only ScopeFrame contains nothing but overlays now * Fix predecls * Fix wrong overlay id translation and aliases * Fix broken env lookup logic * Remove TODOs * Add overlay add + remove for environment * Add a few overlay tests; Fix overlay add name * Some cleanup; Fix overlay add/remove names * Clippy * Fmt * Remove walls of comments * List overlays from stack; Add debugging flag Currently, the engine state ordering is somehow broken. * Fix (?) overlay list test * Fix tests on Windows * Fix activated overlay ordering * Check for active overlays equality in overlay list This removes the -p flag: Either both parser and engine will have the same overlays, or the command will fail. * Add merging on overlay remove * Change help message and comment * Add some remove-merge/discard tests * (WIP) Track removed overlays properly * Clippy; Fmt * Fix getting last overlay; Fix predecls in overlays * Remove merging; Fix re-add overwriting stuff Also some error message tweaks. * Fix overlay error in the engine * Update variable_completions.rs * Adds flags and optional arguments to view-source (#5446) * added flags and optional arguments to view-source * removed redundant code * removed redundant code * fmt * fix bug in shell_integration (#5450) * fix bug in shell_integration * add some comments * enable cd to work with directory abbreviations (#5452) * enable cd to work with abbreviations * add abbreviation example * fix tests * make it configurable * make cd recornize symblic link (#5454) * implement seq char command to generate single character sequence (#5453) * add tmp code * add seq char command * Add split number flag in `split row` (#5434) Signed-off-by: Yuheng Su <gipsyh.icu@gmail.com> * Add two more overlay tests * Add ModuleId to OverlayFrame * Fix env conversion accidentally activating overlay It activated overlay from permanent state prematurely which would cause `overlay add` to misbehave. * Remove unused parameter; Add overlay list test * Remove added traces * Add overlay commands examples * Modify TODO * Fix $nu.scope iteration * Disallow removing default overlay * Refactor some parser errors * Remove last overlay if no argument * Diversify overlay examples * Make it possible to update overlay's module In case the origin module updates, the overlay add loads the new module, makes it overlay's origin and applies the changes. Before, it was impossible to update the overlay if the module changed. Co-authored-by: JT <547158+jntrnr@users.noreply.github.com> Co-authored-by: pwygab <88221256+merelymyself@users.noreply.github.com> Co-authored-by: Darren Schroeder <343840+fdncred@users.noreply.github.com> Co-authored-by: WindSoilder <WindSoilder@outlook.com> Co-authored-by: Yuheng Su <gipsyh.icu@gmail.com>
2022-05-07 21:39:22 +02:00
id: maybe_module_id,
span: *head_span,
},
2021-09-27 02:23:22 +02:00
members: vec![],
hidden: HashSet::new(),
2021-09-27 02:23:22 +02:00
},
Some(ParseError::ExportNotFound(result.span)),
),
}
2021-09-26 20:39:19 +02:00
} else {
2021-11-14 20:40:26 +01:00
let tail = trim_quotes(tail);
2021-09-26 20:39:19 +02:00
(
ImportPattern {
head: ImportPatternHead {
name: head,
Overlays (#5375) * WIP: Start laying overlays * Rename Overlay->Module; Start adding overlay * Revamp adding overlay * Add overlay add tests; Disable debug print * Fix overlay add; Add overlay remove * Add overlay remove tests * Add missing overlay remove file * Add overlay list command * (WIP?) Enable overlays for env vars * Move OverlayFrames to ScopeFrames * (WIP) Move everything to overlays only ScopeFrame contains nothing but overlays now * Fix predecls * Fix wrong overlay id translation and aliases * Fix broken env lookup logic * Remove TODOs * Add overlay add + remove for environment * Add a few overlay tests; Fix overlay add name * Some cleanup; Fix overlay add/remove names * Clippy * Fmt * Remove walls of comments * List overlays from stack; Add debugging flag Currently, the engine state ordering is somehow broken. * Fix (?) overlay list test * Fix tests on Windows * Fix activated overlay ordering * Check for active overlays equality in overlay list This removes the -p flag: Either both parser and engine will have the same overlays, or the command will fail. * Add merging on overlay remove * Change help message and comment * Add some remove-merge/discard tests * (WIP) Track removed overlays properly * Clippy; Fmt * Fix getting last overlay; Fix predecls in overlays * Remove merging; Fix re-add overwriting stuff Also some error message tweaks. * Fix overlay error in the engine * Update variable_completions.rs * Adds flags and optional arguments to view-source (#5446) * added flags and optional arguments to view-source * removed redundant code * removed redundant code * fmt * fix bug in shell_integration (#5450) * fix bug in shell_integration * add some comments * enable cd to work with directory abbreviations (#5452) * enable cd to work with abbreviations * add abbreviation example * fix tests * make it configurable * make cd recornize symblic link (#5454) * implement seq char command to generate single character sequence (#5453) * add tmp code * add seq char command * Add split number flag in `split row` (#5434) Signed-off-by: Yuheng Su <gipsyh.icu@gmail.com> * Add two more overlay tests * Add ModuleId to OverlayFrame * Fix env conversion accidentally activating overlay It activated overlay from permanent state prematurely which would cause `overlay add` to misbehave. * Remove unused parameter; Add overlay list test * Remove added traces * Add overlay commands examples * Modify TODO * Fix $nu.scope iteration * Disallow removing default overlay * Refactor some parser errors * Remove last overlay if no argument * Diversify overlay examples * Make it possible to update overlay's module In case the origin module updates, the overlay add loads the new module, makes it overlay's origin and applies the changes. Before, it was impossible to update the overlay if the module changed. Co-authored-by: JT <547158+jntrnr@users.noreply.github.com> Co-authored-by: pwygab <88221256+merelymyself@users.noreply.github.com> Co-authored-by: Darren Schroeder <343840+fdncred@users.noreply.github.com> Co-authored-by: WindSoilder <WindSoilder@outlook.com> Co-authored-by: Yuheng Su <gipsyh.icu@gmail.com>
2022-05-07 21:39:22 +02:00
id: maybe_module_id,
span: *head_span,
},
2021-09-26 20:39:19 +02:00
members: vec![ImportPatternMember::Name {
name: tail.to_vec(),
span: *tail_span,
2021-09-26 20:39:19 +02:00
}],
hidden: HashSet::new(),
2021-09-26 20:39:19 +02:00
},
None,
2021-09-26 20:39:19 +02:00
)
}
} else {
(
ImportPattern {
head: ImportPatternHead {
name: head,
Overlays (#5375) * WIP: Start laying overlays * Rename Overlay->Module; Start adding overlay * Revamp adding overlay * Add overlay add tests; Disable debug print * Fix overlay add; Add overlay remove * Add overlay remove tests * Add missing overlay remove file * Add overlay list command * (WIP?) Enable overlays for env vars * Move OverlayFrames to ScopeFrames * (WIP) Move everything to overlays only ScopeFrame contains nothing but overlays now * Fix predecls * Fix wrong overlay id translation and aliases * Fix broken env lookup logic * Remove TODOs * Add overlay add + remove for environment * Add a few overlay tests; Fix overlay add name * Some cleanup; Fix overlay add/remove names * Clippy * Fmt * Remove walls of comments * List overlays from stack; Add debugging flag Currently, the engine state ordering is somehow broken. * Fix (?) overlay list test * Fix tests on Windows * Fix activated overlay ordering * Check for active overlays equality in overlay list This removes the -p flag: Either both parser and engine will have the same overlays, or the command will fail. * Add merging on overlay remove * Change help message and comment * Add some remove-merge/discard tests * (WIP) Track removed overlays properly * Clippy; Fmt * Fix getting last overlay; Fix predecls in overlays * Remove merging; Fix re-add overwriting stuff Also some error message tweaks. * Fix overlay error in the engine * Update variable_completions.rs * Adds flags and optional arguments to view-source (#5446) * added flags and optional arguments to view-source * removed redundant code * removed redundant code * fmt * fix bug in shell_integration (#5450) * fix bug in shell_integration * add some comments * enable cd to work with directory abbreviations (#5452) * enable cd to work with abbreviations * add abbreviation example * fix tests * make it configurable * make cd recornize symblic link (#5454) * implement seq char command to generate single character sequence (#5453) * add tmp code * add seq char command * Add split number flag in `split row` (#5434) Signed-off-by: Yuheng Su <gipsyh.icu@gmail.com> * Add two more overlay tests * Add ModuleId to OverlayFrame * Fix env conversion accidentally activating overlay It activated overlay from permanent state prematurely which would cause `overlay add` to misbehave. * Remove unused parameter; Add overlay list test * Remove added traces * Add overlay commands examples * Modify TODO * Fix $nu.scope iteration * Disallow removing default overlay * Refactor some parser errors * Remove last overlay if no argument * Diversify overlay examples * Make it possible to update overlay's module In case the origin module updates, the overlay add loads the new module, makes it overlay's origin and applies the changes. Before, it was impossible to update the overlay if the module changed. Co-authored-by: JT <547158+jntrnr@users.noreply.github.com> Co-authored-by: pwygab <88221256+merelymyself@users.noreply.github.com> Co-authored-by: Darren Schroeder <343840+fdncred@users.noreply.github.com> Co-authored-by: WindSoilder <WindSoilder@outlook.com> Co-authored-by: Yuheng Su <gipsyh.icu@gmail.com>
2022-05-07 21:39:22 +02:00
id: maybe_module_id,
span: *head_span,
},
2021-09-26 20:39:19 +02:00
members: vec![],
hidden: HashSet::new(),
2021-09-26 20:39:19 +02:00
},
None,
)
};
(
Expression {
expr: Expr::ImportPattern(import_pattern),
span: span(&spans[1..]),
ty: Type::List(Box::new(Type::String)),
custom_completion: None,
},
error.or(err),
)
2021-09-26 20:39:19 +02:00
}
2021-09-02 10:25:22 +02:00
pub fn parse_var_with_opt_type(
working_set: &mut StateWorkingSet,
spans: &[Span],
spans_idx: &mut usize,
) -> (Expression, Option<ParseError>) {
let bytes = working_set.get_span_contents(spans[*spans_idx]).to_vec();
2021-07-16 08:24:46 +02:00
if bytes.contains(&b' ')
|| bytes.contains(&b'"')
|| bytes.contains(&b'\'')
|| bytes.contains(&b'`')
{
2021-10-12 07:08:55 +02:00
return (
garbage(spans[*spans_idx]),
Some(ParseError::VariableNotValid(spans[*spans_idx])),
);
}
2021-09-02 10:25:22 +02:00
if bytes.ends_with(b":") {
// We end with colon, so the next span should be the type
if *spans_idx + 1 < spans.len() {
*spans_idx += 1;
let type_bytes = working_set.get_span_contents(spans[*spans_idx]);
2021-07-16 08:24:46 +02:00
2021-09-02 10:25:22 +02:00
let ty = parse_type(working_set, type_bytes);
2021-07-16 08:24:46 +02:00
let var_name = bytes[0..(bytes.len() - 1)].to_vec();
if !is_variable(&var_name) {
return (
garbage(spans[*spans_idx]),
Some(ParseError::Expected(
"valid variable name".into(),
spans[*spans_idx],
)),
);
}
let id = working_set.add_variable(var_name, spans[*spans_idx - 1], ty.clone());
2021-07-16 08:24:46 +02:00
2021-09-02 10:25:22 +02:00
(
Expression {
2021-10-25 22:04:23 +02:00
expr: Expr::VarDecl(id),
2021-09-02 10:25:22 +02:00
span: span(&spans[*spans_idx - 1..*spans_idx + 1]),
ty,
custom_completion: None,
2021-09-02 10:25:22 +02:00
},
None,
)
2021-07-16 08:24:46 +02:00
} else {
let var_name = bytes[0..(bytes.len() - 1)].to_vec();
if !is_variable(&var_name) {
return (
garbage(spans[*spans_idx]),
Some(ParseError::Expected(
"valid variable name".into(),
spans[*spans_idx],
)),
);
}
let id = working_set.add_variable(var_name, spans[*spans_idx], Type::Any);
2021-07-16 08:24:46 +02:00
(
Expression {
2021-10-25 22:04:23 +02:00
expr: Expr::VarDecl(id),
2021-09-02 10:25:22 +02:00
span: spans[*spans_idx],
ty: Type::Any,
custom_completion: None,
2021-07-16 08:24:46 +02:00
},
2021-09-02 10:25:22 +02:00
Some(ParseError::MissingType(spans[*spans_idx])),
2021-07-16 08:24:46 +02:00
)
}
2021-09-02 10:25:22 +02:00
} else {
let var_name = bytes;
if !is_variable(&var_name) {
return (
garbage(spans[*spans_idx]),
Some(ParseError::Expected(
"valid variable name".into(),
spans[*spans_idx],
)),
);
}
let id = working_set.add_variable(
var_name,
span(&spans[*spans_idx..*spans_idx + 1]),
Type::Any,
);
2021-07-08 00:55:46 +02:00
2021-09-02 10:25:22 +02:00
(
Expression {
2021-10-25 22:04:23 +02:00
expr: Expr::VarDecl(id),
2021-09-02 10:25:22 +02:00
span: span(&spans[*spans_idx..*spans_idx + 1]),
ty: Type::Any,
custom_completion: None,
2021-09-02 10:25:22 +02:00
},
None,
)
}
}
2021-09-09 23:47:20 +02:00
pub fn expand_to_cell_path(
working_set: &mut StateWorkingSet,
expression: &mut Expression,
var_id: VarId,
expand_aliases_denylist: &[usize],
2021-09-09 23:47:20 +02:00
) {
if let Expression {
expr: Expr::String(_),
span,
..
} = expression
{
// Re-parse the string as if it were a cell-path
let (new_expression, _err) =
parse_full_cell_path(working_set, Some(var_id), *span, expand_aliases_denylist);
2021-09-09 23:47:20 +02:00
*expression = new_expression;
}
}
2021-09-02 10:25:22 +02:00
pub fn parse_row_condition(
working_set: &mut StateWorkingSet,
spans: &[Span],
expand_aliases_denylist: &[usize],
2021-09-02 10:25:22 +02:00
) -> (Expression, Option<ParseError>) {
let var_id = working_set.add_variable(b"$it".to_vec(), span(spans), Type::Any);
let (expression, err) =
parse_math_expression(working_set, spans, Some(var_id), expand_aliases_denylist);
2021-09-09 23:47:20 +02:00
let span = span(spans);
2021-11-26 04:49:03 +01:00
let block_id = match expression.expr {
Expr::Block(block_id) => block_id,
_ => {
// We have an expression, so let's convert this into a block.
let mut block = Block::new();
let mut pipeline = Pipeline::new();
pipeline.expressions.push(expression);
block.pipelines.push(pipeline);
2021-11-26 04:49:03 +01:00
block.signature.required_positional.push(PositionalArg {
name: "$it".into(),
desc: "row condition".into(),
shape: SyntaxShape::Any,
var_id: Some(var_id),
2022-03-07 21:08:56 +01:00
default_value: None,
2021-11-26 04:49:03 +01:00
});
working_set.add_block(block)
}
};
2021-09-09 23:47:20 +02:00
(
Expression {
ty: Type::Bool,
span,
2021-11-26 04:49:03 +01:00
expr: Expr::RowCondition(block_id),
custom_completion: None,
2021-09-09 23:47:20 +02:00
},
err,
)
2021-09-02 10:25:22 +02:00
}
2021-07-16 23:55:12 +02:00
2021-09-02 10:25:22 +02:00
pub fn parse_signature(
working_set: &mut StateWorkingSet,
span: Span,
expand_aliases_denylist: &[usize],
2021-09-02 10:25:22 +02:00
) -> (Expression, Option<ParseError>) {
let bytes = working_set.get_span_contents(span);
2021-07-16 23:55:12 +02:00
2021-09-02 10:25:22 +02:00
let mut error = None;
let mut start = span.start;
let mut end = span.end;
2021-07-16 23:55:12 +02:00
2021-09-02 10:25:22 +02:00
if bytes.starts_with(b"[") {
start += 1;
2021-10-11 22:58:38 +02:00
} else {
error = error.or_else(|| {
Some(ParseError::Expected(
"[".into(),
Span {
start,
end: start + 1,
},
))
});
2021-09-02 10:25:22 +02:00
}
2021-10-11 22:58:38 +02:00
2021-09-02 10:25:22 +02:00
if bytes.ends_with(b"]") {
end -= 1;
} else {
error = error.or_else(|| Some(ParseError::Unclosed("]".into(), Span { start: end, end })));
2021-09-02 10:25:22 +02:00
}
2021-07-16 23:55:12 +02:00
let (sig, err) =
parse_signature_helper(working_set, Span { start, end }, expand_aliases_denylist);
2021-09-06 01:16:27 +02:00
error = error.or(err);
(
Expression {
expr: Expr::Signature(sig),
span,
ty: Type::Signature,
custom_completion: None,
2021-09-06 01:16:27 +02:00
},
error,
)
}
pub fn parse_signature_helper(
working_set: &mut StateWorkingSet,
span: Span,
expand_aliases_denylist: &[usize],
2021-09-06 01:16:27 +02:00
) -> (Box<Signature>, Option<ParseError>) {
2022-03-07 21:08:56 +01:00
#[allow(clippy::enum_variant_names)]
2021-09-06 01:16:27 +02:00
enum ParseMode {
ArgMode,
TypeMode,
2022-03-07 21:08:56 +01:00
DefaultValueMode,
2021-09-06 01:16:27 +02:00
}
2022-03-07 21:08:56 +01:00
#[derive(Debug)]
2021-09-06 01:16:27 +02:00
enum Arg {
Positional(PositionalArg, bool), // bool - required
RestPositional(PositionalArg),
2021-09-06 01:16:27 +02:00
Flag(Flag),
}
let mut error = None;
2021-09-02 10:25:22 +02:00
let source = working_set.get_span_contents(span);
2021-07-16 23:55:12 +02:00
2022-03-07 21:08:56 +01:00
let (output, err) = lex(
source,
span.start,
&[b'\n', b'\r', b','],
&[b':', b'='],
false,
);
2021-09-02 10:25:22 +02:00
error = error.or(err);
2021-07-16 23:55:12 +02:00
2021-09-02 10:25:22 +02:00
let mut args: Vec<Arg> = vec![];
let mut parse_mode = ParseMode::ArgMode;
2021-07-16 23:55:12 +02:00
2021-09-02 10:25:22 +02:00
for token in &output {
match token {
Token {
contents: crate::TokenContents::Item,
span,
} => {
let span = *span;
let contents = working_set.get_span_contents(span);
if contents == b":" {
match parse_mode {
ParseMode::ArgMode => {
parse_mode = ParseMode::TypeMode;
2021-07-16 23:55:12 +02:00
}
2022-03-07 21:08:56 +01:00
ParseMode::TypeMode | ParseMode::DefaultValueMode => {
2021-09-02 10:25:22 +02:00
// We're seeing two types for the same thing for some reason, error
error =
error.or_else(|| Some(ParseError::Expected("type".into(), span)));
}
}
2022-03-07 21:08:56 +01:00
} else if contents == b"=" {
match parse_mode {
ParseMode::ArgMode | ParseMode::TypeMode => {
parse_mode = ParseMode::DefaultValueMode;
}
ParseMode::DefaultValueMode => {
// We're seeing two default values for some reason, error
error = error.or_else(|| {
Some(ParseError::Expected("default value".into(), span))
});
}
}
2021-09-02 10:25:22 +02:00
} else {
match parse_mode {
ParseMode::ArgMode => {
if contents.starts_with(b"--") && contents.len() > 2 {
// Long flag
let flags: Vec<_> =
contents.split(|x| x == &b'(').map(|x| x.to_vec()).collect();
2021-10-13 19:53:27 +02:00
let long = String::from_utf8_lossy(&flags[0][2..]).to_string();
let mut variable_name = flags[0][2..].to_vec();
// Replace the '-' in a variable name with '_'
(0..variable_name.len()).for_each(|idx| {
if variable_name[idx] == b'-' {
variable_name[idx] = b'_';
}
});
if !is_variable(&variable_name) {
error = error.or_else(|| {
Some(ParseError::Expected(
"valid variable name".into(),
span,
))
})
}
2022-03-09 10:42:19 +01:00
let var_id =
working_set.add_variable(variable_name, span, Type::Any);
2021-09-02 10:25:22 +02:00
if flags.len() == 1 {
args.push(Arg::Flag(Flag {
arg: None,
desc: String::new(),
long,
short: None,
required: false,
var_id: Some(var_id),
2022-03-07 21:08:56 +01:00
default_value: None,
2021-09-02 10:25:22 +02:00
}));
} else if flags.len() >= 3 {
error = error.or_else(|| {
Some(ParseError::Expected("one short flag".into(), span))
});
2021-09-02 10:25:22 +02:00
} else {
let short_flag = &flags[1];
let short_flag = if !short_flag.starts_with(b"-")
|| !short_flag.ends_with(b")")
{
error = error.or_else(|| {
Some(ParseError::Expected("short flag".into(), span))
});
short_flag
2021-07-17 20:52:50 +02:00
} else {
2021-09-02 10:25:22 +02:00
&short_flag[1..(short_flag.len() - 1)]
};
2021-07-17 00:39:30 +02:00
let short_flag =
String::from_utf8_lossy(short_flag).to_string();
let chars: Vec<char> = short_flag.chars().collect();
2021-10-13 19:53:27 +02:00
let long = String::from_utf8_lossy(&flags[0][2..]).to_string();
2021-09-02 10:25:22 +02:00
let variable_name = flags[0][2..].to_vec();
if !is_variable(&variable_name) {
error = error.or_else(|| {
Some(ParseError::Expected(
"valid variable name".into(),
span,
))
})
}
let var_id =
working_set.add_variable(variable_name, span, Type::Any);
2021-07-17 00:39:30 +02:00
2021-09-02 10:25:22 +02:00
if chars.len() == 1 {
2021-07-17 00:39:30 +02:00
args.push(Arg::Flag(Flag {
arg: None,
desc: String::new(),
2021-09-02 10:25:22 +02:00
long,
2021-07-17 00:39:30 +02:00
short: Some(chars[0]),
required: false,
2021-07-23 23:19:30 +02:00
var_id: Some(var_id),
2022-03-07 21:08:56 +01:00
default_value: None,
2021-07-17 00:39:30 +02:00
}));
2021-09-02 10:25:22 +02:00
} else {
2021-07-30 00:56:51 +02:00
error = error.or_else(|| {
2021-08-17 01:00:00 +02:00
Some(ParseError::Expected("short flag".into(), span))
2021-07-30 00:56:51 +02:00
});
2021-09-02 10:25:22 +02:00
}
}
} else if contents.starts_with(b"-") && contents.len() > 1 {
// Short flag
let short_flag = &contents[1..];
let short_flag = String::from_utf8_lossy(short_flag).to_string();
let chars: Vec<char> = short_flag.chars().collect();
if chars.len() > 1 {
error = error.or_else(|| {
Some(ParseError::Expected("short flag".into(), span))
});
2022-01-06 22:06:54 +01:00
}
2021-09-02 10:25:22 +02:00
2022-01-06 22:06:54 +01:00
let mut encoded_var_name = vec![0u8; 4];
let len = chars[0].encode_utf8(&mut encoded_var_name).len();
let variable_name = encoded_var_name[0..len].to_vec();
if !is_variable(&variable_name) {
error = error.or_else(|| {
Some(ParseError::Expected(
"valid variable name".into(),
span,
))
})
}
2022-03-09 10:42:19 +01:00
let var_id =
working_set.add_variable(variable_name, span, Type::Any);
2021-09-02 10:25:22 +02:00
2022-01-06 22:06:54 +01:00
args.push(Arg::Flag(Flag {
arg: None,
desc: String::new(),
long: String::new(),
short: Some(chars[0]),
required: false,
var_id: Some(var_id),
2022-03-07 21:08:56 +01:00
default_value: None,
2022-01-06 22:06:54 +01:00
}));
2021-09-02 10:25:22 +02:00
} else if contents.starts_with(b"(-") {
let short_flag = &contents[2..];
let short_flag = if !short_flag.ends_with(b")") {
error = error.or_else(|| {
Some(ParseError::Expected("short flag".into(), span))
});
short_flag
} else {
&short_flag[..(short_flag.len() - 1)]
};
2021-07-17 20:52:50 +02:00
2021-09-02 10:25:22 +02:00
let short_flag = String::from_utf8_lossy(short_flag).to_string();
let chars: Vec<char> = short_flag.chars().collect();
2021-07-17 20:52:50 +02:00
2021-09-02 10:25:22 +02:00
if chars.len() == 1 {
match args.last_mut() {
Some(Arg::Flag(flag)) => {
if flag.short.is_some() {
2021-07-30 00:56:51 +02:00
error = error.or_else(|| {
2021-08-17 01:00:00 +02:00
Some(ParseError::Expected(
2021-09-02 10:25:22 +02:00
"one short flag".into(),
2021-07-30 00:56:51 +02:00
span,
))
});
2021-09-02 10:25:22 +02:00
} else {
flag.short = Some(chars[0]);
2021-07-17 20:52:50 +02:00
}
}
2021-09-02 10:25:22 +02:00
_ => {
error = error.or_else(|| {
Some(ParseError::Expected(
"unknown flag".into(),
span,
))
});
}
2021-07-17 20:52:50 +02:00
}
2021-07-30 00:56:51 +02:00
} else {
2021-09-02 10:25:22 +02:00
error = error.or_else(|| {
Some(ParseError::Expected("short flag".into(), span))
});
2021-07-16 23:55:12 +02:00
}
2021-09-02 10:25:22 +02:00
} else if contents.ends_with(b"?") {
let contents: Vec<_> = contents[..(contents.len() - 1)].into();
let name = String::from_utf8_lossy(&contents).to_string();
if !is_variable(&contents) {
error = error.or_else(|| {
Some(ParseError::Expected(
"valid variable name".into(),
span,
))
})
}
let var_id = working_set.add_variable(contents, span, Type::Any);
2021-09-02 10:25:22 +02:00
// Positional arg, optional
args.push(Arg::Positional(
PositionalArg {
desc: String::new(),
name,
shape: SyntaxShape::Any,
var_id: Some(var_id),
2022-03-07 21:08:56 +01:00
default_value: None,
2021-09-02 10:25:22 +02:00
},
false,
))
2021-09-07 05:37:02 +02:00
} else if let Some(contents) = contents.strip_prefix(b"...") {
let name = String::from_utf8_lossy(contents).to_string();
let contents_vec: Vec<u8> = contents.to_vec();
if !is_variable(&contents_vec) {
error = error.or_else(|| {
Some(ParseError::Expected(
"valid variable name".into(),
span,
))
})
}
2021-09-07 05:37:02 +02:00
2022-03-09 10:42:19 +01:00
let var_id =
working_set.add_variable(contents_vec, span, Type::Any);
2021-09-07 05:37:02 +02:00
args.push(Arg::RestPositional(PositionalArg {
desc: String::new(),
name,
shape: SyntaxShape::Any,
var_id: Some(var_id),
2022-03-07 21:08:56 +01:00
default_value: None,
}));
2021-09-02 10:25:22 +02:00
} else {
let name = String::from_utf8_lossy(contents).to_string();
let contents_vec = contents.to_vec();
if !is_variable(&contents_vec) {
error = error.or_else(|| {
Some(ParseError::Expected(
"valid variable name".into(),
span,
))
})
}
2022-03-09 10:42:19 +01:00
let var_id =
working_set.add_variable(contents_vec, span, Type::Any);
2021-09-02 10:25:22 +02:00
// Positional arg, required
args.push(Arg::Positional(
PositionalArg {
desc: String::new(),
name,
shape: SyntaxShape::Any,
var_id: Some(var_id),
2022-03-07 21:08:56 +01:00
default_value: None,
2021-09-02 10:25:22 +02:00
},
true,
))
2021-07-16 23:55:12 +02:00
}
2021-09-02 10:25:22 +02:00
}
ParseMode::TypeMode => {
if let Some(last) = args.last_mut() {
let (syntax_shape, err) =
parse_shape_name(working_set, contents, span);
error = error.or(err);
2021-10-12 19:44:23 +02:00
//TODO check if we're replacing a custom parameter already
2021-09-02 10:25:22 +02:00
match last {
Arg::Positional(PositionalArg { shape, var_id, .. }, ..) => {
working_set.set_variable_type(var_id.expect("internal error: all custom parameters must have var_ids"), syntax_shape.to_type());
*shape = syntax_shape;
}
Arg::RestPositional(PositionalArg {
shape, var_id, ..
}) => {
working_set.set_variable_type(var_id.expect("internal error: all custom parameters must have var_ids"), syntax_shape.to_type());
*shape = syntax_shape;
}
2021-09-02 10:25:22 +02:00
Arg::Flag(Flag { arg, var_id, .. }) => {
2021-10-12 06:49:17 +02:00
// Flags with a boolean type are just present/not-present switches
if syntax_shape != SyntaxShape::Boolean {
working_set.set_variable_type(var_id.expect("internal error: all custom parameters must have var_ids"), syntax_shape.to_type());
*arg = Some(syntax_shape)
}
2021-07-16 23:55:12 +02:00
}
}
}
2021-09-02 10:25:22 +02:00
parse_mode = ParseMode::ArgMode;
2021-07-16 23:55:12 +02:00
}
2022-03-07 21:08:56 +01:00
ParseMode::DefaultValueMode => {
if let Some(last) = args.last_mut() {
let (expression, err) = parse_value(
working_set,
span,
&SyntaxShape::Any,
expand_aliases_denylist,
);
2022-03-07 21:08:56 +01:00
error = error.or(err);
//TODO check if we're replacing a custom parameter already
match last {
Arg::Positional(
PositionalArg {
shape,
var_id,
default_value,
..
},
required,
) => {
let var_id = var_id.expect("internal error: all custom parameters must have var_ids");
2022-03-09 10:42:19 +01:00
let var_type = &working_set.get_variable(var_id).ty;
2022-03-07 21:08:56 +01:00
match var_type {
Type::Any => {
2022-03-07 21:08:56 +01:00
working_set.set_variable_type(
var_id,
expression.ty.clone(),
);
}
t => {
if t != &expression.ty {
error = error.or_else(|| {
Some(ParseError::AssignmentMismatch(
"Default value wrong type".into(),
format!("default value not {}", t),
expression.span,
))
})
}
}
}
*shape = expression.ty.to_shape();
*default_value = Some(expression);
*required = false;
}
Arg::RestPositional(..) => {
error = error.or_else(|| {
Some(ParseError::AssignmentMismatch(
"Rest parameter given default value".into(),
"can't have default value".into(),
expression.span,
))
})
}
Arg::Flag(Flag {
arg,
var_id,
default_value,
..
}) => {
let var_id = var_id.expect("internal error: all custom parameters must have var_ids");
2022-03-09 10:42:19 +01:00
let var_type = &working_set.get_variable(var_id).ty;
2022-03-07 21:08:56 +01:00
let expression_ty = expression.ty.clone();
let expression_span = expression.span;
*default_value = Some(expression);
// Flags with a boolean type are just present/not-present switches
if var_type != &Type::Bool {
match var_type {
Type::Any => {
2022-03-07 21:08:56 +01:00
*arg = Some(expression_ty.to_shape());
working_set
.set_variable_type(var_id, expression_ty);
}
t => {
if t != &expression_ty {
error = error.or_else(|| {
Some(ParseError::AssignmentMismatch(
"Default value wrong type".into(),
format!("default value not {}", t),
expression_span,
))
})
}
}
}
}
}
}
}
parse_mode = ParseMode::ArgMode;
}
2021-07-16 23:55:12 +02:00
}
}
2021-09-02 10:25:22 +02:00
}
Token {
contents: crate::TokenContents::Comment,
span,
} => {
let contents = working_set.get_span_contents(Span {
start: span.start + 1,
end: span.end,
});
let mut contents = String::from_utf8_lossy(contents).to_string();
contents = contents.trim().into();
if let Some(last) = args.last_mut() {
match last {
Arg::Flag(flag) => {
if !flag.desc.is_empty() {
flag.desc.push('\n');
2021-07-17 00:31:36 +02:00
}
2021-09-02 10:25:22 +02:00
flag.desc.push_str(&contents);
}
Arg::Positional(positional, ..) => {
if !positional.desc.is_empty() {
positional.desc.push('\n');
2021-07-17 00:31:36 +02:00
}
2021-09-02 10:25:22 +02:00
positional.desc.push_str(&contents);
2021-07-17 00:31:36 +02:00
}
Arg::RestPositional(positional) => {
if !positional.desc.is_empty() {
positional.desc.push('\n');
}
positional.desc.push_str(&contents);
}
2021-07-17 00:31:36 +02:00
}
}
2021-07-16 23:55:12 +02:00
}
2021-09-02 10:25:22 +02:00
_ => {}
2021-07-16 23:55:12 +02:00
}
2021-09-02 10:25:22 +02:00
}
2021-07-16 23:55:12 +02:00
2021-09-02 10:25:22 +02:00
let mut sig = Signature::new(String::new());
for arg in args {
match arg {
Arg::Positional(positional, required) => {
2021-09-07 05:37:02 +02:00
if required {
2022-03-07 21:08:56 +01:00
if !sig.optional_positional.is_empty() {
error = error.or_else(|| {
Some(ParseError::RequiredAfterOptional(
positional.name.clone(),
span,
))
})
}
2021-09-02 10:25:22 +02:00
sig.required_positional.push(positional)
} else {
sig.optional_positional.push(positional)
2021-07-17 00:53:45 +02:00
}
2021-07-16 23:55:12 +02:00
}
2021-09-02 10:25:22 +02:00
Arg::Flag(flag) => sig.named.push(flag),
Arg::RestPositional(positional) => {
if positional.name.is_empty() {
error = error.or(Some(ParseError::RestNeedsName(span)))
} else if sig.rest_positional.is_none() {
sig.rest_positional = Some(PositionalArg {
name: positional.name,
..positional
})
} else {
// Too many rest params
error = error.or(Some(ParseError::MultipleRestParams(span)))
}
}
2021-07-16 23:55:12 +02:00
}
}
2021-09-06 01:16:27 +02:00
(Box::new(sig), error)
2021-09-02 10:25:22 +02:00
}
2021-07-08 09:49:17 +02:00
2021-09-02 10:25:22 +02:00
pub fn parse_list_expression(
working_set: &mut StateWorkingSet,
span: Span,
element_shape: &SyntaxShape,
expand_aliases_denylist: &[usize],
2021-09-02 10:25:22 +02:00
) -> (Expression, Option<ParseError>) {
let bytes = working_set.get_span_contents(span);
2021-07-08 09:49:17 +02:00
2021-09-02 10:25:22 +02:00
let mut error = None;
2021-07-08 09:49:17 +02:00
2021-09-02 10:25:22 +02:00
let mut start = span.start;
let mut end = span.end;
2021-07-08 09:49:17 +02:00
2021-09-02 10:25:22 +02:00
if bytes.starts_with(b"[") {
start += 1;
}
if bytes.ends_with(b"]") {
end -= 1;
} else {
error = error.or_else(|| Some(ParseError::Unclosed("]".into(), Span { start: end, end })));
2021-09-02 10:25:22 +02:00
}
2021-07-08 09:49:17 +02:00
let inner_span = Span { start, end };
let source = working_set.get_span_contents(inner_span);
2021-07-08 09:49:17 +02:00
let (output, err) = lex(source, inner_span.start, &[b'\n', b'\r', b','], &[], true);
2021-09-02 10:25:22 +02:00
error = error.or(err);
2021-07-08 09:49:17 +02:00
2021-09-02 10:25:22 +02:00
let (output, err) = lite_parse(&output);
error = error.or(err);
2021-07-08 23:45:56 +02:00
2021-09-02 10:25:22 +02:00
let mut args = vec![];
2021-08-17 02:26:05 +02:00
2021-09-02 10:25:22 +02:00
let mut contained_type: Option<Type> = None;
2021-07-08 09:49:17 +02:00
2021-09-02 10:25:22 +02:00
if !output.block.is_empty() {
for arg in &output.block[0].commands {
let mut spans_idx = 0;
2021-07-08 23:45:56 +02:00
2021-09-02 10:25:22 +02:00
while spans_idx < arg.parts.len() {
let (arg, err) = parse_multispan_value(
working_set,
&arg.parts,
&mut spans_idx,
element_shape,
expand_aliases_denylist,
);
2021-09-02 10:25:22 +02:00
error = error.or(err);
if let Some(ref ctype) = contained_type {
if *ctype != arg.ty {
contained_type = Some(Type::Any);
2021-08-17 02:26:05 +02:00
}
2021-09-02 10:25:22 +02:00
} else {
contained_type = Some(arg.ty.clone());
}
2021-08-17 02:26:05 +02:00
2021-09-02 10:25:22 +02:00
args.push(arg);
2021-07-16 08:24:46 +02:00
2021-09-02 10:25:22 +02:00
spans_idx += 1;
2021-07-08 09:49:17 +02:00
}
}
}
2021-09-02 10:25:22 +02:00
(
Expression {
expr: Expr::List(args),
span,
ty: Type::List(Box::new(if let Some(ty) = contained_type {
2021-09-04 09:59:38 +02:00
ty
2021-09-02 10:25:22 +02:00
} else {
Type::Any
2021-09-02 10:25:22 +02:00
})),
custom_completion: None,
2021-09-02 10:25:22 +02:00
},
error,
)
}
pub fn parse_table_expression(
working_set: &mut StateWorkingSet,
2021-09-08 20:54:27 +02:00
original_span: Span,
expand_aliases_denylist: &[usize],
2021-09-02 10:25:22 +02:00
) -> (Expression, Option<ParseError>) {
2021-09-08 20:54:27 +02:00
let bytes = working_set.get_span_contents(original_span);
2021-09-02 10:25:22 +02:00
let mut error = None;
2021-07-06 00:58:56 +02:00
2021-09-08 20:54:27 +02:00
let mut start = original_span.start;
let mut end = original_span.end;
2021-07-06 00:58:56 +02:00
2021-09-02 10:25:22 +02:00
if bytes.starts_with(b"[") {
start += 1;
}
if bytes.ends_with(b"]") {
end -= 1;
} else {
error = error.or_else(|| Some(ParseError::Unclosed("]".into(), Span { start: end, end })));
2021-09-02 10:25:22 +02:00
}
2021-07-06 00:58:56 +02:00
let inner_span = Span { start, end };
2021-07-06 00:58:56 +02:00
let source = working_set.get_span_contents(inner_span);
2021-07-06 00:58:56 +02:00
2021-11-21 19:13:09 +01:00
let (output, err) = lex(source, start, &[b'\n', b'\r', b','], &[], true);
2021-09-02 10:25:22 +02:00
error = error.or(err);
2021-07-06 00:58:56 +02:00
2021-09-02 10:25:22 +02:00
let (output, err) = lite_parse(&output);
error = error.or(err);
2021-07-06 00:58:56 +02:00
2021-09-02 10:25:22 +02:00
match output.block.len() {
0 => (
Expression {
expr: Expr::List(vec![]),
span: original_span,
ty: Type::List(Box::new(Type::Any)),
custom_completion: None,
2021-09-02 10:25:22 +02:00
},
None,
),
1 => {
// List
parse_list_expression(
working_set,
original_span,
&SyntaxShape::Any,
expand_aliases_denylist,
)
2021-09-02 10:25:22 +02:00
}
_ => {
let mut table_headers = vec![];
let (headers, err) = parse_value(
working_set,
output.block[0].commands[0].parts[0],
&SyntaxShape::List(Box::new(SyntaxShape::Any)),
expand_aliases_denylist,
2021-09-02 10:25:22 +02:00
);
error = error.or(err);
if let Expression {
expr: Expr::List(headers),
..
} = headers
{
table_headers = headers;
2021-07-06 00:58:56 +02:00
}
2021-07-06 03:48:45 +02:00
2021-09-02 10:25:22 +02:00
let mut rows = vec![];
for part in &output.block[1].commands[0].parts {
let (values, err) = parse_value(
working_set,
*part,
2021-08-28 21:17:30 +02:00
&SyntaxShape::List(Box::new(SyntaxShape::Any)),
expand_aliases_denylist,
2021-08-28 21:17:30 +02:00
);
2021-07-06 03:48:45 +02:00
error = error.or(err);
if let Expression {
2021-09-02 10:25:22 +02:00
expr: Expr::List(values),
2021-09-08 20:54:27 +02:00
span,
2021-07-06 03:48:45 +02:00
..
2021-09-02 10:25:22 +02:00
} = values
2021-07-06 03:48:45 +02:00
{
2021-09-08 20:54:27 +02:00
match values.len().cmp(&table_headers.len()) {
std::cmp::Ordering::Less => {
error = error
.or(Some(ParseError::MissingColumns(table_headers.len(), span)))
2021-09-08 20:54:27 +02:00
}
std::cmp::Ordering::Equal => {}
std::cmp::Ordering::Greater => {
error = error.or_else(|| {
Some(ParseError::ExtraColumns(
table_headers.len(),
values[table_headers.len()].span,
))
})
}
}
2021-09-02 10:25:22 +02:00
rows.push(values);
2021-07-06 03:48:45 +02:00
}
}
2021-07-02 09:32:30 +02:00
2021-09-02 10:25:22 +02:00
(
Expression {
expr: Expr::Table(table_headers, rows),
span: original_span,
ty: Type::Table(vec![]), //FIXME
custom_completion: None,
2021-09-02 10:25:22 +02:00
},
error,
)
2021-07-02 09:32:30 +02:00
}
2021-09-02 10:25:22 +02:00
}
}
2021-07-02 09:32:30 +02:00
2021-09-02 10:25:22 +02:00
pub fn parse_block_expression(
working_set: &mut StateWorkingSet,
shape: &SyntaxShape,
2021-09-02 10:25:22 +02:00
span: Span,
expand_aliases_denylist: &[usize],
2021-09-02 10:25:22 +02:00
) -> (Expression, Option<ParseError>) {
2022-01-01 22:42:50 +01:00
trace!("parsing: block expression");
2021-09-02 10:25:22 +02:00
let bytes = working_set.get_span_contents(span);
let mut error = None;
2021-07-02 09:32:30 +02:00
2021-09-02 10:25:22 +02:00
let mut start = span.start;
let mut end = span.end;
2021-07-02 09:32:30 +02:00
2021-09-02 10:25:22 +02:00
if bytes.starts_with(b"{") {
start += 1;
} else {
return (
garbage(span),
Some(ParseError::Expected("block".into(), span)),
);
}
if bytes.ends_with(b"}") {
end -= 1;
} else {
error = error.or_else(|| Some(ParseError::Unclosed("}".into(), Span { start: end, end })));
2021-09-02 10:25:22 +02:00
}
2021-07-02 09:32:30 +02:00
2022-01-03 06:21:26 +01:00
let inner_span = Span { start, end };
2021-09-02 10:25:22 +02:00
2022-01-03 06:21:26 +01:00
let source = working_set.get_span_contents(inner_span);
2021-09-02 10:25:22 +02:00
let (output, err) = lex(source, start, &[], &[], false);
2021-09-02 10:25:22 +02:00
error = error.or(err);
2021-09-06 04:20:02 +02:00
working_set.enter_scope();
2021-09-08 00:00:20 +02:00
2021-09-02 10:25:22 +02:00
// Check to see if we have parameters
let (signature, amt_to_skip): (Option<(Box<Signature>, Span)>, usize) = match output.first() {
2021-09-02 10:25:22 +02:00
Some(Token {
contents: TokenContents::Pipe,
2021-09-06 01:16:27 +02:00
span,
}) => {
// We've found a parameter list
let start_point = span.start;
let mut token_iter = output.iter().enumerate().skip(1);
let mut end_span = None;
let mut amt_to_skip = 1;
for token in &mut token_iter {
if let Token {
2021-09-02 10:25:22 +02:00
contents: TokenContents::Pipe,
2021-09-06 01:16:27 +02:00
span,
} = token.1
{
end_span = Some(span);
amt_to_skip = token.0;
break;
2021-08-25 21:29:36 +02:00
}
}
2021-09-06 01:16:27 +02:00
let end_point = if let Some(span) = end_span {
span.end
} else {
end
};
let signature_span = Span {
start: start_point,
end: end_point,
};
let (signature, err) =
parse_signature_helper(working_set, signature_span, expand_aliases_denylist);
2021-09-06 01:16:27 +02:00
error = error.or(err);
(Some((signature, signature_span)), amt_to_skip)
2021-09-02 10:25:22 +02:00
}
2021-09-06 01:16:27 +02:00
_ => (None, 0),
2021-09-02 10:25:22 +02:00
};
2021-08-25 21:29:36 +02:00
2021-09-06 01:16:27 +02:00
let (output, err) = lite_parse(&output[amt_to_skip..]);
2021-09-02 10:25:22 +02:00
error = error.or(err);
2021-07-02 09:32:30 +02:00
// TODO: Finish this
if let SyntaxShape::Block(Some(v)) = shape {
if let Some((sig, sig_span)) = &signature {
if sig.num_positionals() > v.len() {
error = error.or_else(|| {
Some(ParseError::Expected(
format!(
"{} block parameter{}",
v.len(),
if v.len() > 1 { "s" } else { "" }
),
*sig_span,
))
});
}
for (expected, PositionalArg { name, shape, .. }) in
v.iter().zip(sig.required_positional.iter())
{
if expected != shape && *shape != SyntaxShape::Any {
error = error.or_else(|| {
Some(ParseError::ParameterMismatchType(
name.to_owned(),
expected.to_string(),
shape.to_string(),
*sig_span,
))
});
}
}
}
}
let (mut output, err) =
parse_block(working_set, &output, false, expand_aliases_denylist, false);
2021-09-02 10:25:22 +02:00
error = error.or(err);
2021-07-02 09:32:30 +02:00
2021-09-06 01:16:27 +02:00
if let Some(signature) = signature {
output.signature = signature.0;
2021-09-06 04:20:02 +02:00
} else if let Some(last) = working_set.delta.scope.last() {
2021-10-12 19:44:23 +02:00
// FIXME: this only supports the top $it. Is this sufficient?
2021-09-13 09:31:11 +02:00
2021-09-06 04:20:02 +02:00
if let Some(var_id) = last.get_var(b"$it") {
let mut signature = Signature::new("");
signature.required_positional.push(PositionalArg {
var_id: Some(*var_id),
name: "$it".into(),
desc: String::new(),
shape: SyntaxShape::Any,
2022-03-07 21:08:56 +01:00
default_value: None,
2021-09-06 04:20:02 +02:00
});
output.signature = Box::new(signature);
}
2021-09-06 01:16:27 +02:00
}
output.span = Some(span);
2021-10-25 22:04:23 +02:00
2021-09-06 04:20:02 +02:00
working_set.exit_scope();
2021-09-02 10:25:22 +02:00
let block_id = working_set.add_block(output);
2021-07-16 22:26:40 +02:00
2021-09-02 10:25:22 +02:00
(
Expression {
expr: Expr::Block(block_id),
span,
ty: Type::Block,
custom_completion: None,
2021-09-02 10:25:22 +02:00
},
error,
)
}
2021-07-02 09:32:30 +02:00
2021-09-02 10:25:22 +02:00
pub fn parse_value(
working_set: &mut StateWorkingSet,
span: Span,
shape: &SyntaxShape,
expand_aliases_denylist: &[usize],
2021-09-02 10:25:22 +02:00
) -> (Expression, Option<ParseError>) {
let bytes = working_set.get_span_contents(span);
if bytes.is_empty() {
return (garbage(span), Some(ParseError::IncompleteParser(span)));
}
2021-09-02 10:25:22 +02:00
// First, check the special-cases. These will likely represent specific values as expressions
// and may fit a variety of shapes.
//
// We check variable first because immediately following we check for variables with cell paths
2021-09-02 10:25:22 +02:00
// which might result in a value that fits other shapes (and require the variable to already be
// declared)
if shape == &SyntaxShape::Variable {
2022-01-01 22:42:50 +01:00
trace!("parsing: variable");
2021-09-02 10:25:22 +02:00
return parse_variable_expr(working_set, span);
}
2022-01-01 22:42:50 +01:00
// Check for reserved keyword values
match bytes {
b"true" => {
if matches!(shape, SyntaxShape::Boolean) || matches!(shape, SyntaxShape::Any) {
return (
Expression {
expr: Expr::Bool(true),
span,
ty: Type::Bool,
custom_completion: None,
},
None,
);
} else {
return (
Expression::garbage(span),
Some(ParseError::Expected("non-boolean value".into(), span)),
);
}
}
b"false" => {
if matches!(shape, SyntaxShape::Boolean) || matches!(shape, SyntaxShape::Any) {
return (
Expression {
expr: Expr::Bool(false),
span,
ty: Type::Bool,
custom_completion: None,
},
None,
);
} else {
return (
Expression::garbage(span),
Some(ParseError::Expected("non-boolean value".into(), span)),
);
}
}
b"null" => {
return (
Expression {
expr: Expr::Nothing,
span,
ty: Type::Nothing,
custom_completion: None,
},
None,
);
}
_ => {}
}
match bytes[0] {
b'$' => return parse_dollar_expr(working_set, span, expand_aliases_denylist),
b'(' => {
if let (expr, None) = parse_range(working_set, span, expand_aliases_denylist) {
2021-11-11 00:14:00 +01:00
return (expr, None);
} else {
return parse_full_cell_path(working_set, None, span, expand_aliases_denylist);
2021-11-11 00:14:00 +01:00
}
}
b'{' => {
if !matches!(shape, SyntaxShape::Block(..)) {
if let (expr, None) =
parse_full_cell_path(working_set, None, span, expand_aliases_denylist)
{
return (expr, None);
}
}
if matches!(shape, SyntaxShape::Block(_)) || matches!(shape, SyntaxShape::Any) {
return parse_block_expression(working_set, shape, span, expand_aliases_denylist);
} else if matches!(shape, SyntaxShape::Record) {
return parse_record(working_set, span, expand_aliases_denylist);
} else {
return (
Expression::garbage(span),
Some(ParseError::Expected("non-block value".into(), span)),
);
}
2021-09-04 08:52:28 +02:00
}
b'[' => match shape {
2021-09-02 10:25:22 +02:00
SyntaxShape::Any
| SyntaxShape::List(_)
| SyntaxShape::Table
| SyntaxShape::Signature => {}
_ => {
return (
Expression::garbage(span),
Some(ParseError::Expected("non-[] value".into(), span)),
);
2021-07-08 23:45:56 +02:00
}
},
_ => {}
2021-09-02 10:25:22 +02:00
}
2021-07-01 03:31:02 +02:00
2021-09-02 10:25:22 +02:00
match shape {
SyntaxShape::Custom(shape, custom_completion) => {
let (mut expression, err) =
parse_value(working_set, span, shape, expand_aliases_denylist);
expression.custom_completion = Some(*custom_completion);
(expression, err)
}
2021-09-07 00:02:24 +02:00
SyntaxShape::Number => parse_number(bytes, span),
SyntaxShape::Int => parse_int(bytes, span),
2021-10-05 04:27:39 +02:00
SyntaxShape::Duration => parse_duration(working_set, span),
SyntaxShape::DateTime => parse_datetime(working_set, span),
2021-10-05 04:27:39 +02:00
SyntaxShape::Filesize => parse_filesize(working_set, span),
SyntaxShape::Range => parse_range(working_set, span, expand_aliases_denylist),
2021-10-04 21:21:31 +02:00
SyntaxShape::Filepath => parse_filepath(working_set, span),
SyntaxShape::Directory => parse_directory(working_set, span),
2021-10-04 21:21:31 +02:00
SyntaxShape::GlobPattern => parse_glob_pattern(working_set, span),
SyntaxShape::String => parse_string(working_set, span, expand_aliases_denylist),
2022-03-01 00:31:53 +01:00
SyntaxShape::Binary => parse_binary(working_set, span),
2021-09-02 10:25:22 +02:00
SyntaxShape::Signature => {
if bytes.starts_with(b"[") {
parse_signature(working_set, span, expand_aliases_denylist)
2021-09-02 10:25:22 +02:00
} else {
(
Expression::garbage(span),
Some(ParseError::Expected("signature".into(), span)),
)
2021-07-09 08:23:20 +02:00
}
2021-09-02 10:25:22 +02:00
}
SyntaxShape::List(elem) => {
if bytes.starts_with(b"[") {
parse_list_expression(working_set, span, elem, expand_aliases_denylist)
2021-09-02 10:25:22 +02:00
} else {
(
Expression::garbage(span),
Some(ParseError::Expected("list".into(), span)),
)
2021-07-08 09:49:17 +02:00
}
2021-09-02 10:25:22 +02:00
}
SyntaxShape::Table => {
if bytes.starts_with(b"[") {
parse_table_expression(working_set, span, expand_aliases_denylist)
2021-09-02 10:25:22 +02:00
} else {
2021-07-02 08:44:37 +02:00
(
2021-09-02 10:25:22 +02:00
Expression::garbage(span),
Some(ParseError::Expected("table".into(), span)),
2021-07-02 08:44:37 +02:00
)
}
2021-07-01 02:01:04 +02:00
}
2021-10-02 04:59:11 +02:00
SyntaxShape::CellPath => {
let source = working_set.get_span_contents(span);
let mut error = None;
2021-11-21 19:13:09 +01:00
let (tokens, err) = lex(source, span.start, &[b'\n', b'\r'], &[b'.'], true);
2021-10-02 04:59:11 +02:00
error = error.or(err);
let tokens = tokens.into_iter().peekable();
let (cell_path, err) =
parse_cell_path(working_set, tokens, false, expand_aliases_denylist, span);
2021-10-02 04:59:11 +02:00
error = error.or(err);
(
Expression {
expr: Expr::CellPath(CellPath { members: cell_path }),
span,
ty: Type::CellPath,
custom_completion: None,
},
error,
)
}
2021-10-12 06:49:17 +02:00
SyntaxShape::Boolean => {
// Redundant, though we catch bad boolean parses here
if bytes == b"true" || bytes == b"false" {
2021-10-12 06:49:17 +02:00
(
Expression {
expr: Expr::Bool(true),
span,
ty: Type::Bool,
custom_completion: None,
},
None,
)
} else {
(
garbage(span),
Some(ParseError::Expected("bool".into(), span)),
)
}
}
2021-09-02 10:25:22 +02:00
SyntaxShape::Any => {
if bytes.starts_with(b"[") {
//parse_value(working_set, span, &SyntaxShape::Table)
parse_full_cell_path(working_set, None, span, expand_aliases_denylist)
} else {
let shapes = [
2022-03-01 00:31:53 +01:00
SyntaxShape::Binary,
SyntaxShape::Int,
SyntaxShape::Number,
SyntaxShape::Range,
SyntaxShape::DateTime,
SyntaxShape::Filesize,
SyntaxShape::Duration,
SyntaxShape::Record,
SyntaxShape::Block(None),
SyntaxShape::String,
];
for shape in shapes.iter() {
if let (s, None) =
parse_value(working_set, span, shape, expand_aliases_denylist)
{
return (s, None);
}
}
(
garbage(span),
Some(ParseError::Expected("any shape".into(), span)),
)
2021-07-02 08:44:37 +02:00
}
2021-09-02 10:25:22 +02:00
}
_ => (garbage(span), Some(ParseError::IncompleteParser(span))),
2021-07-02 08:44:37 +02:00
}
2021-09-02 10:25:22 +02:00
}
2021-07-02 08:44:37 +02:00
2021-09-02 10:25:22 +02:00
pub fn parse_operator(
working_set: &mut StateWorkingSet,
span: Span,
) -> (Expression, Option<ParseError>) {
let contents = working_set.get_span_contents(span);
let operator = match contents {
b"==" => Operator::Equal,
b"!=" => Operator::NotEqual,
b"<" => Operator::LessThan,
b"<=" => Operator::LessThanOrEqual,
b">" => Operator::GreaterThan,
b">=" => Operator::GreaterThanOrEqual,
b"=~" => Operator::RegexMatch,
b"!~" => Operator::NotRegexMatch,
2021-09-02 10:25:22 +02:00
b"+" => Operator::Plus,
b"-" => Operator::Minus,
b"*" => Operator::Multiply,
b"/" => Operator::Divide,
b"//" => Operator::FloorDivision,
2021-09-02 10:25:22 +02:00
b"in" => Operator::In,
b"not-in" => Operator::NotIn,
b"mod" => Operator::Modulo,
b"bit-or" => Operator::BitOr,
2022-07-03 13:45:20 +02:00
b"bit-xor" => Operator::BitXor,
b"bit-and" => Operator::BitAnd,
b"bit-shl" => Operator::ShiftLeft,
b"bit-shr" => Operator::ShiftRight,
2022-05-02 09:20:07 +02:00
b"starts-with" => Operator::StartsWith,
b"ends-with" => Operator::EndsWith,
2022-04-22 21:14:31 +02:00
b"&&" | b"and" => Operator::And,
b"||" | b"or" => Operator::Or,
2021-09-02 10:25:22 +02:00
b"**" => Operator::Pow,
_ => {
return (
garbage(span),
Some(ParseError::Expected("operator".into(), span)),
);
}
};
2021-07-02 08:44:37 +02:00
2021-09-02 10:25:22 +02:00
(
Expression {
expr: Expr::Operator(operator),
span,
ty: Type::Any,
custom_completion: None,
2021-09-02 10:25:22 +02:00
},
None,
)
}
2021-07-02 08:44:37 +02:00
2021-09-02 10:25:22 +02:00
pub fn parse_math_expression(
working_set: &mut StateWorkingSet,
spans: &[Span],
2021-09-09 23:47:20 +02:00
lhs_row_var_id: Option<VarId>,
expand_aliases_denylist: &[usize],
2021-09-02 10:25:22 +02:00
) -> (Expression, Option<ParseError>) {
// As the expr_stack grows, we increase the required precedence to grow larger
// If, at any time, the operator we're looking at is the same or lower precedence
// of what is in the expression stack, we collapse the expression stack.
//
// This leads to an expression stack that grows under increasing precedence and collapses
// under decreasing/sustained precedence
//
// The end result is a stack that we can fold into binary operations as right associations
// safely.
let mut expr_stack: Vec<Expression> = vec![];
let mut idx = 0;
let mut last_prec = 1000000;
let mut error = None;
2022-04-06 21:10:25 +02:00
let first_span = working_set.get_span_contents(spans[0]);
if first_span == b"not" {
if spans.len() > 1 {
let (remainder, err) = parse_math_expression(
working_set,
&spans[1..],
lhs_row_var_id,
expand_aliases_denylist,
);
return (
Expression {
expr: Expr::UnaryNot(Box::new(remainder)),
span: span(spans),
ty: Type::Bool,
custom_completion: None,
},
err,
);
} else {
return (
garbage(spans[0]),
Some(ParseError::Expected(
"expression".into(),
Span {
start: spans[0].end,
end: spans[0].end,
},
)),
);
}
}
let (mut lhs, err) = parse_value(
working_set,
spans[0],
&SyntaxShape::Any,
expand_aliases_denylist,
);
2021-09-02 10:25:22 +02:00
error = error.or(err);
idx += 1;
if idx >= spans.len() {
// We already found the one part of our expression, so let's expand
if let Some(row_var_id) = lhs_row_var_id {
expand_to_cell_path(working_set, &mut lhs, row_var_id, expand_aliases_denylist);
}
}
2021-09-02 10:25:22 +02:00
expr_stack.push(lhs);
while idx < spans.len() {
let (op, err) = parse_operator(working_set, spans[idx]);
2021-07-02 08:44:37 +02:00
error = error.or(err);
2021-09-02 10:25:22 +02:00
let op_prec = op.precedence();
2021-07-02 08:44:37 +02:00
2021-09-02 10:25:22 +02:00
idx += 1;
2021-07-02 08:44:37 +02:00
2021-09-02 10:25:22 +02:00
if idx == spans.len() {
// Handle broken math expr `1 +` etc
error = error.or(Some(ParseError::IncompleteMathExpression(spans[idx - 1])));
2021-07-02 08:44:37 +02:00
2021-09-02 10:25:22 +02:00
expr_stack.push(Expression::garbage(spans[idx - 1]));
expr_stack.push(Expression::garbage(spans[idx - 1]));
2021-07-22 21:50:59 +02:00
2021-09-02 10:25:22 +02:00
break;
}
2021-07-22 21:50:59 +02:00
let (rhs, err) = parse_value(
working_set,
spans[idx],
&SyntaxShape::Any,
expand_aliases_denylist,
);
2021-09-02 10:25:22 +02:00
error = error.or(err);
2021-07-02 08:44:37 +02:00
2022-03-25 04:23:08 +01:00
while op_prec <= last_prec && expr_stack.len() > 1 {
2021-11-06 08:31:28 +01:00
// Collapse the right associated operations first
// so that we can get back to a stack with a lower precedence
let mut rhs = expr_stack
.pop()
.expect("internal error: expression stack empty");
let mut op = expr_stack
.pop()
.expect("internal error: expression stack empty");
2022-03-25 04:23:08 +01:00
last_prec = op.precedence();
if last_prec < op_prec {
expr_stack.push(op);
expr_stack.push(rhs);
break;
}
2021-11-06 08:31:28 +01:00
let mut lhs = expr_stack
.pop()
.expect("internal error: expression stack empty");
if let Some(row_var_id) = lhs_row_var_id {
expand_to_cell_path(working_set, &mut lhs, row_var_id, expand_aliases_denylist);
2021-11-06 08:31:28 +01:00
}
2021-09-09 23:47:20 +02:00
2021-11-06 08:31:28 +01:00
let (result_ty, err) = math_result_type(working_set, &mut lhs, &mut op, &mut rhs);
error = error.or(err);
2021-07-02 08:44:37 +02:00
2021-11-06 08:31:28 +01:00
let op_span = span(&[lhs.span, rhs.span]);
expr_stack.push(Expression {
expr: Expr::BinaryOp(Box::new(lhs), Box::new(op), Box::new(rhs)),
span: op_span,
ty: result_ty,
custom_completion: None,
});
2021-07-02 08:44:37 +02:00
}
2021-09-02 10:25:22 +02:00
expr_stack.push(op);
expr_stack.push(rhs);
2021-07-02 08:44:37 +02:00
2021-09-02 10:25:22 +02:00
last_prec = op_prec;
2021-07-23 23:19:30 +02:00
2021-09-02 10:25:22 +02:00
idx += 1;
}
2021-07-02 08:44:37 +02:00
2021-09-02 10:25:22 +02:00
while expr_stack.len() != 1 {
let mut rhs = expr_stack
.pop()
.expect("internal error: expression stack empty");
let mut op = expr_stack
2021-07-02 08:44:37 +02:00
.pop()
.expect("internal error: expression stack empty");
2021-09-02 10:25:22 +02:00
let mut lhs = expr_stack
.pop()
.expect("internal error: expression stack empty");
2021-09-09 23:47:20 +02:00
if let Some(row_var_id) = lhs_row_var_id {
expand_to_cell_path(working_set, &mut lhs, row_var_id, expand_aliases_denylist);
2021-09-09 23:47:20 +02:00
}
2021-09-02 10:25:22 +02:00
let (result_ty, err) = math_result_type(working_set, &mut lhs, &mut op, &mut rhs);
error = error.or(err);
2021-07-02 08:44:37 +02:00
2021-09-02 10:25:22 +02:00
let binary_op_span = span(&[lhs.span, rhs.span]);
expr_stack.push(Expression {
expr: Expr::BinaryOp(Box::new(lhs), Box::new(op), Box::new(rhs)),
span: binary_op_span,
ty: result_ty,
custom_completion: None,
2021-09-02 10:25:22 +02:00
});
2021-07-01 02:01:04 +02:00
}
2021-09-02 10:25:22 +02:00
let output = expr_stack
.pop()
.expect("internal error: expression stack empty");
2021-07-02 00:40:08 +02:00
2021-09-02 10:25:22 +02:00
(output, error)
}
pub fn parse_expression(
working_set: &mut StateWorkingSet,
spans: &[Span],
expand_aliases_denylist: &[usize],
2021-09-02 10:25:22 +02:00
) -> (Expression, Option<ParseError>) {
2021-11-04 03:32:35 +01:00
let mut pos = 0;
let mut shorthand = vec![];
2021-09-02 10:25:22 +02:00
2021-11-04 03:32:35 +01:00
while pos < spans.len() {
// Check if there is any environment shorthand
let name = working_set.get_span_contents(spans[pos]);
let split = name.splitn(2, |x| *x == b'=');
2021-11-04 03:32:35 +01:00
let split: Vec<_> = split.collect();
if split.len() == 2 && !split[0].is_empty() {
let point = split[0].len() + 1;
let lhs = parse_string_strict(
working_set,
Span {
start: spans[pos].start,
end: spans[pos].start + point - 1,
},
);
let rhs = if spans[pos].start + point < spans[pos].end {
let rhs_span = Span {
start: spans[pos].start + point,
end: spans[pos].end,
};
if working_set.get_span_contents(rhs_span).starts_with(b"$") {
parse_dollar_expr(working_set, rhs_span, expand_aliases_denylist)
} else {
parse_string_strict(working_set, rhs_span)
}
2021-11-04 03:32:35 +01:00
} else {
(
Expression {
expr: Expr::String(String::new()),
span: Span { start: 0, end: 0 },
2021-11-04 03:32:35 +01:00
ty: Type::Nothing,
custom_completion: None,
},
None,
)
};
if lhs.1.is_none() && rhs.1.is_none() {
shorthand.push((lhs.0, rhs.0));
pos += 1;
} else {
break;
}
} else {
break;
}
}
if pos == spans.len() {
return (
garbage(span(spans)),
Some(ParseError::UnknownCommand(spans[0])),
);
}
let (output, err) = if is_math_expression_like(working_set, spans[pos], expand_aliases_denylist)
{
parse_math_expression(working_set, &spans[pos..], None, expand_aliases_denylist)
2021-11-04 03:32:35 +01:00
} else {
let bytes = working_set.get_span_contents(spans[pos]);
// For now, check for special parses of certain keywords
match bytes {
b"def" => (
parse_call(
working_set,
&spans[pos..],
spans[0],
expand_aliases_denylist,
)
.0,
Some(ParseError::BuiltinCommandInPipeline("def".into(), spans[0])),
),
b"extern" => (
parse_call(
working_set,
&spans[pos..],
spans[0],
expand_aliases_denylist,
)
.0,
Some(ParseError::BuiltinCommandInPipeline(
"extern".into(),
spans[0],
)),
),
b"let" => (
parse_call(
working_set,
&spans[pos..],
spans[0],
expand_aliases_denylist,
)
.0,
Some(ParseError::LetInPipeline(
String::from_utf8_lossy(match spans.len() {
1 | 2 | 3 => b"value",
_ => working_set.get_span_contents(spans[3]),
})
.to_string(),
String::from_utf8_lossy(match spans.len() {
1 => b"variable",
_ => working_set.get_span_contents(spans[1]),
})
.to_string(),
spans[0],
)),
),
b"alias" => (
parse_call(
working_set,
&spans[pos..],
spans[0],
expand_aliases_denylist,
)
.0,
Some(ParseError::BuiltinCommandInPipeline(
"alias".into(),
spans[0],
)),
),
b"module" => (
parse_call(
working_set,
&spans[pos..],
spans[0],
expand_aliases_denylist,
)
.0,
Some(ParseError::BuiltinCommandInPipeline(
"module".into(),
spans[0],
)),
),
b"use" => (
parse_call(
working_set,
&spans[pos..],
spans[0],
expand_aliases_denylist,
)
.0,
Some(ParseError::BuiltinCommandInPipeline("use".into(), spans[0])),
),
Overlays (#5375) * WIP: Start laying overlays * Rename Overlay->Module; Start adding overlay * Revamp adding overlay * Add overlay add tests; Disable debug print * Fix overlay add; Add overlay remove * Add overlay remove tests * Add missing overlay remove file * Add overlay list command * (WIP?) Enable overlays for env vars * Move OverlayFrames to ScopeFrames * (WIP) Move everything to overlays only ScopeFrame contains nothing but overlays now * Fix predecls * Fix wrong overlay id translation and aliases * Fix broken env lookup logic * Remove TODOs * Add overlay add + remove for environment * Add a few overlay tests; Fix overlay add name * Some cleanup; Fix overlay add/remove names * Clippy * Fmt * Remove walls of comments * List overlays from stack; Add debugging flag Currently, the engine state ordering is somehow broken. * Fix (?) overlay list test * Fix tests on Windows * Fix activated overlay ordering * Check for active overlays equality in overlay list This removes the -p flag: Either both parser and engine will have the same overlays, or the command will fail. * Add merging on overlay remove * Change help message and comment * Add some remove-merge/discard tests * (WIP) Track removed overlays properly * Clippy; Fmt * Fix getting last overlay; Fix predecls in overlays * Remove merging; Fix re-add overwriting stuff Also some error message tweaks. * Fix overlay error in the engine * Update variable_completions.rs * Adds flags and optional arguments to view-source (#5446) * added flags and optional arguments to view-source * removed redundant code * removed redundant code * fmt * fix bug in shell_integration (#5450) * fix bug in shell_integration * add some comments * enable cd to work with directory abbreviations (#5452) * enable cd to work with abbreviations * add abbreviation example * fix tests * make it configurable * make cd recornize symblic link (#5454) * implement seq char command to generate single character sequence (#5453) * add tmp code * add seq char command * Add split number flag in `split row` (#5434) Signed-off-by: Yuheng Su <gipsyh.icu@gmail.com> * Add two more overlay tests * Add ModuleId to OverlayFrame * Fix env conversion accidentally activating overlay It activated overlay from permanent state prematurely which would cause `overlay add` to misbehave. * Remove unused parameter; Add overlay list test * Remove added traces * Add overlay commands examples * Modify TODO * Fix $nu.scope iteration * Disallow removing default overlay * Refactor some parser errors * Remove last overlay if no argument * Diversify overlay examples * Make it possible to update overlay's module In case the origin module updates, the overlay add loads the new module, makes it overlay's origin and applies the changes. Before, it was impossible to update the overlay if the module changed. Co-authored-by: JT <547158+jntrnr@users.noreply.github.com> Co-authored-by: pwygab <88221256+merelymyself@users.noreply.github.com> Co-authored-by: Darren Schroeder <343840+fdncred@users.noreply.github.com> Co-authored-by: WindSoilder <WindSoilder@outlook.com> Co-authored-by: Yuheng Su <gipsyh.icu@gmail.com>
2022-05-07 21:39:22 +02:00
b"overlay" => {
if spans.len() > 1 && working_set.get_span_contents(spans[1]) == b"list" {
// whitelist 'overlay list'
parse_call(
working_set,
&spans[pos..],
spans[0],
expand_aliases_denylist,
)
} else {
(
parse_call(
working_set,
&spans[pos..],
spans[0],
expand_aliases_denylist,
)
.0,
Some(ParseError::BuiltinCommandInPipeline(
"overlay".into(),
spans[0],
)),
)
}
}
b"source" => (
parse_call(
working_set,
&spans[pos..],
spans[0],
expand_aliases_denylist,
)
.0,
Some(ParseError::BuiltinCommandInPipeline(
"source".into(),
spans[0],
)),
),
b"export" => (
parse_call(
working_set,
&spans[pos..],
spans[0],
expand_aliases_denylist,
)
.0,
Some(ParseError::UnexpectedKeyword("export".into(), spans[0])),
),
b"hide" => (
parse_call(
working_set,
&spans[pos..],
spans[0],
expand_aliases_denylist,
)
.0,
Some(ParseError::BuiltinCommandInPipeline(
"hide".into(),
spans[0],
)),
),
#[cfg(feature = "plugin")]
b"register" => (
parse_call(
working_set,
&spans[pos..],
spans[0],
expand_aliases_denylist,
)
.0,
Some(ParseError::BuiltinCommandInPipeline(
"plugin".into(),
spans[0],
)),
),
b"for" => parse_for(working_set, spans, expand_aliases_denylist),
_ => parse_call(
working_set,
&spans[pos..],
spans[0],
expand_aliases_denylist,
),
}
2021-11-04 03:32:35 +01:00
};
let with_env = working_set.find_decl(b"with-env", &Type::Any);
2021-11-04 03:32:35 +01:00
if !shorthand.is_empty() {
if let Some(decl_id) = with_env {
let mut block = Block::default();
let ty = output.ty.clone();
block.pipelines = vec![Pipeline {
2021-11-04 03:32:35 +01:00
expressions: vec![output],
}];
2021-11-04 03:32:35 +01:00
let block_id = working_set.add_block(block);
let mut env_vars = vec![];
for sh in shorthand {
env_vars.push(sh.0);
env_vars.push(sh.1);
}
let arguments = vec![
Argument::Positional(Expression {
2021-11-04 03:32:35 +01:00
expr: Expr::List(env_vars),
span: span(&spans[..pos]),
ty: Type::Any,
2021-11-04 03:32:35 +01:00
custom_completion: None,
}),
Argument::Positional(Expression {
2021-11-04 03:32:35 +01:00
expr: Expr::Block(block_id),
span: span(&spans[pos..]),
ty,
custom_completion: None,
}),
2021-11-04 03:32:35 +01:00
];
2022-02-21 18:58:04 +01:00
let expr = Expr::Call(Box::new(Call {
head: Span { start: 0, end: 0 },
decl_id,
arguments,
redirect_stdout: true,
redirect_stderr: false,
2022-02-21 18:58:04 +01:00
}));
2021-11-04 03:32:35 +01:00
(
Expression {
2022-02-21 18:58:04 +01:00
expr,
2021-11-04 03:32:35 +01:00
custom_completion: None,
span: span(spans),
ty: Type::Any,
2021-11-04 03:32:35 +01:00
},
err,
)
} else {
(output, err)
}
} else {
2021-11-04 03:32:35 +01:00
(output, err)
2021-07-01 02:01:04 +02:00
}
2021-09-02 10:25:22 +02:00
}
2021-07-01 02:01:04 +02:00
2021-09-02 10:25:22 +02:00
pub fn parse_variable(
working_set: &mut StateWorkingSet,
span: Span,
) -> (Option<VarId>, Option<ParseError>) {
let bytes = working_set.get_span_contents(span);
2021-07-01 02:01:04 +02:00
2021-09-02 10:25:22 +02:00
if is_variable(bytes) {
if let Some(var_id) = working_set.find_variable(bytes) {
let input = working_set.get_variable(var_id).ty.clone();
working_set.type_scope.add_type(input);
2021-09-02 10:25:22 +02:00
(Some(var_id), None)
2021-07-01 02:01:04 +02:00
} else {
2021-09-02 10:25:22 +02:00
(None, None)
2021-07-01 02:01:04 +02:00
}
2021-09-02 10:25:22 +02:00
} else {
(
None,
Some(ParseError::Expected("valid variable name".into(), span)),
)
2021-07-01 02:01:04 +02:00
}
2021-09-02 10:25:22 +02:00
}
2021-07-01 02:01:04 +02:00
pub fn parse_builtin_commands(
working_set: &mut StateWorkingSet,
lite_command: &LiteCommand,
expand_aliases_denylist: &[usize],
) -> (Pipeline, Option<ParseError>) {
let name = working_set.get_span_contents(lite_command.parts[0]);
2021-09-13 21:59:11 +02:00
match name {
b"def" | b"def-env" => parse_def(working_set, lite_command, expand_aliases_denylist),
b"extern" => parse_extern(working_set, lite_command, expand_aliases_denylist),
b"let" => parse_let(working_set, &lite_command.parts, expand_aliases_denylist),
b"for" => {
let (expr, err) = parse_for(working_set, &lite_command.parts, expand_aliases_denylist);
(Pipeline::from_vec(vec![expr]), err)
}
b"alias" => parse_alias(working_set, &lite_command.parts, expand_aliases_denylist),
b"module" => parse_module(working_set, &lite_command.parts, expand_aliases_denylist),
b"use" => parse_use(working_set, &lite_command.parts, expand_aliases_denylist),
Overlays (#5375) * WIP: Start laying overlays * Rename Overlay->Module; Start adding overlay * Revamp adding overlay * Add overlay add tests; Disable debug print * Fix overlay add; Add overlay remove * Add overlay remove tests * Add missing overlay remove file * Add overlay list command * (WIP?) Enable overlays for env vars * Move OverlayFrames to ScopeFrames * (WIP) Move everything to overlays only ScopeFrame contains nothing but overlays now * Fix predecls * Fix wrong overlay id translation and aliases * Fix broken env lookup logic * Remove TODOs * Add overlay add + remove for environment * Add a few overlay tests; Fix overlay add name * Some cleanup; Fix overlay add/remove names * Clippy * Fmt * Remove walls of comments * List overlays from stack; Add debugging flag Currently, the engine state ordering is somehow broken. * Fix (?) overlay list test * Fix tests on Windows * Fix activated overlay ordering * Check for active overlays equality in overlay list This removes the -p flag: Either both parser and engine will have the same overlays, or the command will fail. * Add merging on overlay remove * Change help message and comment * Add some remove-merge/discard tests * (WIP) Track removed overlays properly * Clippy; Fmt * Fix getting last overlay; Fix predecls in overlays * Remove merging; Fix re-add overwriting stuff Also some error message tweaks. * Fix overlay error in the engine * Update variable_completions.rs * Adds flags and optional arguments to view-source (#5446) * added flags and optional arguments to view-source * removed redundant code * removed redundant code * fmt * fix bug in shell_integration (#5450) * fix bug in shell_integration * add some comments * enable cd to work with directory abbreviations (#5452) * enable cd to work with abbreviations * add abbreviation example * fix tests * make it configurable * make cd recornize symblic link (#5454) * implement seq char command to generate single character sequence (#5453) * add tmp code * add seq char command * Add split number flag in `split row` (#5434) Signed-off-by: Yuheng Su <gipsyh.icu@gmail.com> * Add two more overlay tests * Add ModuleId to OverlayFrame * Fix env conversion accidentally activating overlay It activated overlay from permanent state prematurely which would cause `overlay add` to misbehave. * Remove unused parameter; Add overlay list test * Remove added traces * Add overlay commands examples * Modify TODO * Fix $nu.scope iteration * Disallow removing default overlay * Refactor some parser errors * Remove last overlay if no argument * Diversify overlay examples * Make it possible to update overlay's module In case the origin module updates, the overlay add loads the new module, makes it overlay's origin and applies the changes. Before, it was impossible to update the overlay if the module changed. Co-authored-by: JT <547158+jntrnr@users.noreply.github.com> Co-authored-by: pwygab <88221256+merelymyself@users.noreply.github.com> Co-authored-by: Darren Schroeder <343840+fdncred@users.noreply.github.com> Co-authored-by: WindSoilder <WindSoilder@outlook.com> Co-authored-by: Yuheng Su <gipsyh.icu@gmail.com>
2022-05-07 21:39:22 +02:00
b"overlay" => parse_overlay(working_set, &lite_command.parts, expand_aliases_denylist),
b"source" => parse_source(working_set, &lite_command.parts, expand_aliases_denylist),
b"export" => {
if let Some(decl_id) = working_set.find_decl(b"alias", &Type::Any) {
let parsed_call = parse_internal_call(
working_set,
lite_command.parts[0],
&lite_command.parts[1..],
decl_id,
expand_aliases_denylist,
);
if parsed_call.call.has_flag("help") {
(
Pipeline::from_vec(vec![Expression {
expr: Expr::Call(parsed_call.call),
span: span(&lite_command.parts),
ty: parsed_call.output,
custom_completion: None,
}]),
None,
)
} else {
(
garbage_pipeline(&lite_command.parts),
Some(ParseError::UnexpectedKeyword(
"export".into(),
lite_command.parts[0],
)),
)
}
} else {
(
garbage_pipeline(&lite_command.parts),
Some(ParseError::UnexpectedKeyword(
"export".into(),
lite_command.parts[0],
)),
)
}
}
b"hide" => parse_hide(working_set, &lite_command.parts, expand_aliases_denylist),
2021-11-02 21:56:00 +01:00
#[cfg(feature = "plugin")]
b"register" => parse_register(working_set, &lite_command.parts, expand_aliases_denylist),
2021-09-13 21:59:11 +02:00
_ => {
let (expr, err) =
parse_expression(working_set, &lite_command.parts, expand_aliases_denylist);
(Pipeline::from_vec(vec![expr]), err)
}
}
2021-09-02 10:25:22 +02:00
}
2021-06-30 03:42:56 +02:00
2021-11-11 00:14:00 +01:00
pub fn parse_record(
working_set: &mut StateWorkingSet,
span: Span,
expand_aliases_denylist: &[usize],
2021-11-11 00:14:00 +01:00
) -> (Expression, Option<ParseError>) {
let bytes = working_set.get_span_contents(span);
let mut error = None;
let mut start = span.start;
let mut end = span.end;
if bytes.starts_with(b"{") {
start += 1;
} else {
error = error.or_else(|| {
Some(ParseError::Expected(
"{".into(),
Span {
start,
end: start + 1,
},
))
});
}
if bytes.ends_with(b"}") {
end -= 1;
} else {
error = error.or_else(|| Some(ParseError::Unclosed("}".into(), Span { start: end, end })));
}
2022-01-03 06:21:26 +01:00
let inner_span = Span { start, end };
let source = working_set.get_span_contents(inner_span);
2021-11-11 00:14:00 +01:00
2021-11-21 19:13:09 +01:00
let (tokens, err) = lex(source, start, &[b'\n', b'\r', b','], &[b':'], true);
2021-11-11 00:14:00 +01:00
error = error.or(err);
let mut output = vec![];
let mut idx = 0;
while idx < tokens.len() {
let (field, err) = parse_value(
working_set,
tokens[idx].span,
&SyntaxShape::Any,
expand_aliases_denylist,
);
2021-11-11 00:14:00 +01:00
error = error.or(err);
idx += 1;
if idx == tokens.len() {
return (
garbage(span),
Some(ParseError::Expected("record".into(), span)),
);
}
let colon = working_set.get_span_contents(tokens[idx].span);
idx += 1;
if idx == tokens.len() || colon != b":" {
//FIXME: need better error
return (
garbage(span),
Some(ParseError::Expected("record".into(), span)),
);
}
let (value, err) = parse_value(
working_set,
tokens[idx].span,
&SyntaxShape::Any,
expand_aliases_denylist,
);
2021-11-11 00:14:00 +01:00
error = error.or(err);
idx += 1;
output.push((field, value));
}
(
Expression {
expr: Expr::Record(output),
span,
ty: Type::Any, //FIXME: but we don't know the contents of the fields, do we?
2021-11-11 00:14:00 +01:00
custom_completion: None,
},
error,
)
}
2021-09-02 10:25:22 +02:00
pub fn parse_block(
working_set: &mut StateWorkingSet,
lite_block: &LiteBlock,
scoped: bool,
expand_aliases_denylist: &[usize],
is_subexpression: bool,
2021-09-02 10:25:22 +02:00
) -> (Block, Option<ParseError>) {
2022-01-01 22:42:50 +01:00
trace!("parsing block: {:?}", lite_block);
2021-09-02 10:25:22 +02:00
if scoped {
working_set.enter_scope();
}
working_set.type_scope.enter_scope();
2021-06-30 03:42:56 +02:00
let mut error = None;
2021-09-02 10:25:22 +02:00
// Pre-declare any definition so that definitions
// that share the same block can see each other
for pipeline in &lite_block.block {
if pipeline.commands.len() == 1 {
if let Some(err) = parse_def_predecl(
working_set,
&pipeline.commands[0].parts,
expand_aliases_denylist,
) {
error = error.or(Some(err));
}
2021-09-02 10:25:22 +02:00
}
}
2021-07-01 02:01:04 +02:00
2021-09-10 09:28:43 +02:00
let block: Block = lite_block
.block
.iter()
.enumerate()
.map(|(idx, pipeline)| {
2021-09-10 09:28:43 +02:00
if pipeline.commands.len() > 1 {
let mut output = pipeline
2021-09-10 09:28:43 +02:00
.commands
.iter()
.map(|command| {
let (expr, err) =
parse_expression(working_set, &command.parts, expand_aliases_denylist);
2021-09-10 09:44:31 +02:00
working_set.type_scope.add_type(expr.ty.clone());
2021-09-10 09:44:31 +02:00
if error.is_none() {
error = err;
}
2021-06-30 03:42:56 +02:00
2021-09-10 09:28:43 +02:00
expr
})
.collect::<Vec<Expression>>();
if is_subexpression {
for expr in output.iter_mut().skip(1) {
if expr.has_in_variable(working_set) {
*expr = wrap_expr_with_collect(working_set, expr);
}
}
} else {
for expr in output.iter_mut() {
if expr.has_in_variable(working_set) {
*expr = wrap_expr_with_collect(working_set, expr);
}
}
}
2021-11-08 08:13:55 +01:00
Pipeline {
2021-09-10 09:28:43 +02:00
expressions: output,
}
2021-09-10 09:28:43 +02:00
} else {
let (mut pipeline, err) = parse_builtin_commands(
working_set,
&pipeline.commands[0],
expand_aliases_denylist,
);
if idx == 0 {
if let Some(let_decl_id) = working_set.find_decl(b"let", &Type::Any) {
if let Some(let_env_decl_id) = working_set.find_decl(b"let-env", &Type::Any)
{
for expr in pipeline.expressions.iter_mut() {
if let Expression {
expr: Expr::Call(call),
..
} = expr
{
if call.decl_id == let_decl_id
|| call.decl_id == let_env_decl_id
{
// Do an expansion
if let Some(Expression {
expr: Expr::Keyword(_, _, expr),
..
}) = call.positional_iter_mut().nth(1)
{
if expr.has_in_variable(working_set) {
*expr = Box::new(wrap_expr_with_collect(
working_set,
expr,
));
}
}
continue;
} else if expr.has_in_variable(working_set) && !is_subexpression
{
*expr = wrap_expr_with_collect(working_set, expr);
}
} else if expr.has_in_variable(working_set) && !is_subexpression {
*expr = wrap_expr_with_collect(working_set, expr);
}
}
}
}
}
2021-09-10 09:44:31 +02:00
if error.is_none() {
error = err;
}
2021-06-30 03:42:56 +02:00
pipeline
2021-09-10 09:28:43 +02:00
}
})
.into();
2021-06-30 03:42:56 +02:00
2021-09-02 10:25:22 +02:00
if scoped {
working_set.exit_scope();
2021-06-30 03:42:56 +02:00
}
working_set.type_scope.exit_scope();
2021-06-30 03:42:56 +02:00
2021-09-02 10:25:22 +02:00
(block, error)
}
2021-06-30 03:42:56 +02:00
pub fn discover_captures_in_block(
2021-10-25 22:04:23 +02:00
working_set: &StateWorkingSet,
block: &Block,
seen: &mut Vec<VarId>,
seen_blocks: &mut HashMap<BlockId, Vec<VarId>>,
2021-10-25 22:04:23 +02:00
) -> Vec<VarId> {
let mut output = vec![];
for flag in &block.signature.named {
if let Some(var_id) = flag.var_id {
seen.push(var_id);
}
}
for positional in &block.signature.required_positional {
if let Some(var_id) = positional.var_id {
seen.push(var_id);
}
}
for positional in &block.signature.optional_positional {
if let Some(var_id) = positional.var_id {
seen.push(var_id);
}
}
for positional in &block.signature.rest_positional {
if let Some(var_id) = positional.var_id {
seen.push(var_id);
}
}
for pipeline in &block.pipelines {
let result = discover_captures_in_pipeline(working_set, pipeline, seen, seen_blocks);
output.extend(&result);
2021-10-25 22:04:23 +02:00
}
output
}
fn discover_captures_in_pipeline(
2021-10-25 22:04:23 +02:00
working_set: &StateWorkingSet,
pipeline: &Pipeline,
seen: &mut Vec<VarId>,
seen_blocks: &mut HashMap<BlockId, Vec<VarId>>,
2021-10-25 22:04:23 +02:00
) -> Vec<VarId> {
let mut output = vec![];
for expr in &pipeline.expressions {
let result = discover_captures_in_expr(working_set, expr, seen, seen_blocks);
2021-10-25 22:04:23 +02:00
output.extend(&result);
}
output
}
pub fn discover_captures_in_expr(
2021-10-25 22:04:23 +02:00
working_set: &StateWorkingSet,
expr: &Expression,
seen: &mut Vec<VarId>,
seen_blocks: &mut HashMap<BlockId, Vec<VarId>>,
2021-10-25 22:04:23 +02:00
) -> Vec<VarId> {
let mut output = vec![];
match &expr.expr {
Expr::BinaryOp(lhs, _, rhs) => {
let lhs_result = discover_captures_in_expr(working_set, lhs, seen, seen_blocks);
let rhs_result = discover_captures_in_expr(working_set, rhs, seen, seen_blocks);
2021-10-25 22:04:23 +02:00
output.extend(&lhs_result);
output.extend(&rhs_result);
}
2022-04-06 21:10:25 +02:00
Expr::UnaryNot(expr) => {
let result = discover_captures_in_expr(working_set, expr, seen, seen_blocks);
output.extend(&result);
}
2021-10-25 22:04:23 +02:00
Expr::Block(block_id) => {
let block = working_set.get_block(*block_id);
let results = {
let mut seen = vec![];
discover_captures_in_block(working_set, block, &mut seen, seen_blocks)
};
seen_blocks.insert(*block_id, results.clone());
for var_id in results.into_iter() {
if !seen.contains(&var_id) {
output.push(var_id)
}
}
2021-10-25 22:04:23 +02:00
}
2022-03-01 00:31:53 +01:00
Expr::Binary(_) => {}
2021-10-25 22:04:23 +02:00
Expr::Bool(_) => {}
Expr::Call(call) => {
let decl = working_set.get_decl(call.decl_id);
if let Some(block_id) = decl.get_block_id() {
match seen_blocks.get(&block_id) {
Some(capture_list) => {
output.extend(capture_list);
}
None => {
let block = working_set.get_block(block_id);
if !block.captures.is_empty() {
output.extend(&block.captures);
} else {
let mut seen = vec![];
seen_blocks.insert(block_id, output.clone());
let result = discover_captures_in_block(
working_set,
block,
&mut seen,
seen_blocks,
);
output.extend(&result);
seen_blocks.insert(block_id, result);
}
}
}
}
for named in call.named_iter() {
if let Some(arg) = &named.2 {
let result = discover_captures_in_expr(working_set, arg, seen, seen_blocks);
2021-10-25 22:04:23 +02:00
output.extend(&result);
}
}
for positional in call.positional_iter() {
let result = discover_captures_in_expr(working_set, positional, seen, seen_blocks);
2021-10-25 22:04:23 +02:00
output.extend(&result);
}
}
Expr::CellPath(_) => {}
Expr::DateTime(_) => {}
Expr::ExternalCall(head, exprs) => {
let result = discover_captures_in_expr(working_set, head, seen, seen_blocks);
output.extend(&result);
2021-10-25 22:04:23 +02:00
for expr in exprs {
let result = discover_captures_in_expr(working_set, expr, seen, seen_blocks);
2021-10-25 22:04:23 +02:00
output.extend(&result);
}
}
Expr::Filepath(_) => {}
Expr::Directory(_) => {}
2021-10-25 22:04:23 +02:00
Expr::Float(_) => {}
Expr::FullCellPath(cell_path) => {
let result = discover_captures_in_expr(working_set, &cell_path.head, seen, seen_blocks);
2021-10-25 22:04:23 +02:00
output.extend(&result);
}
Expr::ImportPattern(_) => {}
2021-10-25 22:04:23 +02:00
Expr::Garbage => {}
Expr::Nothing => {}
2021-10-25 22:04:23 +02:00
Expr::GlobPattern(_) => {}
Expr::Int(_) => {}
Expr::Keyword(_, _, expr) => {
let result = discover_captures_in_expr(working_set, expr, seen, seen_blocks);
2021-10-25 22:04:23 +02:00
output.extend(&result);
}
Expr::List(exprs) => {
for expr in exprs {
let result = discover_captures_in_expr(working_set, expr, seen, seen_blocks);
2021-10-25 22:04:23 +02:00
output.extend(&result);
}
}
Expr::Operator(_) => {}
Expr::Range(expr1, expr2, expr3, _) => {
if let Some(expr) = expr1 {
let result = discover_captures_in_expr(working_set, expr, seen, seen_blocks);
2021-10-25 22:04:23 +02:00
output.extend(&result);
}
if let Some(expr) = expr2 {
let result = discover_captures_in_expr(working_set, expr, seen, seen_blocks);
2021-10-25 22:04:23 +02:00
output.extend(&result);
}
if let Some(expr) = expr3 {
let result = discover_captures_in_expr(working_set, expr, seen, seen_blocks);
2021-10-25 22:04:23 +02:00
output.extend(&result);
}
}
2021-11-11 00:14:00 +01:00
Expr::Record(fields) => {
for (field_name, field_value) in fields {
output.extend(&discover_captures_in_expr(
working_set,
field_name,
seen,
seen_blocks,
));
output.extend(&discover_captures_in_expr(
working_set,
field_value,
seen,
seen_blocks,
));
2021-11-11 00:14:00 +01:00
}
}
Expr::Signature(sig) => {
// Something with a declaration, similar to a var decl, will introduce more VarIds into the stack at eval
for pos in &sig.required_positional {
if let Some(var_id) = pos.var_id {
seen.push(var_id);
}
}
for pos in &sig.optional_positional {
if let Some(var_id) = pos.var_id {
seen.push(var_id);
}
}
if let Some(rest) = &sig.rest_positional {
if let Some(var_id) = rest.var_id {
seen.push(var_id);
}
}
for named in &sig.named {
if let Some(var_id) = named.var_id {
seen.push(var_id);
}
}
}
2021-10-25 22:04:23 +02:00
Expr::String(_) => {}
Expr::StringInterpolation(exprs) => {
for expr in exprs {
let result = discover_captures_in_expr(working_set, expr, seen, seen_blocks);
output.extend(&result);
}
}
2021-11-26 04:49:03 +01:00
Expr::RowCondition(block_id) | Expr::Subexpression(block_id) => {
let block = working_set.get_block(*block_id);
let results = {
let mut seen = vec![];
discover_captures_in_block(working_set, block, &mut seen, seen_blocks)
};
seen_blocks.insert(*block_id, results.clone());
for var_id in results.into_iter() {
if !seen.contains(&var_id) {
output.push(var_id)
}
}
2021-10-25 22:04:23 +02:00
}
Expr::Table(headers, values) => {
for header in headers {
let result = discover_captures_in_expr(working_set, header, seen, seen_blocks);
2021-10-25 22:04:23 +02:00
output.extend(&result);
}
for row in values {
for cell in row {
let result = discover_captures_in_expr(working_set, cell, seen, seen_blocks);
2021-10-25 22:04:23 +02:00
output.extend(&result);
}
}
}
Expr::ValueWithUnit(expr, _) => {
let result = discover_captures_in_expr(working_set, expr, seen, seen_blocks);
2021-10-25 22:04:23 +02:00
output.extend(&result);
}
Expr::Var(var_id) => {
if (*var_id > ENV_VARIABLE_ID || *var_id == IN_VARIABLE_ID) && !seen.contains(var_id) {
2021-10-25 22:04:23 +02:00
output.push(*var_id);
}
}
Expr::VarDecl(var_id) => {
seen.push(*var_id);
}
}
output
}
fn wrap_expr_with_collect(working_set: &mut StateWorkingSet, expr: &Expression) -> Expression {
let span = expr.span;
if let Some(decl_id) = working_set.find_decl(b"collect", &Type::Any) {
let mut output = vec![];
let var_id = working_set.next_var_id();
let mut signature = Signature::new("");
signature.required_positional.push(PositionalArg {
var_id: Some(var_id),
2021-12-30 04:26:40 +01:00
name: "$in".into(),
desc: String::new(),
shape: SyntaxShape::Any,
2022-03-07 21:08:56 +01:00
default_value: None,
});
let mut expr = expr.clone();
expr.replace_in_variable(working_set, var_id);
let block = Block {
pipelines: vec![Pipeline {
expressions: vec![expr],
}],
signature: Box::new(signature),
..Default::default()
};
let block_id = working_set.add_block(block);
output.push(Argument::Positional(Expression {
expr: Expr::Block(block_id),
span,
ty: Type::Any,
custom_completion: None,
}));
2021-12-30 04:26:40 +01:00
// The containing, synthetic call to `collect`.
// We don't want to have a real span as it will confuse flattening
// The args are where we'll get the real info
Expression {
expr: Expr::Call(Box::new(Call {
2021-12-30 04:26:40 +01:00
head: Span::new(0, 0),
arguments: output,
decl_id,
redirect_stdout: true,
redirect_stderr: false,
})),
span,
ty: Type::String,
custom_completion: None,
}
} else {
Expression::garbage(span)
}
}
2021-09-06 22:41:30 +02:00
// Parses a vector of u8 to create an AST Block. If a file name is given, then
// the name is stored in the working set. When parsing a source without a file
// name, the source of bytes is stored as "source"
pub fn parse(
2021-09-02 10:25:22 +02:00
working_set: &mut StateWorkingSet,
2021-09-06 22:41:30 +02:00
fname: Option<&str>,
2021-09-02 10:25:22 +02:00
contents: &[u8],
scoped: bool,
expand_aliases_denylist: &[usize],
2021-09-02 10:25:22 +02:00
) -> (Block, Option<ParseError>) {
2022-01-01 22:42:50 +01:00
trace!("starting top-level parse");
2021-09-02 10:25:22 +02:00
let mut error = None;
2021-07-03 03:29:56 +02:00
2021-09-02 10:25:22 +02:00
let span_offset = working_set.next_span_start();
2021-09-06 22:41:30 +02:00
let name = match fname {
Some(fname) => fname.to_string(),
None => "source".to_string(),
};
2021-07-01 02:01:04 +02:00
2021-09-06 22:41:30 +02:00
working_set.add_file(name, contents);
2021-07-01 02:01:04 +02:00
let (output, err) = lex(contents, span_offset, &[], &[], false);
2021-09-02 10:25:22 +02:00
error = error.or(err);
2021-07-01 02:01:04 +02:00
2021-09-02 10:25:22 +02:00
let (output, err) = lite_parse(&output);
error = error.or(err);
2021-07-01 02:01:04 +02:00
let (mut output, err) =
parse_block(working_set, &output, scoped, expand_aliases_denylist, false);
2021-09-02 10:25:22 +02:00
error = error.or(err);
let mut seen = vec![];
let mut seen_blocks = HashMap::new();
let captures = discover_captures_in_block(working_set, &output, &mut seen, &mut seen_blocks);
output.captures = captures;
// Also check other blocks that might have been imported
for (block_idx, block) in working_set.delta.blocks.iter().enumerate() {
let block_id = block_idx + working_set.permanent_state.num_blocks();
if !seen_blocks.contains_key(&block_id) {
let captures =
discover_captures_in_block(working_set, block, &mut seen, &mut seen_blocks);
seen_blocks.insert(block_id, captures);
}
}
for (block_id, captures) in seen_blocks.into_iter() {
// In theory, we should only be updating captures where we have new information
// the only place where this is possible would be blocks that are newly created
// by our working set delta. If we ever tried to modify the permanent state, we'd
// panic (again, in theory, this shouldn't be possible)
let block = working_set.get_block(block_id);
let block_captures_empty = block.captures.is_empty();
if !captures.is_empty() && block_captures_empty {
let block = working_set.get_block_mut(block_id);
block.captures = captures;
}
}
2021-09-02 10:25:22 +02:00
(output, error)
2021-06-30 03:42:56 +02:00
}