holm/nushell
1
1
Fork 0
forked from extern/nushell
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Protocol: debug_assert!() Span to reflect a valid slice (#6806)

Browse Source 
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
2022-12-03 10:44:12 +01:00
committed by GitHub
parent e6cf18ea43
commit 850ecf648a
36 changed files with 200 additions and 418 deletions
Download Patch File Download Diff File Expand all files Collapse all files

174
crates/nu-parser/src/parser.rs
View File

@ -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);