From 48f2f711857c3797978f1a4e300a1375672cef84 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Sebastian=20Dr=C3=B6ge?= <sebastian@centricular.com>
Date: Wed, 3 Jan 2018 00:58:56 +0200
Subject: [PATCH 1/4] Implement TrustedRandomAccess for slice::{Chunks,
ChunksMut, Windows}
---
src/libcore/slice/mod.rs | 28 ++++++++++++++++++++++++++++
1 file changed, 28 insertions(+)
diff --git a/src/libcore/slice/mod.rs b/src/libcore/slice/mod.rs
index 6b6ec7147b306..ebb1660593137 100644
--- a/src/libcore/slice/mod.rs
+++ b/src/libcore/slice/mod.rs
@@ -2117,6 +2117,14 @@ impl<'a, T> ExactSizeIterator for Windows<'a, T> {}
#[unstable(feature = "fused", issue = "35602")]
impl<'a, T> FusedIterator for Windows<'a, T> {}
+#[doc(hidden)]
+unsafe impl<'a, T> TrustedRandomAccess for Windows<'a, T> {
+ unsafe fn get_unchecked(&mut self, i: usize) -> &'a [T] {
+ from_raw_parts(self.v.as_ptr().offset(i as isize), self.size)
+ }
+ fn may_have_side_effect() -> bool { false }
+}
+
/// An iterator over a slice in (non-overlapping) chunks (`chunk_size` elements at a
/// time).
///
@@ -2228,6 +2236,16 @@ impl<'a, T> ExactSizeIterator for Chunks<'a, T> {}
#[unstable(feature = "fused", issue = "35602")]
impl<'a, T> FusedIterator for Chunks<'a, T> {}
+#[doc(hidden)]
+unsafe impl<'a, T> TrustedRandomAccess for Chunks<'a, T> {
+ unsafe fn get_unchecked(&mut self, i: usize) -> &'a [T] {
+ let start = i * self.size;
+ let end = cmp::min(start + self.size, self.v.len());
+ from_raw_parts(self.v.as_ptr().offset(start as isize), end - start)
+ }
+ fn may_have_side_effect() -> bool { false }
+}
+
/// An iterator over a slice in (non-overlapping) mutable chunks (`chunk_size`
/// elements at a time). When the slice len is not evenly divided by the chunk
/// size, the last slice of the iteration will be the remainder.
@@ -2331,6 +2349,16 @@ impl<'a, T> ExactSizeIterator for ChunksMut<'a, T> {}
#[unstable(feature = "fused", issue = "35602")]
impl<'a, T> FusedIterator for ChunksMut<'a, T> {}
+#[doc(hidden)]
+unsafe impl<'a, T> TrustedRandomAccess for ChunksMut<'a, T> {
+ unsafe fn get_unchecked(&mut self, i: usize) -> &'a mut [T] {
+ let start = i * self.chunk_size;
+ let end = cmp::min(start + self.chunk_size, self.v.len());
+ from_raw_parts_mut(self.v.as_mut_ptr().offset(start as isize), end - start)
+ }
+ fn may_have_side_effect() -> bool { false }
+}
+
//
// Free functions
//
From a56a3fc85f466c8488dccdfb78cfcd05740e0b36 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Sebastian=20Dr=C3=B6ge?= <sebastian@centricular.com>
Date: Wed, 3 Jan 2018 12:25:18 +0200
Subject: [PATCH 2/4] Add unit test for zipping slice::{Chunks, ChunksMut,
Windows} iterators
For testing if the TrustedRandomAccess implementation works.
---
src/libcore/tests/slice.rs | 39 ++++++++++++++++++++++++++++++++++++++
1 file changed, 39 insertions(+)
diff --git a/src/libcore/tests/slice.rs b/src/libcore/tests/slice.rs
index fa4c2e9b3736f..d6230e93f998d 100644
--- a/src/libcore/tests/slice.rs
+++ b/src/libcore/tests/slice.rs
@@ -137,6 +137,18 @@ fn test_chunks_last() {
assert_eq!(c2.last().unwrap()[0], 4);
}
+#[test]
+fn test_chunks_zip() {
+ let v1: &[i32] = &[0, 1, 2, 3, 4];
+ let v2: &[i32] = &[6, 7, 8, 9, 10];
+
+ let res = v1.chunks(2)
+ .zip(v2.chunks(2))
+ .map(|(a, b)| a.iter().sum::<i32>() + b.iter().sum::<i32>())
+ .collect::<Vec<_>>();
+ assert_eq!(res, vec![14, 22, 14]);
+}
+
#[test]
fn test_chunks_mut_count() {
let v: &mut [i32] = &mut [0, 1, 2, 3, 4, 5];
@@ -176,6 +188,20 @@ fn test_chunks_mut_last() {
assert_eq!(c2.last().unwrap()[0], 4);
}
+#[test]
+fn test_chunks_mut_zip() {
+ let v1: &mut [i32] = &mut [0, 1, 2, 3, 4];
+ let v2: &[i32] = &[6, 7, 8, 9, 10];
+
+ for (a, b) in v1.chunks_mut(2).zip(v2.chunks(2)) {
+ let sum = b.iter().sum::<i32>();
+ for v in a {
+ *v += sum;
+ }
+ }
+ assert_eq!(v1, [13, 14, 19, 20, 14]);
+}
+
#[test]
fn test_windows_count() {
let v: &[i32] = &[0, 1, 2, 3, 4, 5];
@@ -215,6 +241,19 @@ fn test_windows_last() {
assert_eq!(c2.last().unwrap()[0], 3);
}
+#[test]
+fn test_windows_zip() {
+ let v1: &[i32] = &[0, 1, 2, 3, 4];
+ let v2: &[i32] = &[6, 7, 8, 9, 10];
+
+ let res = v1.windows(2)
+ .zip(v2.windows(2))
+ .map(|(a, b)| a.iter().sum::<i32>() + b.iter().sum::<i32>())
+ .collect::<Vec<_>>();
+
+ assert_eq!(res, [14, 18, 22, 26]);
+}
+
#[test]
fn get_range() {
let v: &[i32] = &[0, 1, 2, 3, 4, 5];
From 3f29e2b495a6b875af835f1fff64256e2d58d2b6 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Sebastian=20Dr=C3=B6ge?= <sebastian@centricular.com>
Date: Wed, 3 Jan 2018 12:26:55 +0200
Subject: [PATCH 3/4] Fix compilation of TrustedRandomAccess impl for
slice::Chunks
https://github.com/rust-lang/rust/pull/47113 renamed the private size
field to chunk_size for consistency.
---
src/libcore/slice/mod.rs | 4 ++--
1 file changed, 2 insertions(+), 2 deletions(-)
diff --git a/src/libcore/slice/mod.rs b/src/libcore/slice/mod.rs
index ebb1660593137..9b8334167f55f 100644
--- a/src/libcore/slice/mod.rs
+++ b/src/libcore/slice/mod.rs
@@ -2239,8 +2239,8 @@ impl<'a, T> FusedIterator for Chunks<'a, T> {}
#[doc(hidden)]
unsafe impl<'a, T> TrustedRandomAccess for Chunks<'a, T> {
unsafe fn get_unchecked(&mut self, i: usize) -> &'a [T] {
- let start = i * self.size;
- let end = cmp::min(start + self.size, self.v.len());
+ let start = i * self.chunk_size;
+ let end = cmp::min(start + self.chunk_size, self.v.len());
from_raw_parts(self.v.as_ptr().offset(start as isize), end - start)
}
fn may_have_side_effect() -> bool { false }
From b69c124255e25d5d1c16ee88c4f2a75964db9209 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Sebastian=20Dr=C3=B6ge?= <sebastian@centricular.com>
Date: Thu, 4 Jan 2018 11:34:05 +0200
Subject: [PATCH 4/4] Fix potential overflow in TrustedRandomAccess impl for
slice::{Chunks,ChunksMut}
---
src/libcore/slice/mod.rs | 10 ++++++++--
1 file changed, 8 insertions(+), 2 deletions(-)
diff --git a/src/libcore/slice/mod.rs b/src/libcore/slice/mod.rs
index 9b8334167f55f..72036d6d3a248 100644
--- a/src/libcore/slice/mod.rs
+++ b/src/libcore/slice/mod.rs
@@ -2240,7 +2240,10 @@ impl<'a, T> FusedIterator for Chunks<'a, T> {}
unsafe impl<'a, T> TrustedRandomAccess for Chunks<'a, T> {
unsafe fn get_unchecked(&mut self, i: usize) -> &'a [T] {
let start = i * self.chunk_size;
- let end = cmp::min(start + self.chunk_size, self.v.len());
+ let end = match start.checked_add(self.chunk_size) {
+ None => self.v.len(),
+ Some(end) => cmp::min(end, self.v.len()),
+ };
from_raw_parts(self.v.as_ptr().offset(start as isize), end - start)
}
fn may_have_side_effect() -> bool { false }
@@ -2353,7 +2356,10 @@ impl<'a, T> FusedIterator for ChunksMut<'a, T> {}
unsafe impl<'a, T> TrustedRandomAccess for ChunksMut<'a, T> {
unsafe fn get_unchecked(&mut self, i: usize) -> &'a mut [T] {
let start = i * self.chunk_size;
- let end = cmp::min(start + self.chunk_size, self.v.len());
+ let end = match start.checked_add(self.chunk_size) {
+ None => self.v.len(),
+ Some(end) => cmp::min(end, self.v.len()),
+ };
from_raw_parts_mut(self.v.as_mut_ptr().offset(start as isize), end - start)
}
fn may_have_side_effect() -> bool { false }