mirror of
https://github.com/nushell/nushell.git
synced 2025-08-09 06:55:36 +02:00
Protocol: debug_assert!() Span to reflect a valid slice (#6806)
Also enforce this by #[non_exhaustive] span such that going forward we cannot, in debug builds (1), construct invalid spans. The motivation for this stems from #6431 where I've seen crashes due to invalid slice indexing. My hope is this will mitigate such senarios 1. https://github.com/nushell/nushell/pull/6431#issuecomment-1278147241 # Description (description of your pull request here) # Tests Make sure you've done the following: - [ ] Add tests that cover your changes, either in the command examples, the crate/tests folder, or in the /tests folder. - [ ] Try to think about corner cases and various ways how your changes could break. Cover them with tests. - [ ] If adding tests is not possible, please document in the PR body a minimal example with steps on how to reproduce so one can verify your change works. Make sure you've run and fixed any issues with these commands: - [x] `cargo fmt --all -- --check` to check standard code formatting (`cargo fmt --all` applies these changes) - [ ] `cargo clippy --workspace --features=extra -- -D warnings -D clippy::unwrap_used -A clippy::needless_collect` to check that you're using the standard code style - [ ] `cargo test --workspace --features=extra` to check that all the tests pass # Documentation - [ ] If your PR touches a user-facing nushell feature then make sure that there is an entry in the documentation (https://github.com/nushell/nushell.github.io) for the feature, and update it if necessary.
This commit is contained in:
Daniel Buch Hansen
committed by
GitHub
GitHub
parent
e6cf18ea43
commit
850ecf648a
@ -102,10 +102,7 @@ pub fn flatten_expression(
|
||||
}
|
||||
Expr::UnaryNot(inner_expr) => {
|
||||
let mut output = vec![(
|
||||
Span {
|
||||
start: expr.span.start,
|
||||
end: expr.span.start + 3,
|
||||
},
|
||||
Span::new(expr.span.start, expr.span.start + 3),
|
||||
FlatShape::Operator,
|
||||
)];
|
||||
output.extend(flatten_expression(working_set, inner_expr));
|
||||
@ -123,25 +120,13 @@ pub fn flatten_expression(
|
||||
|
||||
if let Some(first) = flattened.first() {
|
||||
if first.0.start > outer_span.start {
|
||||
output.push((
|
||||
Span {
|
||||
start: outer_span.start,
|
||||
end: first.0.start,
|
||||
},
|
||||
FlatShape::Block,
|
||||
));
|
||||
output.push((Span::new(outer_span.start, first.0.start), FlatShape::Block));
|
||||
}
|
||||
}
|
||||
|
||||
let last = if let Some(last) = flattened.last() {
|
||||
if last.0.end < outer_span.end {
|
||||
Some((
|
||||
Span {
|
||||
start: last.0.end,
|
||||
end: outer_span.end,
|
||||
},
|
||||
FlatShape::Block,
|
||||
))
|
||||
Some((Span::new(last.0.end, outer_span.end), FlatShape::Block))
|
||||
} else {
|
||||
None
|
||||
}
|
||||
@ -313,13 +298,7 @@ pub fn flatten_expression(
|
||||
|
||||
if let Some(first) = flattened.first() {
|
||||
if first.0.start > last_end {
|
||||
output.push((
|
||||
Span {
|
||||
start: last_end,
|
||||
end: first.0.start,
|
||||
},
|
||||
FlatShape::List,
|
||||
));
|
||||
output.push((Span::new(last_end, first.0.start), FlatShape::List));
|
||||
}
|
||||
}
|
||||
|
||||
@ -331,13 +310,7 @@ pub fn flatten_expression(
|
||||
}
|
||||
|
||||
if last_end < outer_span.end {
|
||||
output.push((
|
||||
Span {
|
||||
start: last_end,
|
||||
end: outer_span.end,
|
||||
},
|
||||
FlatShape::List,
|
||||
));
|
||||
output.push((Span::new(last_end, outer_span.end), FlatShape::List));
|
||||
}
|
||||
output
|
||||
}
|
||||
@ -353,18 +326,12 @@ pub fn flatten_expression(
|
||||
output.insert(
|
||||
0,
|
||||
(
|
||||
Span {
|
||||
start: expr.span.start,
|
||||
end: expr.span.start + 2,
|
||||
},
|
||||
Span::new(expr.span.start, expr.span.start + 2),
|
||||
FlatShape::StringInterpolation,
|
||||
),
|
||||
);
|
||||
output.push((
|
||||
Span {
|
||||
start: expr.span.end - 1,
|
||||
end: expr.span.end,
|
||||
},
|
||||
Span::new(expr.span.end - 1, expr.span.end),
|
||||
FlatShape::StringInterpolation,
|
||||
));
|
||||
}
|
||||
@ -382,13 +349,7 @@ pub fn flatten_expression(
|
||||
|
||||
if let Some(first) = flattened_lhs.first() {
|
||||
if first.0.start > last_end {
|
||||
output.push((
|
||||
Span {
|
||||
start: last_end,
|
||||
end: first.0.start,
|
||||
},
|
||||
FlatShape::Record,
|
||||
));
|
||||
output.push((Span::new(last_end, first.0.start), FlatShape::Record));
|
||||
}
|
||||
}
|
||||
if let Some(last) = flattened_lhs.last() {
|
||||
@ -398,13 +359,7 @@ pub fn flatten_expression(
|
||||
|
||||
if let Some(first) = flattened_rhs.first() {
|
||||
if first.0.start > last_end {
|
||||
output.push((
|
||||
Span {
|
||||
start: last_end,
|
||||
end: first.0.start,
|
||||
},
|
||||
FlatShape::Record,
|
||||
));
|
||||
output.push((Span::new(last_end, first.0.start), FlatShape::Record));
|
||||
}
|
||||
}
|
||||
if let Some(last) = flattened_rhs.last() {
|
||||
@ -414,13 +369,7 @@ pub fn flatten_expression(
|
||||
output.extend(flattened_rhs);
|
||||
}
|
||||
if last_end < outer_span.end {
|
||||
output.push((
|
||||
Span {
|
||||
start: last_end,
|
||||
end: outer_span.end,
|
||||
},
|
||||
FlatShape::Record,
|
||||
));
|
||||
output.push((Span::new(last_end, outer_span.end), FlatShape::Record));
|
||||
}
|
||||
|
||||
output
|
||||
@ -448,13 +397,7 @@ pub fn flatten_expression(
|
||||
let flattened = flatten_expression(working_set, e);
|
||||
if let Some(first) = flattened.first() {
|
||||
if first.0.start > last_end {
|
||||
output.push((
|
||||
Span {
|
||||
start: last_end,
|
||||
end: first.0.start,
|
||||
},
|
||||
FlatShape::Table,
|
||||
));
|
||||
output.push((Span::new(last_end, first.0.start), FlatShape::Table));
|
||||
}
|
||||
}
|
||||
|
||||
@ -469,13 +412,7 @@ pub fn flatten_expression(
|
||||
let flattened = flatten_expression(working_set, expr);
|
||||
if let Some(first) = flattened.first() {
|
||||
if first.0.start > last_end {
|
||||
output.push((
|
||||
Span {
|
||||
start: last_end,
|
||||
end: first.0.start,
|
||||
},
|
||||
FlatShape::Table,
|
||||
));
|
||||
output.push((Span::new(last_end, first.0.start), FlatShape::Table));
|
||||
}
|
||||
}
|
||||
|
||||
@ -488,13 +425,7 @@ pub fn flatten_expression(
|
||||
}
|
||||
|
||||
if last_end < outer_span.end {
|
||||
output.push((
|
||||
Span {
|
||||
start: last_end,
|
||||
end: outer_span.end,
|
||||
},
|
||||
FlatShape::Table,
|
||||
));
|
||||
output.push((Span::new(last_end, outer_span.end), FlatShape::Table));
|
||||
}
|
||||
|
||||
output
|
||||
|
||||
@ -122,10 +122,7 @@ pub fn lex_item(
|
||||
},
|
||||
Some(ParseError::UnexpectedEof(
|
||||
(start as char).to_string(),
|
||||
Span {
|
||||
start: span.end,
|
||||
end: span.end,
|
||||
},
|
||||
Span::new(span.end, span.end),
|
||||
)),
|
||||
);
|
||||
}
|
||||
@ -193,13 +190,8 @@ pub fn lex_item(
|
||||
// If there is still unclosed opening delimiters, remember they were missing
|
||||
if let Some(block) = block_level.last() {
|
||||
let delim = block.closing();
|
||||
let cause = ParseError::UnexpectedEof(
|
||||
(delim as char).to_string(),
|
||||
Span {
|
||||
start: span.end,
|
||||
end: span.end,
|
||||
},
|
||||
);
|
||||
let cause =
|
||||
ParseError::UnexpectedEof((delim as char).to_string(), Span::new(span.end, span.end));
|
||||
|
||||
return (
|
||||
Token {
|
||||
@ -221,10 +213,7 @@ pub fn lex_item(
|
||||
},
|
||||
Some(ParseError::UnexpectedEof(
|
||||
(delim as char).to_string(),
|
||||
Span {
|
||||
start: span.end,
|
||||
end: span.end,
|
||||
},
|
||||
Span::new(span.end, span.end),
|
||||
)),
|
||||
);
|
||||
}
|
||||
|
||||
@ -1179,10 +1179,7 @@ pub fn parse_export_in_module(
|
||||
error = error.or_else(|| {
|
||||
Some(ParseError::MissingPositional(
|
||||
"def, def-env, alias, or env keyword".into(), // TODO: keep filling more keywords as they come
|
||||
Span {
|
||||
start: export_span.end,
|
||||
end: export_span.end,
|
||||
},
|
||||
Span::new(export_span.end, export_span.end),
|
||||
"'def', `def-env`, `alias`, or 'env' keyword.".to_string(),
|
||||
))
|
||||
});
|
||||
@ -1472,11 +1469,10 @@ pub fn parse_module(
|
||||
if block_bytes.ends_with(b"}") {
|
||||
end -= 1;
|
||||
} else {
|
||||
error =
|
||||
error.or_else(|| Some(ParseError::Unclosed("}".into(), Span { start: end, end })));
|
||||
error = error.or_else(|| Some(ParseError::Unclosed("}".into(), Span::new(end, end))));
|
||||
}
|
||||
|
||||
let block_span = Span { start, end };
|
||||
let block_span = Span::new(start, end);
|
||||
|
||||
let (block, module, err) =
|
||||
parse_module_block(working_set, block_span, expand_aliases_denylist);
|
||||
|
||||
@ -173,19 +173,13 @@ pub fn check_call(command: Span, sig: &Signature, call: &Call) -> Option<ParseEr
|
||||
if let Some(last) = call.positional_iter().last() {
|
||||
return Some(ParseError::MissingPositional(
|
||||
argument.name.clone(),
|
||||
Span {
|
||||
start: last.span.end,
|
||||
end: last.span.end,
|
||||
},
|
||||
Span::new(last.span.end, last.span.end),
|
||||
sig.call_signature(),
|
||||
));
|
||||
} else {
|
||||
return Some(ParseError::MissingPositional(
|
||||
argument.name.clone(),
|
||||
Span {
|
||||
start: command.end,
|
||||
end: command.end,
|
||||
},
|
||||
Span::new(command.end, command.end),
|
||||
sig.call_signature(),
|
||||
));
|
||||
}
|
||||
@ -196,19 +190,13 @@ pub fn check_call(command: Span, sig: &Signature, call: &Call) -> Option<ParseEr
|
||||
if let Some(last) = call.positional_iter().last() {
|
||||
Some(ParseError::MissingPositional(
|
||||
missing.name.clone(),
|
||||
Span {
|
||||
start: last.span.end,
|
||||
end: last.span.end,
|
||||
},
|
||||
Span::new(last.span.end, last.span.end),
|
||||
sig.call_signature(),
|
||||
))
|
||||
} else {
|
||||
Some(ParseError::MissingPositional(
|
||||
missing.name.clone(),
|
||||
Span {
|
||||
start: command.end,
|
||||
end: command.end,
|
||||
},
|
||||
Span::new(command.end, command.end),
|
||||
sig.call_signature(),
|
||||
))
|
||||
}
|
||||
@ -285,10 +273,7 @@ pub fn parse_external_call(
|
||||
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,
|
||||
}
|
||||
Span::new(spans[0].start + 1, spans[0].end)
|
||||
} else {
|
||||
spans[0]
|
||||
};
|
||||
@ -345,7 +330,7 @@ pub fn parse_external_call(
|
||||
span: *span,
|
||||
ty: Type::String,
|
||||
custom_completion: None,
|
||||
})
|
||||
});
|
||||
}
|
||||
}
|
||||
(
|
||||
@ -393,10 +378,7 @@ fn parse_long_flag(
|
||||
(
|
||||
Some(Spanned {
|
||||
item: long_name,
|
||||
span: Span {
|
||||
start: arg_span.start,
|
||||
end: arg_span.start + long_name_len + 2,
|
||||
},
|
||||
span: Span::new(arg_span.start, arg_span.start + long_name_len + 2),
|
||||
}),
|
||||
Some(arg),
|
||||
err,
|
||||
@ -486,10 +468,10 @@ fn parse_short_flags(
|
||||
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,
|
||||
};
|
||||
let short_flag_span = Span::new(
|
||||
orig.start + 1 + short_flag.0,
|
||||
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() {
|
||||
@ -715,10 +697,7 @@ pub fn parse_multispan_value(
|
||||
Some(ParseError::KeywordMissingArgument(
|
||||
arg.to_string(),
|
||||
String::from_utf8_lossy(keyword).into(),
|
||||
Span {
|
||||
start: spans[*spans_idx - 1].end,
|
||||
end: spans[*spans_idx - 1].end,
|
||||
},
|
||||
Span::new(spans[*spans_idx - 1].end, spans[*spans_idx - 1].end),
|
||||
))
|
||||
});
|
||||
return (
|
||||
@ -925,10 +904,7 @@ pub fn parse_internal_call(
|
||||
error = error.or_else(|| {
|
||||
Some(ParseError::MissingPositional(
|
||||
positional.name.clone(),
|
||||
Span {
|
||||
start: spans[spans_idx].end,
|
||||
end: spans[spans_idx].end,
|
||||
},
|
||||
Span::new(spans[spans_idx].end, spans[spans_idx].end),
|
||||
signature.call_signature(),
|
||||
))
|
||||
});
|
||||
@ -1621,7 +1597,7 @@ pub fn parse_string_interpolation(
|
||||
(span.start, span.end)
|
||||
};
|
||||
|
||||
let inner_span = Span { start, end };
|
||||
let inner_span = Span::new(start, end);
|
||||
let contents = working_set.get_span_contents(inner_span).to_vec();
|
||||
|
||||
let mut output = vec![];
|
||||
@ -1642,10 +1618,7 @@ pub fn parse_string_interpolation(
|
||||
{
|
||||
mode = InterpolationMode::Expression;
|
||||
if token_start < b {
|
||||
let span = Span {
|
||||
start: token_start,
|
||||
end: b,
|
||||
};
|
||||
let span = Span::new(token_start, b);
|
||||
let str_contents = working_set.get_span_contents(span);
|
||||
|
||||
let str_contents = if double_quote {
|
||||
@ -1696,10 +1669,7 @@ pub fn parse_string_interpolation(
|
||||
mode = InterpolationMode::String;
|
||||
|
||||
if token_start < b {
|
||||
let span = Span {
|
||||
start: token_start,
|
||||
end: b + 1,
|
||||
};
|
||||
let span = Span::new(token_start, b + 1);
|
||||
|
||||
let (expr, err) =
|
||||
parse_full_cell_path(working_set, None, span, expand_aliases_denylist);
|
||||
@ -1718,10 +1688,7 @@ pub fn parse_string_interpolation(
|
||||
match mode {
|
||||
InterpolationMode::String => {
|
||||
if token_start < end {
|
||||
let span = Span {
|
||||
start: token_start,
|
||||
end,
|
||||
};
|
||||
let span = Span::new(token_start, end);
|
||||
let str_contents = working_set.get_span_contents(span);
|
||||
|
||||
let str_contents = if double_quote {
|
||||
@ -1743,10 +1710,7 @@ pub fn parse_string_interpolation(
|
||||
}
|
||||
InterpolationMode::Expression => {
|
||||
if token_start < end {
|
||||
let span = Span {
|
||||
start: token_start,
|
||||
end,
|
||||
};
|
||||
let span = Span::new(token_start, end);
|
||||
|
||||
let (expr, err) =
|
||||
parse_full_cell_path(working_set, None, span, expand_aliases_denylist);
|
||||
@ -1923,11 +1887,11 @@ pub fn parse_full_cell_path(
|
||||
if bytes.ends_with(b")") {
|
||||
end -= 1;
|
||||
} else {
|
||||
error = error
|
||||
.or_else(|| Some(ParseError::Unclosed(")".into(), Span { start: end, end })));
|
||||
error =
|
||||
error.or_else(|| Some(ParseError::Unclosed(")".into(), Span::new(end, end))));
|
||||
}
|
||||
|
||||
let span = Span { start, end };
|
||||
let span = Span::new(start, end);
|
||||
|
||||
let source = working_set.get_span_contents(span);
|
||||
|
||||
@ -2568,19 +2532,13 @@ pub fn unescape_string(bytes: &[u8], span: Span) -> (Vec<u8>, Option<ParseError>
|
||||
}
|
||||
err = Some(ParseError::Expected(
|
||||
"unicode hex value".into(),
|
||||
Span {
|
||||
start: (span.start + idx),
|
||||
end: span.end,
|
||||
},
|
||||
Span::new(span.start + idx, span.end),
|
||||
));
|
||||
}
|
||||
_ => {
|
||||
err = Some(ParseError::Expected(
|
||||
"unicode hex value".into(),
|
||||
Span {
|
||||
start: (span.start + idx),
|
||||
end: span.end,
|
||||
},
|
||||
Span::new(span.start + idx, span.end),
|
||||
));
|
||||
}
|
||||
}
|
||||
@ -2589,10 +2547,7 @@ pub fn unescape_string(bytes: &[u8], span: Span) -> (Vec<u8>, Option<ParseError>
|
||||
_ => {
|
||||
err = Some(ParseError::Expected(
|
||||
"supported escape character".into(),
|
||||
Span {
|
||||
start: (span.start + idx),
|
||||
end: span.end,
|
||||
},
|
||||
Span::new(span.start + idx, span.end),
|
||||
));
|
||||
}
|
||||
}
|
||||
@ -2772,10 +2727,7 @@ pub fn parse_shape_name(
|
||||
let (shape, err) = parse_shape_name(
|
||||
working_set,
|
||||
split[0].as_bytes(),
|
||||
Span {
|
||||
start: span.start,
|
||||
end: span.start + split[0].len(),
|
||||
},
|
||||
Span::new(span.start, span.start + split[0].len()),
|
||||
);
|
||||
let command_name = trim_quotes(split[1].as_bytes());
|
||||
|
||||
@ -2786,10 +2738,10 @@ pub fn parse_shape_name(
|
||||
} else {
|
||||
return (
|
||||
shape,
|
||||
Some(ParseError::UnknownCommand(Span {
|
||||
start: span.start + split[0].len() + 1,
|
||||
end: span.end,
|
||||
})),
|
||||
Some(ParseError::UnknownCommand(Span::new(
|
||||
span.start + split[0].len() + 1,
|
||||
span.end,
|
||||
))),
|
||||
);
|
||||
}
|
||||
} else {
|
||||
@ -3143,10 +3095,7 @@ pub fn parse_signature(
|
||||
error = error.or_else(|| {
|
||||
Some(ParseError::Expected(
|
||||
"[ or (".into(),
|
||||
Span {
|
||||
start,
|
||||
end: start + 1,
|
||||
},
|
||||
Span::new(start, start + 1),
|
||||
))
|
||||
});
|
||||
}
|
||||
@ -3154,16 +3103,11 @@ pub fn parse_signature(
|
||||
if (has_paren && bytes.ends_with(b")")) || (!has_paren && bytes.ends_with(b"]")) {
|
||||
end -= 1;
|
||||
} else {
|
||||
error = error.or_else(|| {
|
||||
Some(ParseError::Unclosed(
|
||||
"] or )".into(),
|
||||
Span { start: end, end },
|
||||
))
|
||||
});
|
||||
error = error.or_else(|| Some(ParseError::Unclosed("] or )".into(), Span::new(end, end))));
|
||||
}
|
||||
|
||||
let (sig, err) =
|
||||
parse_signature_helper(working_set, Span { start, end }, expand_aliases_denylist);
|
||||
parse_signature_helper(working_set, Span::new(start, end), expand_aliases_denylist);
|
||||
error = error.or(err);
|
||||
|
||||
(
|
||||
@ -3631,10 +3575,7 @@ pub fn parse_signature_helper(
|
||||
contents: crate::TokenContents::Comment,
|
||||
span,
|
||||
} => {
|
||||
let contents = working_set.get_span_contents(Span {
|
||||
start: span.start + 1,
|
||||
end: span.end,
|
||||
});
|
||||
let contents = working_set.get_span_contents(Span::new(span.start + 1, span.end));
|
||||
|
||||
let mut contents = String::from_utf8_lossy(contents).to_string();
|
||||
contents = contents.trim().into();
|
||||
@ -3724,10 +3665,10 @@ pub fn parse_list_expression(
|
||||
if bytes.ends_with(b"]") {
|
||||
end -= 1;
|
||||
} else {
|
||||
error = error.or_else(|| Some(ParseError::Unclosed("]".into(), Span { start: end, end })));
|
||||
error = error.or_else(|| Some(ParseError::Unclosed("]".into(), Span::new(end, end))));
|
||||
}
|
||||
|
||||
let inner_span = Span { start, end };
|
||||
let inner_span = Span::new(start, end);
|
||||
let source = working_set.get_span_contents(inner_span);
|
||||
|
||||
let (output, err) = lex(source, inner_span.start, &[b'\n', b'\r', b','], &[], true);
|
||||
@ -3803,10 +3744,10 @@ pub fn parse_table_expression(
|
||||
if bytes.ends_with(b"]") {
|
||||
end -= 1;
|
||||
} else {
|
||||
error = error.or_else(|| Some(ParseError::Unclosed("]".into(), Span { start: end, end })));
|
||||
error = error.or_else(|| Some(ParseError::Unclosed("]".into(), Span::new(end, end))));
|
||||
}
|
||||
|
||||
let inner_span = Span { start, end };
|
||||
let inner_span = Span::new(start, end);
|
||||
|
||||
let source = working_set.get_span_contents(inner_span);
|
||||
|
||||
@ -3938,10 +3879,10 @@ pub fn parse_block_expression(
|
||||
if bytes.ends_with(b"}") {
|
||||
end -= 1;
|
||||
} else {
|
||||
error = error.or_else(|| Some(ParseError::Unclosed("}".into(), Span { start: end, end })));
|
||||
error = error.or_else(|| Some(ParseError::Unclosed("}".into(), Span::new(end, end))));
|
||||
}
|
||||
|
||||
let inner_span = Span { start, end };
|
||||
let inner_span = Span::new(start, end);
|
||||
|
||||
let source = working_set.get_span_contents(inner_span);
|
||||
|
||||
@ -4069,10 +4010,10 @@ pub fn parse_closure_expression(
|
||||
if bytes.ends_with(b"}") {
|
||||
end -= 1;
|
||||
} else {
|
||||
error = error.or_else(|| Some(ParseError::Unclosed("}".into(), Span { start: end, end })));
|
||||
error = error.or_else(|| Some(ParseError::Unclosed("}".into(), Span::new(end, end))));
|
||||
}
|
||||
|
||||
let inner_span = Span { start, end };
|
||||
let inner_span = Span::new(start, end);
|
||||
|
||||
let source = working_set.get_span_contents(inner_span);
|
||||
|
||||
@ -4111,10 +4052,7 @@ pub fn parse_closure_expression(
|
||||
end
|
||||
};
|
||||
|
||||
let signature_span = Span {
|
||||
start: start_point,
|
||||
end: end_point,
|
||||
};
|
||||
let signature_span = Span::new(start_point, end_point);
|
||||
let (signature, err) =
|
||||
parse_signature_helper(working_set, signature_span, expand_aliases_denylist);
|
||||
error = error.or(err);
|
||||
@ -4673,10 +4611,7 @@ pub fn parse_math_expression(
|
||||
garbage(spans[0]),
|
||||
Some(ParseError::Expected(
|
||||
"expression".into(),
|
||||
Span {
|
||||
start: spans[0].end,
|
||||
end: spans[0].end,
|
||||
},
|
||||
Span::new(spans[0].end, spans[0].end),
|
||||
)),
|
||||
);
|
||||
}
|
||||
@ -4825,16 +4760,10 @@ pub fn parse_expression(
|
||||
|
||||
let lhs = parse_string_strict(
|
||||
working_set,
|
||||
Span {
|
||||
start: spans[pos].start,
|
||||
end: spans[pos].start + point - 1,
|
||||
},
|
||||
Span::new(spans[pos].start, 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,
|
||||
};
|
||||
let rhs_span = Span::new(spans[pos].start + point, spans[pos].end);
|
||||
|
||||
if working_set.get_span_contents(rhs_span).starts_with(b"$") {
|
||||
parse_dollar_expr(working_set, rhs_span, expand_aliases_denylist)
|
||||
@ -4845,7 +4774,7 @@ pub fn parse_expression(
|
||||
(
|
||||
Expression {
|
||||
expr: Expr::String(String::new()),
|
||||
span: Span { start: 0, end: 0 },
|
||||
span: Span::unknown(),
|
||||
ty: Type::Nothing,
|
||||
custom_completion: None,
|
||||
},
|
||||
@ -5124,7 +5053,7 @@ pub fn parse_expression(
|
||||
];
|
||||
|
||||
let expr = Expr::Call(Box::new(Call {
|
||||
head: Span { start: 0, end: 0 },
|
||||
head: Span::unknown(),
|
||||
decl_id,
|
||||
arguments,
|
||||
redirect_stdout: true,
|
||||
@ -5232,10 +5161,7 @@ pub fn parse_record(
|
||||
error = error.or_else(|| {
|
||||
Some(ParseError::Expected(
|
||||
"{".into(),
|
||||
Span {
|
||||
start,
|
||||
end: start + 1,
|
||||
},
|
||||
Span::new(start, start + 1),
|
||||
))
|
||||
});
|
||||
}
|
||||
@ -5243,10 +5169,10 @@ pub fn parse_record(
|
||||
if bytes.ends_with(b"}") {
|
||||
end -= 1;
|
||||
} else {
|
||||
error = error.or_else(|| Some(ParseError::Unclosed("}".into(), Span { start: end, end })));
|
||||
error = error.or_else(|| Some(ParseError::Unclosed("}".into(), Span::new(end, end))));
|
||||
}
|
||||
|
||||
let inner_span = Span { start, end };
|
||||
let inner_span = Span::new(start, end);
|
||||
let source = working_set.get_span_contents(inner_span);
|
||||
|
||||
let (tokens, err) = lex(source, start, &[b'\n', b'\r', b','], &[b':'], true);
|
||||
|
||||
Reference in New Issue
Block a user