mirror of
https://github.com/nushell/nushell.git
synced 2025-06-30 14:40:06 +02:00
Refactor to support multiple parse errors (#8765)
# Description This is a pretty heavy refactor of the parser to support multiple parser errors. It has a few issues we should address before landing: - [x] In some cases, error quality has gotten worse `1 / "bob"` for example - [x] if/else isn't currently parsing correctly - probably others # User-Facing Changes This may have error quality degradation as we adjust to the new error reporting mechanism. # Tests + Formatting Don't forget to add tests that cover your changes. Make sure you've run and fixed any issues with these commands: - `cargo fmt --all -- --check` to check standard code formatting (`cargo fmt --all` applies these changes) - `cargo clippy --workspace -- -D warnings -D clippy::unwrap_used -A clippy::needless_collect` to check that you're using the standard code style - `cargo test --workspace` to check that all tests pass - `cargo run -- crates/nu-utils/standard_library/tests.nu` to run the tests for the standard library > **Note** > from `nushell` you can also use the `toolkit` as follows > ```bash > use toolkit.nu # or use an `env_change` hook to activate it automatically > toolkit check pr > ``` # After Submitting If your PR had any user-facing changes, update [the documentation](https://github.com/nushell/nushell.github.io) after the PR is merged, if necessary. This will help us keep the docs up to date.
This commit is contained in:
@ -1,5 +1,5 @@
|
||||
use nu_parser::{lex, lex_signature, ParseError, Token, TokenContents};
|
||||
use nu_protocol::Span;
|
||||
use nu_parser::{lex, lex_signature, Token, TokenContents};
|
||||
use nu_protocol::{ParseError, Span};
|
||||
|
||||
#[test]
|
||||
fn lex_basic() {
|
||||
|
@ -1,11 +1,10 @@
|
||||
use nu_parser::ParseError;
|
||||
use nu_parser::*;
|
||||
use nu_protocol::ast::{Call, PathMember};
|
||||
use nu_protocol::Span;
|
||||
use nu_protocol::{
|
||||
ast::{Expr, Expression, PipelineElement},
|
||||
engine::{Command, EngineState, Stack, StateWorkingSet},
|
||||
PipelineData, ShellError, Signature, SyntaxShape,
|
||||
ParseError, PipelineData, ShellError, Signature, SyntaxShape,
|
||||
};
|
||||
|
||||
#[cfg(test)]
|
||||
@ -53,7 +52,9 @@ fn test_int(
|
||||
let engine_state = EngineState::new();
|
||||
let mut working_set = StateWorkingSet::new(&engine_state);
|
||||
|
||||
let (block, err) = parse(&mut working_set, None, test, true, &[]);
|
||||
let block = parse(&mut working_set, None, test, true, &[]);
|
||||
|
||||
let err = working_set.parse_errors.first();
|
||||
|
||||
if let Some(err_pat) = expected_err {
|
||||
if let Some(parse_err) = err {
|
||||
@ -265,9 +266,9 @@ fn test_parse_any() {
|
||||
let engine_state = EngineState::new();
|
||||
let mut working_set = StateWorkingSet::new(&engine_state);
|
||||
|
||||
let (block, err) = parse(&mut working_set, None, test, true, &[]);
|
||||
let block = parse(&mut working_set, None, test, true, &[]);
|
||||
|
||||
match (block, err) {
|
||||
match (block, working_set.parse_errors.first()) {
|
||||
(_, Some(e)) => {
|
||||
println!("test: {test:?}, error: {e:#?}");
|
||||
}
|
||||
@ -281,9 +282,9 @@ pub fn parse_int() {
|
||||
let engine_state = EngineState::new();
|
||||
let mut working_set = StateWorkingSet::new(&engine_state);
|
||||
|
||||
let (block, err) = parse(&mut working_set, None, b"3", true, &[]);
|
||||
let block = parse(&mut working_set, None, b"3", true, &[]);
|
||||
|
||||
assert!(err.is_none());
|
||||
assert!(working_set.parse_errors.is_empty());
|
||||
assert_eq!(block.len(), 1);
|
||||
let expressions = &block[0];
|
||||
assert_eq!(expressions.len(), 1);
|
||||
@ -304,9 +305,9 @@ pub fn parse_int_with_underscores() {
|
||||
let engine_state = EngineState::new();
|
||||
let mut working_set = StateWorkingSet::new(&engine_state);
|
||||
|
||||
let (block, err) = parse(&mut working_set, None, b"420_69_2023", true, &[]);
|
||||
let block = parse(&mut working_set, None, b"420_69_2023", true, &[]);
|
||||
|
||||
assert!(err.is_none());
|
||||
assert!(working_set.parse_errors.is_empty());
|
||||
assert_eq!(block.len(), 1);
|
||||
let expressions = &block[0];
|
||||
assert_eq!(expressions.len(), 1);
|
||||
@ -334,9 +335,9 @@ pub fn parse_cell_path() {
|
||||
false,
|
||||
);
|
||||
|
||||
let (block, err) = parse(&mut working_set, None, b"$foo.bar.baz", true, &[]);
|
||||
let block = parse(&mut working_set, None, b"$foo.bar.baz", true, &[]);
|
||||
|
||||
assert!(err.is_none());
|
||||
assert!(working_set.parse_errors.is_empty());
|
||||
assert_eq!(block.len(), 1);
|
||||
let expressions = &block[0];
|
||||
assert_eq!(expressions.len(), 1);
|
||||
@ -388,12 +389,9 @@ pub fn parse_cell_path_optional() {
|
||||
false,
|
||||
);
|
||||
|
||||
let (block, err) = parse(&mut working_set, None, b"$foo.bar?.baz", true, &[]);
|
||||
let block = parse(&mut working_set, None, b"$foo.bar?.baz", true, &[]);
|
||||
|
||||
if let Some(err) = err {
|
||||
dbg!(err);
|
||||
panic!();
|
||||
}
|
||||
assert!(working_set.parse_errors.is_empty());
|
||||
|
||||
assert_eq!(block.len(), 1);
|
||||
let expressions = &block[0];
|
||||
@ -439,9 +437,9 @@ pub fn parse_binary_with_hex_format() {
|
||||
let engine_state = EngineState::new();
|
||||
let mut working_set = StateWorkingSet::new(&engine_state);
|
||||
|
||||
let (block, err) = parse(&mut working_set, None, b"0x[13]", true, &[]);
|
||||
let block = parse(&mut working_set, None, b"0x[13]", true, &[]);
|
||||
|
||||
assert!(err.is_none());
|
||||
assert!(working_set.parse_errors.is_empty());
|
||||
assert_eq!(block.len(), 1);
|
||||
let expressions = &block[0];
|
||||
assert_eq!(expressions.len(), 1);
|
||||
@ -457,9 +455,9 @@ pub fn parse_binary_with_incomplete_hex_format() {
|
||||
let engine_state = EngineState::new();
|
||||
let mut working_set = StateWorkingSet::new(&engine_state);
|
||||
|
||||
let (block, err) = parse(&mut working_set, None, b"0x[3]", true, &[]);
|
||||
let block = parse(&mut working_set, None, b"0x[3]", true, &[]);
|
||||
|
||||
assert!(err.is_none());
|
||||
assert!(working_set.parse_errors.is_empty());
|
||||
assert_eq!(block.len(), 1);
|
||||
let expressions = &block[0];
|
||||
assert_eq!(expressions.len(), 1);
|
||||
@ -475,9 +473,9 @@ pub fn parse_binary_with_binary_format() {
|
||||
let engine_state = EngineState::new();
|
||||
let mut working_set = StateWorkingSet::new(&engine_state);
|
||||
|
||||
let (block, err) = parse(&mut working_set, None, b"0b[1010 1000]", true, &[]);
|
||||
let block = parse(&mut working_set, None, b"0b[1010 1000]", true, &[]);
|
||||
|
||||
assert!(err.is_none());
|
||||
assert!(working_set.parse_errors.is_empty());
|
||||
assert_eq!(block.len(), 1);
|
||||
let expressions = &block[0];
|
||||
assert_eq!(expressions.len(), 1);
|
||||
@ -493,9 +491,9 @@ pub fn parse_binary_with_incomplete_binary_format() {
|
||||
let engine_state = EngineState::new();
|
||||
let mut working_set = StateWorkingSet::new(&engine_state);
|
||||
|
||||
let (block, err) = parse(&mut working_set, None, b"0b[10]", true, &[]);
|
||||
let block = parse(&mut working_set, None, b"0b[10]", true, &[]);
|
||||
|
||||
assert!(err.is_none());
|
||||
assert!(working_set.parse_errors.is_empty());
|
||||
assert_eq!(block.len(), 1);
|
||||
let expressions = &block[0];
|
||||
assert_eq!(expressions.len(), 1);
|
||||
@ -511,9 +509,9 @@ pub fn parse_binary_with_octal_format() {
|
||||
let engine_state = EngineState::new();
|
||||
let mut working_set = StateWorkingSet::new(&engine_state);
|
||||
|
||||
let (block, err) = parse(&mut working_set, None, b"0o[250]", true, &[]);
|
||||
let block = parse(&mut working_set, None, b"0o[250]", true, &[]);
|
||||
|
||||
assert!(err.is_none());
|
||||
assert!(working_set.parse_errors.is_empty());
|
||||
assert_eq!(block.len(), 1);
|
||||
let expressions = &block[0];
|
||||
assert_eq!(expressions.len(), 1);
|
||||
@ -529,9 +527,9 @@ pub fn parse_binary_with_incomplete_octal_format() {
|
||||
let engine_state = EngineState::new();
|
||||
let mut working_set = StateWorkingSet::new(&engine_state);
|
||||
|
||||
let (block, err) = parse(&mut working_set, None, b"0o[2]", true, &[]);
|
||||
let block = parse(&mut working_set, None, b"0o[2]", true, &[]);
|
||||
|
||||
assert!(err.is_none());
|
||||
assert!(working_set.parse_errors.is_empty());
|
||||
assert_eq!(block.len(), 1);
|
||||
let expressions = &block[0];
|
||||
assert_eq!(expressions.len(), 1);
|
||||
@ -547,9 +545,9 @@ pub fn parse_binary_with_invalid_octal_format() {
|
||||
let engine_state = EngineState::new();
|
||||
let mut working_set = StateWorkingSet::new(&engine_state);
|
||||
|
||||
let (block, err) = parse(&mut working_set, None, b"0b[90]", true, &[]);
|
||||
let block = parse(&mut working_set, None, b"0b[90]", true, &[]);
|
||||
|
||||
assert!(err.is_none());
|
||||
assert!(working_set.parse_errors.is_empty());
|
||||
assert_eq!(block.len(), 1);
|
||||
let expressions = &block[0];
|
||||
assert_eq!(expressions.len(), 1);
|
||||
@ -567,9 +565,9 @@ pub fn parse_binary_with_multi_byte_char() {
|
||||
|
||||
// found using fuzzing, Rust can panic if you slice into this string
|
||||
let contents = b"0x[\xEF\xBF\xBD]";
|
||||
let (block, err) = parse(&mut working_set, None, contents, true, &[]);
|
||||
let block = parse(&mut working_set, None, contents, true, &[]);
|
||||
|
||||
assert!(err.is_none());
|
||||
assert!(working_set.parse_errors.is_empty());
|
||||
assert_eq!(block.len(), 1);
|
||||
let expressions = &block[0];
|
||||
assert_eq!(expressions.len(), 1);
|
||||
@ -588,9 +586,9 @@ pub fn parse_call() {
|
||||
let sig = Signature::build("foo").named("--jazz", SyntaxShape::Int, "jazz!!", Some('j'));
|
||||
working_set.add_decl(sig.predeclare());
|
||||
|
||||
let (block, err) = parse(&mut working_set, None, b"foo", true, &[]);
|
||||
let block = parse(&mut working_set, None, b"foo", true, &[]);
|
||||
|
||||
assert!(err.is_none());
|
||||
assert!(working_set.parse_errors.is_empty());
|
||||
assert_eq!(block.len(), 1);
|
||||
|
||||
let expressions = &block[0];
|
||||
@ -616,8 +614,11 @@ pub fn parse_call_missing_flag_arg() {
|
||||
let sig = Signature::build("foo").named("jazz", SyntaxShape::Int, "jazz!!", Some('j'));
|
||||
working_set.add_decl(sig.predeclare());
|
||||
|
||||
let (_, err) = parse(&mut working_set, None, b"foo --jazz", true, &[]);
|
||||
assert!(matches!(err, Some(ParseError::MissingFlagParam(..))));
|
||||
parse(&mut working_set, None, b"foo --jazz", true, &[]);
|
||||
assert!(matches!(
|
||||
working_set.parse_errors.first(),
|
||||
Some(ParseError::MissingFlagParam(..))
|
||||
));
|
||||
}
|
||||
|
||||
#[test]
|
||||
@ -628,8 +629,11 @@ pub fn parse_call_missing_short_flag_arg() {
|
||||
let sig = Signature::build("foo").named("--jazz", SyntaxShape::Int, "jazz!!", Some('j'));
|
||||
working_set.add_decl(sig.predeclare());
|
||||
|
||||
let (_, err) = parse(&mut working_set, None, b"foo -j", true, &[]);
|
||||
assert!(matches!(err, Some(ParseError::MissingFlagParam(..))));
|
||||
parse(&mut working_set, None, b"foo -j", true, &[]);
|
||||
assert!(matches!(
|
||||
working_set.parse_errors.first(),
|
||||
Some(ParseError::MissingFlagParam(..))
|
||||
));
|
||||
}
|
||||
|
||||
#[test]
|
||||
@ -641,9 +645,9 @@ pub fn parse_call_too_many_shortflag_args() {
|
||||
.named("--jazz", SyntaxShape::Int, "jazz!!", Some('j'))
|
||||
.named("--math", SyntaxShape::Int, "math!!", Some('m'));
|
||||
working_set.add_decl(sig.predeclare());
|
||||
let (_, err) = parse(&mut working_set, None, b"foo -mj", true, &[]);
|
||||
parse(&mut working_set, None, b"foo -mj", true, &[]);
|
||||
assert!(matches!(
|
||||
err,
|
||||
working_set.parse_errors.first(),
|
||||
Some(ParseError::ShortFlagBatchCantTakeArg(..))
|
||||
));
|
||||
}
|
||||
@ -655,8 +659,11 @@ pub fn parse_call_unknown_shorthand() {
|
||||
|
||||
let sig = Signature::build("foo").switch("--jazz", "jazz!!", Some('j'));
|
||||
working_set.add_decl(sig.predeclare());
|
||||
let (_, err) = parse(&mut working_set, None, b"foo -mj", true, &[]);
|
||||
assert!(matches!(err, Some(ParseError::UnknownFlag(..))));
|
||||
parse(&mut working_set, None, b"foo -mj", true, &[]);
|
||||
assert!(matches!(
|
||||
working_set.parse_errors.first(),
|
||||
Some(ParseError::UnknownFlag(..))
|
||||
));
|
||||
}
|
||||
|
||||
#[test]
|
||||
@ -666,8 +673,11 @@ pub fn parse_call_extra_positional() {
|
||||
|
||||
let sig = Signature::build("foo").switch("--jazz", "jazz!!", Some('j'));
|
||||
working_set.add_decl(sig.predeclare());
|
||||
let (_, err) = parse(&mut working_set, None, b"foo -j 100", true, &[]);
|
||||
assert!(matches!(err, Some(ParseError::ExtraPositional(..))));
|
||||
parse(&mut working_set, None, b"foo -j 100", true, &[]);
|
||||
assert!(matches!(
|
||||
working_set.parse_errors.first(),
|
||||
Some(ParseError::ExtraPositional(..))
|
||||
));
|
||||
}
|
||||
|
||||
#[test]
|
||||
@ -677,8 +687,11 @@ pub fn parse_call_missing_req_positional() {
|
||||
|
||||
let sig = Signature::build("foo").required("jazz", SyntaxShape::Int, "jazz!!");
|
||||
working_set.add_decl(sig.predeclare());
|
||||
let (_, err) = parse(&mut working_set, None, b"foo", true, &[]);
|
||||
assert!(matches!(err, Some(ParseError::MissingPositional(..))));
|
||||
parse(&mut working_set, None, b"foo", true, &[]);
|
||||
assert!(matches!(
|
||||
working_set.parse_errors.first(),
|
||||
Some(ParseError::MissingPositional(..))
|
||||
));
|
||||
}
|
||||
|
||||
#[test]
|
||||
@ -688,17 +701,20 @@ pub fn parse_call_missing_req_flag() {
|
||||
|
||||
let sig = Signature::build("foo").required_named("--jazz", SyntaxShape::Int, "jazz!!", None);
|
||||
working_set.add_decl(sig.predeclare());
|
||||
let (_, err) = parse(&mut working_set, None, b"foo", true, &[]);
|
||||
assert!(matches!(err, Some(ParseError::MissingRequiredFlag(..))));
|
||||
parse(&mut working_set, None, b"foo", true, &[]);
|
||||
assert!(matches!(
|
||||
working_set.parse_errors.first(),
|
||||
Some(ParseError::MissingRequiredFlag(..))
|
||||
));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_nothing_comparison_eq() {
|
||||
let engine_state = EngineState::new();
|
||||
let mut working_set = StateWorkingSet::new(&engine_state);
|
||||
let (block, err) = parse(&mut working_set, None, b"2 == null", true, &[]);
|
||||
let block = parse(&mut working_set, None, b"2 == null", true, &[]);
|
||||
|
||||
assert!(err.is_none());
|
||||
assert!(working_set.parse_errors.is_empty());
|
||||
assert_eq!(block.len(), 1);
|
||||
|
||||
let expressions = &block[0];
|
||||
@ -719,9 +735,9 @@ fn test_nothing_comparison_eq() {
|
||||
fn test_nothing_comparison_neq() {
|
||||
let engine_state = EngineState::new();
|
||||
let mut working_set = StateWorkingSet::new(&engine_state);
|
||||
let (block, err) = parse(&mut working_set, None, b"2 != null", true, &[]);
|
||||
let block = parse(&mut working_set, None, b"2 != null", true, &[]);
|
||||
|
||||
assert!(err.is_none());
|
||||
assert!(working_set.parse_errors.is_empty());
|
||||
assert_eq!(block.len(), 1);
|
||||
|
||||
let expressions = &block[0];
|
||||
@ -746,9 +762,9 @@ mod string {
|
||||
let engine_state = EngineState::new();
|
||||
let mut working_set = StateWorkingSet::new(&engine_state);
|
||||
|
||||
let (block, err) = parse(&mut working_set, None, b"\"hello nushell\"", true, &[]);
|
||||
let block = parse(&mut working_set, None, b"\"hello nushell\"", true, &[]);
|
||||
|
||||
assert!(err.is_none());
|
||||
assert!(working_set.parse_errors.is_empty());
|
||||
assert_eq!(block.len(), 1);
|
||||
let expressions = &block[0];
|
||||
assert_eq!(expressions.len(), 1);
|
||||
@ -769,9 +785,9 @@ mod string {
|
||||
let engine_state = EngineState::new();
|
||||
let mut working_set = StateWorkingSet::new(&engine_state);
|
||||
|
||||
let (block, err) = parse(&mut working_set, None, b"$\"hello (39 + 3)\"", true, &[]);
|
||||
let block = parse(&mut working_set, None, b"$\"hello (39 + 3)\"", true, &[]);
|
||||
|
||||
assert!(err.is_none());
|
||||
assert!(working_set.parse_errors.is_empty());
|
||||
assert_eq!(block.len(), 1);
|
||||
|
||||
let expressions = &block[0];
|
||||
@ -801,9 +817,9 @@ mod string {
|
||||
let engine_state = EngineState::new();
|
||||
let mut working_set = StateWorkingSet::new(&engine_state);
|
||||
|
||||
let (block, err) = parse(&mut working_set, None, b"$\"hello \\(39 + 3)\"", true, &[]);
|
||||
let block = parse(&mut working_set, None, b"$\"hello \\(39 + 3)\"", true, &[]);
|
||||
|
||||
assert!(err.is_none());
|
||||
assert!(working_set.parse_errors.is_empty());
|
||||
|
||||
assert_eq!(block.len(), 1);
|
||||
let expressions = &block[0];
|
||||
@ -832,7 +848,7 @@ mod string {
|
||||
let engine_state = EngineState::new();
|
||||
let mut working_set = StateWorkingSet::new(&engine_state);
|
||||
|
||||
let (block, err) = parse(
|
||||
let block = parse(
|
||||
&mut working_set,
|
||||
None,
|
||||
b"$\"hello \\\\(39 + 3)\"",
|
||||
@ -840,7 +856,7 @@ mod string {
|
||||
&[],
|
||||
);
|
||||
|
||||
assert!(err.is_none());
|
||||
assert!(working_set.parse_errors.is_empty());
|
||||
|
||||
assert_eq!(block.len(), 1);
|
||||
let expressions = &block[0];
|
||||
@ -871,7 +887,7 @@ mod string {
|
||||
let engine_state = EngineState::new();
|
||||
let mut working_set = StateWorkingSet::new(&engine_state);
|
||||
|
||||
let (block, err) = parse(
|
||||
let block = parse(
|
||||
&mut working_set,
|
||||
None,
|
||||
b"$\"\\(1 + 3)\\(7 - 5)\"",
|
||||
@ -879,7 +895,7 @@ mod string {
|
||||
&[],
|
||||
);
|
||||
|
||||
assert!(err.is_none());
|
||||
assert!(working_set.parse_errors.is_empty());
|
||||
|
||||
assert_eq!(block.len(), 1);
|
||||
let expressions = &block[0];
|
||||
@ -914,7 +930,7 @@ mod string {
|
||||
false,
|
||||
);
|
||||
|
||||
let (_block, err) = parse(
|
||||
parse(
|
||||
&mut working_set,
|
||||
None,
|
||||
br#"
|
||||
@ -924,7 +940,7 @@ mod string {
|
||||
&[],
|
||||
);
|
||||
|
||||
assert!(err.is_none());
|
||||
assert!(working_set.parse_errors.is_empty());
|
||||
}
|
||||
|
||||
#[test]
|
||||
@ -939,7 +955,7 @@ mod string {
|
||||
false,
|
||||
);
|
||||
|
||||
let (_block, err) = parse(
|
||||
parse(
|
||||
&mut working_set,
|
||||
None,
|
||||
br#"
|
||||
@ -949,7 +965,7 @@ mod string {
|
||||
&[],
|
||||
);
|
||||
|
||||
assert!(err.is_none());
|
||||
assert!(working_set.parse_errors.is_empty());
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -963,9 +979,9 @@ mod range {
|
||||
let engine_state = EngineState::new();
|
||||
let mut working_set = StateWorkingSet::new(&engine_state);
|
||||
|
||||
let (block, err) = parse(&mut working_set, None, b"0..10", true, &[]);
|
||||
let block = parse(&mut working_set, None, b"0..10", true, &[]);
|
||||
|
||||
assert!(err.is_none());
|
||||
assert!(working_set.parse_errors.is_empty());
|
||||
assert_eq!(block.len(), 1);
|
||||
|
||||
let expressions = &block[0];
|
||||
@ -995,9 +1011,9 @@ mod range {
|
||||
let engine_state = EngineState::new();
|
||||
let mut working_set = StateWorkingSet::new(&engine_state);
|
||||
|
||||
let (block, err) = parse(&mut working_set, None, b"0..<10", true, &[]);
|
||||
let block = parse(&mut working_set, None, b"0..<10", true, &[]);
|
||||
|
||||
assert!(err.is_none());
|
||||
assert!(working_set.parse_errors.is_empty());
|
||||
assert_eq!(block.len(), 1);
|
||||
|
||||
let expressions = &block[0];
|
||||
@ -1027,9 +1043,9 @@ mod range {
|
||||
let engine_state = EngineState::new();
|
||||
let mut working_set = StateWorkingSet::new(&engine_state);
|
||||
|
||||
let (block, err) = parse(&mut working_set, None, b"10..0", true, &[]);
|
||||
let block = parse(&mut working_set, None, b"10..0", true, &[]);
|
||||
|
||||
assert!(err.is_none());
|
||||
assert!(working_set.parse_errors.is_empty());
|
||||
assert_eq!(block.len(), 1);
|
||||
|
||||
let expressions = &block[0];
|
||||
@ -1059,9 +1075,9 @@ mod range {
|
||||
let engine_state = EngineState::new();
|
||||
let mut working_set = StateWorkingSet::new(&engine_state);
|
||||
|
||||
let (block, err) = parse(&mut working_set, None, b"(3 - 3)..<(8 + 2)", true, &[]);
|
||||
let block = parse(&mut working_set, None, b"(3 - 3)..<(8 + 2)", true, &[]);
|
||||
|
||||
assert!(err.is_none());
|
||||
assert!(working_set.parse_errors.is_empty());
|
||||
assert_eq!(block.len(), 1);
|
||||
|
||||
let expressions = &block[0];
|
||||
@ -1093,9 +1109,9 @@ mod range {
|
||||
|
||||
working_set.add_decl(Box::new(Let));
|
||||
|
||||
let (block, err) = parse(&mut working_set, None, b"let a = 2; $a..10", true, &[]);
|
||||
let block = parse(&mut working_set, None, b"let a = 2; $a..10", true, &[]);
|
||||
|
||||
assert!(err.is_none());
|
||||
assert!(working_set.parse_errors.is_empty());
|
||||
assert_eq!(block.len(), 2);
|
||||
|
||||
let expressions = &block[1];
|
||||
@ -1127,7 +1143,7 @@ mod range {
|
||||
|
||||
working_set.add_decl(Box::new(Let));
|
||||
|
||||
let (block, err) = parse(
|
||||
let block = parse(
|
||||
&mut working_set,
|
||||
None,
|
||||
b"let a = 2; $a..<($a + 10)",
|
||||
@ -1135,7 +1151,7 @@ mod range {
|
||||
&[],
|
||||
);
|
||||
|
||||
assert!(err.is_none());
|
||||
assert!(working_set.parse_errors.is_empty());
|
||||
assert_eq!(block.len(), 2);
|
||||
|
||||
let expressions = &block[1];
|
||||
@ -1165,9 +1181,9 @@ mod range {
|
||||
let engine_state = EngineState::new();
|
||||
let mut working_set = StateWorkingSet::new(&engine_state);
|
||||
|
||||
let (block, err) = parse(&mut working_set, None, b"0..", true, &[]);
|
||||
let block = parse(&mut working_set, None, b"0..", true, &[]);
|
||||
|
||||
assert!(err.is_none());
|
||||
assert!(working_set.parse_errors.is_empty());
|
||||
assert_eq!(block.len(), 1);
|
||||
|
||||
let expressions = &block[0];
|
||||
@ -1197,9 +1213,9 @@ mod range {
|
||||
let engine_state = EngineState::new();
|
||||
let mut working_set = StateWorkingSet::new(&engine_state);
|
||||
|
||||
let (block, err) = parse(&mut working_set, None, b"..10", true, &[]);
|
||||
let block = parse(&mut working_set, None, b"..10", true, &[]);
|
||||
|
||||
assert!(err.is_none());
|
||||
assert!(working_set.parse_errors.is_empty());
|
||||
assert_eq!(block.len(), 1);
|
||||
|
||||
let expressions = &block[0];
|
||||
@ -1229,9 +1245,9 @@ mod range {
|
||||
let engine_state = EngineState::new();
|
||||
let mut working_set = StateWorkingSet::new(&engine_state);
|
||||
|
||||
let (block, err) = parse(&mut working_set, None, b"-10..-3", true, &[]);
|
||||
let block = parse(&mut working_set, None, b"-10..-3", true, &[]);
|
||||
|
||||
assert!(err.is_none());
|
||||
assert!(working_set.parse_errors.is_empty());
|
||||
assert_eq!(block.len(), 1);
|
||||
|
||||
let expressions = &block[0];
|
||||
@ -1261,9 +1277,9 @@ mod range {
|
||||
let engine_state = EngineState::new();
|
||||
let mut working_set = StateWorkingSet::new(&engine_state);
|
||||
|
||||
let (block, err) = parse(&mut working_set, None, b"2.0..4.0..10.0", true, &[]);
|
||||
let block = parse(&mut working_set, None, b"2.0..4.0..10.0", true, &[]);
|
||||
|
||||
assert!(err.is_none());
|
||||
assert!(working_set.parse_errors.is_empty());
|
||||
assert_eq!(block.len(), 1);
|
||||
|
||||
let expressions = &block[0];
|
||||
@ -1293,9 +1309,9 @@ mod range {
|
||||
let engine_state = EngineState::new();
|
||||
let mut working_set = StateWorkingSet::new(&engine_state);
|
||||
|
||||
let (_, err) = parse(&mut working_set, None, b"(0)..\"a\"", true, &[]);
|
||||
parse(&mut working_set, None, b"(0)..\"a\"", true, &[]);
|
||||
|
||||
assert!(err.is_some());
|
||||
assert!(!working_set.parse_errors.is_empty());
|
||||
}
|
||||
}
|
||||
|
||||
@ -1616,9 +1632,9 @@ mod input_types {
|
||||
let mut working_set = StateWorkingSet::new(&engine_state);
|
||||
let input = r#"ls | to-custom | group-by name other"#;
|
||||
|
||||
let (block, err) = parse(&mut working_set, None, input.as_bytes(), true, &[]);
|
||||
let block = parse(&mut working_set, None, input.as_bytes(), true, &[]);
|
||||
|
||||
assert!(err.is_none());
|
||||
assert!(working_set.parse_errors.is_empty());
|
||||
assert_eq!(block.len(), 1);
|
||||
|
||||
let expressions = &block[0];
|
||||
@ -1680,9 +1696,9 @@ mod input_types {
|
||||
let input =
|
||||
r#"let a = (ls | to-custom | group-by name other); let b = (1+3); $a | agg sum"#;
|
||||
|
||||
let (block, err) = parse(&mut working_set, None, input.as_bytes(), true, &[]);
|
||||
let block = parse(&mut working_set, None, input.as_bytes(), true, &[]);
|
||||
|
||||
assert!(err.is_none());
|
||||
assert!(working_set.parse_errors.is_empty());
|
||||
assert_eq!(block.len(), 3);
|
||||
|
||||
let expressions = &block[2];
|
||||
@ -1711,9 +1727,9 @@ mod input_types {
|
||||
let mut working_set = StateWorkingSet::new(&engine_state);
|
||||
let input = r#"let a = (ls | to-custom | group-by name other); ($a + $a) | agg sum"#;
|
||||
|
||||
let (block, err) = parse(&mut working_set, None, input.as_bytes(), true, &[]);
|
||||
let block = parse(&mut working_set, None, input.as_bytes(), true, &[]);
|
||||
|
||||
assert!(err.is_none());
|
||||
assert!(working_set.parse_errors.is_empty());
|
||||
assert_eq!(block.len(), 2);
|
||||
|
||||
let expressions = &block[1];
|
||||
@ -1743,9 +1759,9 @@ mod input_types {
|
||||
let input = r#"
|
||||
let a = (ls | to-custom | group-by name other); [1 2 3] | to-custom; [1 2 3] | to-custom"#;
|
||||
|
||||
let (block, err) = parse(&mut working_set, None, input.as_bytes(), true, &[]);
|
||||
let block = parse(&mut working_set, None, input.as_bytes(), true, &[]);
|
||||
|
||||
assert!(err.is_none());
|
||||
assert!(working_set.parse_errors.is_empty());
|
||||
assert_eq!(block.len(), 3);
|
||||
|
||||
let expressions = &block[1];
|
||||
@ -1787,9 +1803,9 @@ mod input_types {
|
||||
let mut working_set = StateWorkingSet::new(&engine_state);
|
||||
let input = r#"ls | group-by name"#;
|
||||
|
||||
let (block, err) = parse(&mut working_set, None, input.as_bytes(), true, &[]);
|
||||
let block = parse(&mut working_set, None, input.as_bytes(), true, &[]);
|
||||
|
||||
assert!(err.is_none());
|
||||
assert!(working_set.parse_errors.is_empty());
|
||||
assert_eq!(block.len(), 1);
|
||||
|
||||
let expressions = &block[0];
|
||||
@ -1832,7 +1848,7 @@ mod input_types {
|
||||
let (block, delta) = {
|
||||
let mut working_set = StateWorkingSet::new(&engine_state);
|
||||
let input = r#"ls | to-custom | group-by name other | agg ("b" | min)"#;
|
||||
let (block, _) = parse(&mut working_set, None, input.as_bytes(), true, &[]);
|
||||
let block = parse(&mut working_set, None, input.as_bytes(), true, &[]);
|
||||
|
||||
(block, working_set.render())
|
||||
};
|
||||
@ -1893,9 +1909,9 @@ mod input_types {
|
||||
let mut working_set = StateWorkingSet::new(&engine_state);
|
||||
let input = r#"[[a b]; [1 2] [3 4]] | to-custom | with-column [ ("a" | min) ("b" | min) ] | collect"#;
|
||||
|
||||
let (block, err) = parse(&mut working_set, None, input.as_bytes(), true, &[]);
|
||||
let block = parse(&mut working_set, None, input.as_bytes(), true, &[]);
|
||||
|
||||
assert!(err.is_none());
|
||||
assert!(working_set.parse_errors.is_empty());
|
||||
assert_eq!(block.len(), 1);
|
||||
|
||||
let expressions = &block[0];
|
||||
@ -1947,9 +1963,9 @@ mod input_types {
|
||||
];
|
||||
|
||||
for input in inputs {
|
||||
let (block, err) = parse(&mut working_set, None, input.as_bytes(), true, &[]);
|
||||
let block = parse(&mut working_set, None, input.as_bytes(), true, &[]);
|
||||
|
||||
assert!(err.is_none(), "testing: {input}");
|
||||
assert!(working_set.parse_errors.is_empty());
|
||||
assert_eq!(block.len(), 2, "testing: {input}");
|
||||
}
|
||||
}
|
||||
@ -1960,7 +1976,7 @@ mod input_types {
|
||||
add_declarations(&mut engine_state);
|
||||
|
||||
let mut working_set = StateWorkingSet::new(&engine_state);
|
||||
let (_, err) = parse(
|
||||
parse(
|
||||
&mut working_set,
|
||||
None,
|
||||
b"if false { 'a' } else { $foo }",
|
||||
@ -1968,9 +1984,10 @@ mod input_types {
|
||||
&[],
|
||||
);
|
||||
|
||||
let err = err.unwrap();
|
||||
|
||||
assert!(matches!(err, ParseError::VariableNotFound(_)));
|
||||
assert!(matches!(
|
||||
working_set.parse_errors.first(),
|
||||
Some(ParseError::VariableNotFound(_))
|
||||
));
|
||||
}
|
||||
|
||||
#[test]
|
||||
@ -1979,7 +1996,7 @@ mod input_types {
|
||||
add_declarations(&mut engine_state);
|
||||
|
||||
let mut working_set = StateWorkingSet::new(&engine_state);
|
||||
let (_, err) = parse(
|
||||
parse(
|
||||
&mut working_set,
|
||||
None,
|
||||
b"if false { 'a' } else $foo { 'b' }",
|
||||
@ -1987,8 +2004,9 @@ mod input_types {
|
||||
&[],
|
||||
);
|
||||
|
||||
let err = err.unwrap();
|
||||
|
||||
assert!(matches!(err, ParseError::VariableNotFound(_)));
|
||||
assert!(matches!(
|
||||
working_set.parse_errors.first(),
|
||||
Some(ParseError::VariableNotFound(_))
|
||||
));
|
||||
}
|
||||
}
|
||||
|
@ -14,9 +14,9 @@ pub fn do_test(test: &[u8], expected: &str, error_contains: Option<&str>) {
|
||||
let engine_state = EngineState::new();
|
||||
let mut working_set = StateWorkingSet::new(&engine_state);
|
||||
|
||||
let (block, err) = parse(&mut working_set, None, test, true, &[]);
|
||||
let block = parse(&mut working_set, None, test, true, &[]);
|
||||
|
||||
match err {
|
||||
match working_set.parse_errors.first() {
|
||||
None => {
|
||||
assert_eq!(block.len(), 1);
|
||||
let expressions = &block[0];
|
||||
|
Reference in New Issue
Block a user