mirror of
https://github.com/nushell/nushell.git
synced 2025-05-29 14:21:45 +02:00
850ecf648a
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.
92 lines
2.3 KiB
Rust
92 lines
2.3 KiB
Rust
use miette::SourceSpan;
|
|
use serde::{Deserialize, Serialize};
|
|
|
|
/// A spanned area of interest, generic over what kind of thing is of interest
|
|
#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq)]
|
|
pub struct Spanned<T>
|
|
where
|
|
T: Clone + std::fmt::Debug,
|
|
{
|
|
pub item: T,
|
|
pub span: Span,
|
|
}
|
|
|
|
/// Spans are a global offset across all seen files, which are cached in the engine's state. The start and
|
|
/// end offset together make the inclusive start/exclusive end pair for where to underline to highlight
|
|
/// a given point of interest.
|
|
#[non_exhaustive]
|
|
#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
|
|
pub struct Span {
|
|
pub start: usize,
|
|
pub end: usize,
|
|
}
|
|
|
|
impl From<Span> for SourceSpan {
|
|
fn from(s: Span) -> Self {
|
|
Self::new(s.start.into(), (s.end - s.start).into())
|
|
}
|
|
}
|
|
|
|
impl Span {
|
|
pub fn new(start: usize, end: usize) -> Span {
|
|
debug_assert!(
|
|
end >= start,
|
|
"Can't create a Span whose end < start, start={}, end={}",
|
|
start,
|
|
end
|
|
);
|
|
|
|
Span { start, end }
|
|
}
|
|
|
|
pub const fn unknown() -> Span {
|
|
Span { start: 0, end: 0 }
|
|
}
|
|
|
|
/// Note: Only use this for test data, *not* live data, as it will point into unknown source
|
|
/// when used in errors.
|
|
pub const fn test_data() -> Span {
|
|
Self::unknown()
|
|
}
|
|
|
|
pub fn offset(&self, offset: usize) -> Span {
|
|
Span::new(self.start - offset, self.end - offset)
|
|
}
|
|
|
|
pub fn contains(&self, pos: usize) -> bool {
|
|
pos >= self.start && pos < self.end
|
|
}
|
|
|
|
pub fn contains_span(&self, span: Span) -> bool {
|
|
span.start >= self.start && span.end <= self.end
|
|
}
|
|
|
|
/// Point to the space just past this span, useful for missing
|
|
/// values
|
|
pub fn past(&self) -> Span {
|
|
Span {
|
|
start: self.end,
|
|
end: self.end,
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Used when you have a slice of spans of at least size 1
|
|
pub fn span(spans: &[Span]) -> Span {
|
|
let length = spans.len();
|
|
|
|
//TODO debug_assert!(length > 0, "expect spans > 0");
|
|
if length == 0 {
|
|
Span::unknown()
|
|
} else if length == 1 {
|
|
spans[0]
|
|
} else {
|
|
let end = spans
|
|
.iter()
|
|
.map(|s| s.end)
|
|
.max()
|
|
.expect("Must be an end. Length > 0");
|
|
Span::new(spans[0].start, end)
|
|
}
|
|
}
|