mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Replace ad hoc implementations with slice::check_range

Browse Source
This commit is contained in:
dylni 2020-08-16 21:47:12 -04:00
parent ed02b90e9b
commit d04e6b8de5
6 changed files with 24 additions and 90 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

37
library/alloc/src/collections/vec_deque.rs
View File

@ -14,8 +14,7 @@
use core::hash::{Hash, Hasher};
use core::iter::{once, repeat_with, FromIterator, FusedIterator};
use core::mem::{self, replace, ManuallyDrop};
use core::ops::Bound::{Excluded, Included, Unbounded};
use core::ops::{Index, IndexMut, RangeBounds, Try};
use core::ops::{Index, IndexMut, Range, RangeBounds, Try};
use core::ptr::{self, NonNull};
use core::slice;
@ -1083,24 +1082,16 @@ pub fn is_empty(&self) -> bool {
self.tail == self.head
}
fn range_start_end<R>(&self, range: R) -> (usize, usize)
fn range_tail_head<R>(&self, range: R) -> (usize, usize)
where
R: RangeBounds<usize>,
{
let len = self.len();
let start = match range.start_bound() {
Included(&n) => n,
Excluded(&n) => n + 1,
Unbounded => 0,
};
let end = match range.end_bound() {
Included(&n) => n + 1,
Excluded(&n) => n,
Unbounded => len,
};
assert!(start <= end, "lower bound was too large");
assert!(end <= len, "upper bound was too large");
(start, end)
// SAFETY: This buffer is only used to check the range.
let buffer = unsafe { slice::from_raw_parts(self.ptr(), self.len()) };
let Range { start, end } = buffer.check_range(range);
let tail = self.wrap_add(self.tail, start);
let head = self.wrap_add(self.tail, end);
(tail, head)
}
/// Creates an iterator that covers the specified range in the `VecDeque`.
@ -1131,9 +1122,7 @@ pub fn range<R>(&self, range: R) -> Iter<'_, T>
where
R: RangeBounds<usize>,
{
let (start, end) = self.range_start_end(range);
let tail = self.wrap_add(self.tail, start);
let head = self.wrap_add(self.tail, end);
let (tail, head) = self.range_tail_head(range);
Iter {
tail,
head,
@ -1174,9 +1163,7 @@ pub fn range_mut<R>(&mut self, range: R) -> IterMut<'_, T>
where
R: RangeBounds<usize>,
{
let (start, end) = self.range_start_end(range);
let tail = self.wrap_add(self.tail, start);
let head = self.wrap_add(self.tail, end);
let (tail, head) = self.range_tail_head(range);
IterMut {
tail,
head,
@ -1230,7 +1217,7 @@ pub fn drain<R>(&mut self, range: R) -> Drain<'_, T>
// When finished, the remaining data will be copied back to cover the hole,
// and the head/tail values will be restored correctly.
//
let (start, end) = self.range_start_end(range);
let (drain_tail, drain_head) = self.range_tail_head(range);
// The deque's elements are parted into three segments:
// * self.tail -> drain_tail
@ -1248,8 +1235,6 @@ pub fn drain<R>(&mut self, range: R) -> Drain<'_, T>
// T t h H
// [. . . o o x x o o . . .]
//
let drain_tail = self.wrap_add(self.tail, start);
let drain_head = self.wrap_add(self.tail, end);
let head = self.head;
// "forget" about the values after the start of the drain until after

1
library/alloc/src/lib.rs
View File

@ -114,6 +114,7 @@
#![feature(rustc_attrs)]
#![feature(receiver_trait)]
#![feature(min_specialization)]
#![feature(slice_check_range)]
#![feature(slice_ptr_get)]
#![feature(slice_ptr_len)]
#![feature(staged_api)]

20
library/alloc/src/string.rs
View File

@ -47,7 +47,7 @@
use core::hash;
use core::iter::{FromIterator, FusedIterator};
use core::ops::Bound::{Excluded, Included, Unbounded};
use core::ops::{self, Add, AddAssign, Index, IndexMut, RangeBounds};
use core::ops::{self, Add, AddAssign, Index, IndexMut, Range, RangeBounds};
use core::ptr;
use core::str::{lossy, pattern::Pattern};
@ -1506,23 +1506,15 @@ pub fn drain<R>(&mut self, range: R) -> Drain<'_>
// of the vector version. The data is just plain bytes.
// Because the range removal happens in Drop, if the Drain iterator is leaked,
// the removal will not happen.
let len = self.len();
let start = match range.start_bound() {
Included(&n) => n,
Excluded(&n) => n + 1,
Unbounded => 0,
};
let end = match range.end_bound() {
Included(&n) => n + 1,
Excluded(&n) => n,
Unbounded => len,
};
let Range { start, end } = self.as_bytes().check_range(range);
assert!(self.is_char_boundary(start));
assert!(self.is_char_boundary(end));
// Take out two simultaneous borrows. The &mut String won't be accessed
// until iteration is over, in Drop.
let self_ptr = self as *mut _;
// slicing does the appropriate bounds checks
let chars_iter = self[start..end].chars();
// SAFETY: `check_range` and `is_char_boundary` do the appropriate bounds checks.
let chars_iter = unsafe { self.get_unchecked(start..end) }.chars();
Drain { start, end, iter: chars_iter, string: self_ptr }
}

33
library/alloc/src/vec.rs
View File

@ -66,8 +66,7 @@
use core::iter::{FromIterator, FusedIterator, TrustedLen};
use core::marker::PhantomData;
use core::mem::{self, ManuallyDrop, MaybeUninit};
use core::ops::Bound::{Excluded, Included, Unbounded};
use core::ops::{self, Index, IndexMut, RangeBounds};
use core::ops::{self, Index, IndexMut, Range, RangeBounds};
use core::ptr::{self, NonNull};
use core::slice::{self, SliceIndex};
@ -1311,35 +1310,7 @@ pub fn drain<R>(&mut self, range: R) -> Drain<'_, T>
// the hole, and the vector length is restored to the new length.
//
let len = self.len();
let start = match range.start_bound() {
Included(&n) => n,
Excluded(&n) => n + 1,
Unbounded => 0,
};
let end = match range.end_bound() {
Included(&n) => n + 1,
Excluded(&n) => n,
Unbounded => len,
};
#[cold]
#[inline(never)]
fn start_assert_failed(start: usize, end: usize) -> ! {
panic!("start drain index (is {}) should be <= end drain index (is {})", start, end);
}
#[cold]
#[inline(never)]
fn end_assert_failed(end: usize, len: usize) -> ! {
panic!("end drain index (is {}) should be <= len (is {})", end, len);
}
if start > end {
start_assert_failed(start, end);
}
if end > len {
end_assert_failed(end, len);
}
let Range { start, end } = self.check_range(range);
unsafe {
// set self.vec length's to start, to be safe in case Drain is leaked

19
library/core/src/slice/mod.rs
View File

@ -2511,26 +2511,11 @@ pub fn copy_from_slice(&mut self, src: &[T])
/// ```
#[stable(feature = "copy_within", since = "1.37.0")]
#[track_caller]
pub fn copy_within<R: ops::RangeBounds<usize>>(&mut self, src: R, dest: usize)
pub fn copy_within<R: RangeBounds<usize>>(&mut self, src: R, dest: usize)
where
T: Copy,
{
let src_start = match src.start_bound() {
ops::Bound::Included(&n) => n,
ops::Bound::Excluded(&n) => {
n.checked_add(1).unwrap_or_else(|| slice_start_index_overflow_fail())
}
ops::Bound::Unbounded => 0,
};
let src_end = match src.end_bound() {
ops::Bound::Included(&n) => {
n.checked_add(1).unwrap_or_else(|| slice_end_index_overflow_fail())
}
ops::Bound::Excluded(&n) => n,
ops::Bound::Unbounded => self.len(),
};
assert!(src_start <= src_end, "src end is before src start");
assert!(src_end <= self.len(), "src is out of bounds");
let Range { start: src_start, end: src_end } = self.check_range(src);
let count = src_end - src_start;
assert!(dest <= self.len() - count, "dest is out of bounds");
unsafe {

4
library/core/tests/slice.rs
View File

@ -1797,7 +1797,7 @@ fn test_copy_within() {
}
#[test]
#[should_panic(expected = "src is out of bounds")]
#[should_panic(expected = "range end index 14 out of range for slice of length 13")]
fn test_copy_within_panics_src_too_long() {
let mut bytes = *b"Hello, World!";
// The length is only 13, so 14 is out of bounds.
@ -1812,7 +1812,7 @@ fn test_copy_within_panics_dest_too_long() {
bytes.copy_within(0..4, 10);
}
#[test]
#[should_panic(expected = "src end is before src start")]
#[should_panic(expected = "slice index starts at 2 but ends at 1")]
fn test_copy_within_panics_src_inverted() {
let mut bytes = *b"Hello, World!";
// 2 is greater than 1, so this range is invalid.