Skip to content

Commit 67d1388

Browse files
committed
rollup merge of #20061: aturon/stab-2-vec-slice
Conflicts: src/libcollections/slice.rs src/libcollections/vec.rs src/libstd/sys/windows/os.rs
2 parents dd0f29a + 6abfac0 commit 67d1388

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

80 files changed

+2627
-2626
lines changed

src/compiletest/runtest.rs

+3-3
Original file line numberDiff line numberDiff line change
@@ -32,6 +32,7 @@ use std::io::process;
3232
use std::io::timer;
3333
use std::io;
3434
use std::os;
35+
use std::iter::repeat;
3536
use std::str;
3637
use std::string::String;
3738
use std::thread::Thread;
@@ -947,8 +948,7 @@ fn check_expected_errors(expected_errors: Vec<errors::ExpectedError> ,
947948
proc_res: &ProcRes) {
948949

949950
// true if we found the error in question
950-
let mut found_flags = Vec::from_elem(
951-
expected_errors.len(), false);
951+
let mut found_flags: Vec<_> = repeat(false).take(expected_errors.len()).collect();
952952

953953
if proc_res.status.success() {
954954
fatal("process did not return an error status");
@@ -1308,7 +1308,7 @@ fn make_run_args(config: &Config, props: &TestProps, testfile: &Path) ->
13081308
// Add the arguments in the run_flags directive
13091309
args.extend(split_maybe_args(&props.run_flags).into_iter());
13101310

1311-
let prog = args.remove(0).unwrap();
1311+
let prog = args.remove(0);
13121312
return ProcArgs {
13131313
prog: prog,
13141314
args: args,

src/liballoc/arc.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -96,7 +96,7 @@ use heap::deallocate;
9696
/// use std::thread::Thread;
9797
///
9898
/// fn main() {
99-
/// let numbers = Vec::from_fn(100, |i| i as f32);
99+
/// let numbers: Vec<_> = range(0, 100u32).map(|i| i as f32).collect();
100100
/// let shared_numbers = Arc::new(numbers);
101101
///
102102
/// for _ in range(0u, 10) {

src/libcollections/binary_heap.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -66,7 +66,7 @@
6666
//! // for a simpler implementation.
6767
//! fn shortest_path(adj_list: &Vec<Vec<Edge>>, start: uint, goal: uint) -> uint {
6868
//! // dist[node] = current shortest distance from `start` to `node`
69-
//! let mut dist = Vec::from_elem(adj_list.len(), uint::MAX);
69+
//! let mut dist: Vec<_> = range(0, adj_list.len()).map(|_| uint::MAX).collect();
7070
//!
7171
//! let mut heap = BinaryHeap::new();
7272
//!

src/libcollections/bit.rs

+5-5
Original file line numberDiff line numberDiff line change
@@ -85,7 +85,7 @@ use core::prelude::*;
8585
use core::cmp;
8686
use core::default::Default;
8787
use core::fmt;
88-
use core::iter::{Cloned, Chain, Enumerate, Repeat, Skip, Take};
88+
use core::iter::{Cloned, Chain, Enumerate, Repeat, Skip, Take, repeat};
8989
use core::iter;
9090
use core::num::Int;
9191
use core::slice::{Iter, IterMut};
@@ -267,7 +267,7 @@ impl Bitv {
267267
pub fn from_elem(nbits: uint, bit: bool) -> Bitv {
268268
let nblocks = blocks_for_bits(nbits);
269269
let mut bitv = Bitv {
270-
storage: Vec::from_elem(nblocks, if bit { !0u32 } else { 0u32 }),
270+
storage: repeat(if bit { !0u32 } else { 0u32 }).take(nblocks).collect(),
271271
nbits: nbits
272272
};
273273
bitv.fix_last_block();
@@ -651,7 +651,7 @@ impl Bitv {
651651

652652
let len = self.nbits/8 +
653653
if self.nbits % 8 == 0 { 0 } else { 1 };
654-
Vec::from_fn(len, |i|
654+
range(0, len).map(|i|
655655
bit(self, i, 0) |
656656
bit(self, i, 1) |
657657
bit(self, i, 2) |
@@ -660,7 +660,7 @@ impl Bitv {
660660
bit(self, i, 5) |
661661
bit(self, i, 6) |
662662
bit(self, i, 7)
663-
)
663+
).collect()
664664
}
665665

666666
/// Deprecated: Use `iter().collect()`.
@@ -834,7 +834,7 @@ impl Bitv {
834834
// Allocate new words, if needed
835835
if new_nblocks > self.storage.len() {
836836
let to_add = new_nblocks - self.storage.len();
837-
self.storage.grow(to_add, full_value);
837+
self.storage.extend(repeat(full_value).take(to_add));
838838
}
839839

840840
// Adjust internal bit count

src/libcollections/btree/node.rs

+33-33
Original file line numberDiff line numberDiff line change
@@ -555,10 +555,10 @@ impl <K, V> Node<K, V> {
555555
let node = mem::replace(left_and_out, unsafe { Node::new_internal(capacity_from_b(b)) });
556556
left_and_out._len = 1;
557557
unsafe {
558-
ptr::write(left_and_out.keys_mut().unsafe_mut(0), key);
559-
ptr::write(left_and_out.vals_mut().unsafe_mut(0), value);
560-
ptr::write(left_and_out.edges_mut().unsafe_mut(0), node);
561-
ptr::write(left_and_out.edges_mut().unsafe_mut(1), right);
558+
ptr::write(left_and_out.keys_mut().get_unchecked_mut(0), key);
559+
ptr::write(left_and_out.vals_mut().get_unchecked_mut(0), value);
560+
ptr::write(left_and_out.edges_mut().get_unchecked_mut(0), node);
561+
ptr::write(left_and_out.edges_mut().get_unchecked_mut(1), right);
562562
}
563563
}
564564

@@ -637,7 +637,7 @@ impl<'a, K: 'a, V: 'a> Handle<&'a Node<K, V>, handle::Edge, handle::Internal> {
637637
/// making it more suitable for moving down a chain of nodes.
638638
pub fn into_edge(self) -> &'a Node<K, V> {
639639
unsafe {
640-
self.node.edges().unsafe_get(self.index)
640+
self.node.edges().get_unchecked(self.index)
641641
}
642642
}
643643
}
@@ -648,7 +648,7 @@ impl<'a, K: 'a, V: 'a> Handle<&'a mut Node<K, V>, handle::Edge, handle::Internal
648648
/// `edge_mut`, making it more suitable for moving down a chain of nodes.
649649
pub fn into_edge_mut(self) -> &'a mut Node<K, V> {
650650
unsafe {
651-
self.node.edges_mut().unsafe_mut(self.index)
651+
self.node.edges_mut().get_unchecked_mut(self.index)
652652
}
653653
}
654654
}
@@ -722,7 +722,7 @@ impl<K, V, NodeRef: DerefMut<Node<K, V>>> Handle<NodeRef, handle::Edge, handle::
722722
/// confused with `node`, which references the parent node of what is returned here.
723723
pub fn edge_mut(&mut self) -> &mut Node<K, V> {
724724
unsafe {
725-
self.node.edges_mut().unsafe_mut(self.index)
725+
self.node.edges_mut().get_unchecked_mut(self.index)
726726
}
727727
}
728728

@@ -830,8 +830,8 @@ impl<'a, K: 'a, V: 'a, NodeType> Handle<&'a Node<K, V>, handle::KV, NodeType> {
830830
let (keys, vals) = self.node.as_slices();
831831
unsafe {
832832
(
833-
keys.unsafe_get(self.index),
834-
vals.unsafe_get(self.index)
833+
keys.get_unchecked(self.index),
834+
vals.get_unchecked(self.index)
835835
)
836836
}
837837
}
@@ -845,8 +845,8 @@ impl<'a, K: 'a, V: 'a, NodeType> Handle<&'a mut Node<K, V>, handle::KV, NodeType
845845
let (keys, vals) = self.node.as_slices_mut();
846846
unsafe {
847847
(
848-
keys.unsafe_mut(self.index),
849-
vals.unsafe_mut(self.index)
848+
keys.get_unchecked_mut(self.index),
849+
vals.get_unchecked_mut(self.index)
850850
)
851851
}
852852
}
@@ -870,14 +870,14 @@ impl<'a, K: 'a, V: 'a, NodeRef: Deref<Node<K, V>> + 'a, NodeType> Handle<NodeRef
870870
// /// reference with a lifetime as large as `into_kv_mut`, but it also does not consume the
871871
// /// handle.
872872
// pub fn key(&'a self) -> &'a K {
873-
// unsafe { self.node.keys().unsafe_get(self.index) }
873+
// unsafe { self.node.keys().get_unchecked(self.index) }
874874
// }
875875
//
876876
// /// Returns a reference to the value pointed-to by this handle. This doesn't return a
877877
// /// reference with a lifetime as large as `into_kv_mut`, but it also does not consume the
878878
// /// handle.
879879
// pub fn val(&'a self) -> &'a V {
880-
// unsafe { self.node.vals().unsafe_get(self.index) }
880+
// unsafe { self.node.vals().get_unchecked(self.index) }
881881
// }
882882
}
883883

@@ -887,14 +887,14 @@ impl<'a, K: 'a, V: 'a, NodeRef: DerefMut<Node<K, V>> + 'a, NodeType> Handle<Node
887887
/// reference with a lifetime as large as `into_kv_mut`, but it also does not consume the
888888
/// handle.
889889
pub fn key_mut(&'a mut self) -> &'a mut K {
890-
unsafe { self.node.keys_mut().unsafe_mut(self.index) }
890+
unsafe { self.node.keys_mut().get_unchecked_mut(self.index) }
891891
}
892892

893893
/// Returns a mutable reference to the value pointed-to by this handle. This doesn't return a
894894
/// reference with a lifetime as large as `into_kv_mut`, but it also does not consume the
895895
/// handle.
896896
pub fn val_mut(&'a mut self) -> &'a mut V {
897-
unsafe { self.node.vals_mut().unsafe_mut(self.index) }
897+
unsafe { self.node.vals_mut().get_unchecked_mut(self.index) }
898898
}
899899
}
900900

@@ -1078,7 +1078,7 @@ impl<K, V> Node<K, V> {
10781078
debug_assert!(!self.is_leaf());
10791079

10801080
unsafe {
1081-
let ret = ptr::read(self.edges().unsafe_get(0));
1081+
let ret = ptr::read(self.edges().get_unchecked(0));
10821082
self.destroy();
10831083
ptr::write(self, ret);
10841084
}
@@ -1092,8 +1092,8 @@ impl<K, V> Node<K, V> {
10921092
unsafe fn push_kv(&mut self, key: K, val: V) {
10931093
let len = self.len();
10941094

1095-
ptr::write(self.keys_mut().unsafe_mut(len), key);
1096-
ptr::write(self.vals_mut().unsafe_mut(len), val);
1095+
ptr::write(self.keys_mut().get_unchecked_mut(len), key);
1096+
ptr::write(self.vals_mut().get_unchecked_mut(len), val);
10971097

10981098
self._len += 1;
10991099
}
@@ -1103,7 +1103,7 @@ impl<K, V> Node<K, V> {
11031103
unsafe fn push_edge(&mut self, edge: Node<K, V>) {
11041104
let len = self.len();
11051105

1106-
ptr::write(self.edges_mut().unsafe_mut(len), edge);
1106+
ptr::write(self.edges_mut().get_unchecked_mut(len), edge);
11071107
}
11081108

11091109
// This must be followed by insert_edge on an internal node.
@@ -1120,12 +1120,12 @@ impl<K, V> Node<K, V> {
11201120
self.len() - index
11211121
);
11221122

1123-
ptr::write(self.keys_mut().unsafe_mut(index), key);
1124-
ptr::write(self.vals_mut().unsafe_mut(index), val);
1123+
ptr::write(self.keys_mut().get_unchecked_mut(index), key);
1124+
ptr::write(self.vals_mut().get_unchecked_mut(index), val);
11251125

11261126
self._len += 1;
11271127

1128-
self.vals_mut().unsafe_mut(index)
1128+
self.vals_mut().get_unchecked_mut(index)
11291129
}
11301130

11311131
// This can only be called immediately after a call to insert_kv.
@@ -1136,14 +1136,14 @@ impl<K, V> Node<K, V> {
11361136
self.edges().as_ptr().offset(index as int),
11371137
self.len() - index
11381138
);
1139-
ptr::write(self.edges_mut().unsafe_mut(index), edge);
1139+
ptr::write(self.edges_mut().get_unchecked_mut(index), edge);
11401140
}
11411141

11421142
// This must be followed by pop_edge on an internal node.
11431143
#[inline]
11441144
unsafe fn pop_kv(&mut self) -> (K, V) {
1145-
let key = ptr::read(self.keys().unsafe_get(self.len() - 1));
1146-
let val = ptr::read(self.vals().unsafe_get(self.len() - 1));
1145+
let key = ptr::read(self.keys().get_unchecked(self.len() - 1));
1146+
let val = ptr::read(self.vals().get_unchecked(self.len() - 1));
11471147

11481148
self._len -= 1;
11491149

@@ -1153,16 +1153,16 @@ impl<K, V> Node<K, V> {
11531153
// This can only be called immediately after a call to pop_kv.
11541154
#[inline]
11551155
unsafe fn pop_edge(&mut self) -> Node<K, V> {
1156-
let edge = ptr::read(self.edges().unsafe_get(self.len() + 1));
1156+
let edge = ptr::read(self.edges().get_unchecked(self.len() + 1));
11571157

11581158
edge
11591159
}
11601160

11611161
// This must be followed by remove_edge on an internal node.
11621162
#[inline]
11631163
unsafe fn remove_kv(&mut self, index: uint) -> (K, V) {
1164-
let key = ptr::read(self.keys().unsafe_get(index));
1165-
let val = ptr::read(self.vals().unsafe_get(index));
1164+
let key = ptr::read(self.keys().get_unchecked(index));
1165+
let val = ptr::read(self.vals().get_unchecked(index));
11661166

11671167
ptr::copy_memory(
11681168
self.keys_mut().as_mut_ptr().offset(index as int),
@@ -1183,7 +1183,7 @@ impl<K, V> Node<K, V> {
11831183
// This can only be called immediately after a call to remove_kv.
11841184
#[inline]
11851185
unsafe fn remove_edge(&mut self, index: uint) -> Node<K, V> {
1186-
let edge = ptr::read(self.edges().unsafe_get(index));
1186+
let edge = ptr::read(self.edges().get_unchecked(index));
11871187

11881188
ptr::copy_memory(
11891189
self.edges_mut().as_mut_ptr().offset(index as int),
@@ -1230,8 +1230,8 @@ impl<K, V> Node<K, V> {
12301230
);
12311231
}
12321232

1233-
let key = ptr::read(self.keys().unsafe_get(right_offset - 1));
1234-
let val = ptr::read(self.vals().unsafe_get(right_offset - 1));
1233+
let key = ptr::read(self.keys().get_unchecked(right_offset - 1));
1234+
let val = ptr::read(self.vals().get_unchecked(right_offset - 1));
12351235

12361236
self._len = right_offset - 1;
12371237

@@ -1250,8 +1250,8 @@ impl<K, V> Node<K, V> {
12501250
let old_len = self.len();
12511251
self._len += right.len() + 1;
12521252

1253-
ptr::write(self.keys_mut().unsafe_mut(old_len), key);
1254-
ptr::write(self.vals_mut().unsafe_mut(old_len), val);
1253+
ptr::write(self.keys_mut().get_unchecked_mut(old_len), key);
1254+
ptr::write(self.vals_mut().get_unchecked_mut(old_len), val);
12551255

12561256
ptr::copy_nonoverlapping_memory(
12571257
self.keys_mut().as_mut_ptr().offset(old_len as int + 1),

src/libcollections/dlist.rs

+4-2
Original file line numberDiff line numberDiff line change
@@ -1294,8 +1294,10 @@ mod tests {
12941294
v.pop();
12951295
}
12961296
1 => {
1297-
m.pop_front();
1298-
v.remove(0);
1297+
if !v.is_empty() {
1298+
m.pop_front();
1299+
v.remove(0);
1300+
}
12991301
}
13001302
2 | 4 => {
13011303
m.push_front(-i);

src/libcollections/lib.rs

+2-2
Original file line numberDiff line numberDiff line change
@@ -128,8 +128,8 @@ mod prelude {
128128
pub use unicode::char::UnicodeChar;
129129

130130
// from collections.
131-
pub use slice::{CloneSliceExt, VectorVector};
132-
pub use str::{IntoMaybeOwned, StrVector};
131+
pub use slice::{CloneSliceExt, SliceConcatExt};
132+
pub use str::IntoMaybeOwned;
133133
pub use string::{String, ToString};
134134
pub use vec::Vec;
135135
}

src/libcollections/ring_buf.rs

+3-3
Original file line numberDiff line numberDiff line change
@@ -1154,7 +1154,7 @@ impl<'a, T> Iterator<&'a T> for Iter<'a, T> {
11541154
}
11551155
let tail = self.tail;
11561156
self.tail = wrap_index(self.tail + 1, self.ring.len());
1157-
unsafe { Some(self.ring.unsafe_get(tail)) }
1157+
unsafe { Some(self.ring.get_unchecked(tail)) }
11581158
}
11591159

11601160
#[inline]
@@ -1171,7 +1171,7 @@ impl<'a, T> DoubleEndedIterator<&'a T> for Iter<'a, T> {
11711171
return None;
11721172
}
11731173
self.head = wrap_index(self.head - 1, self.ring.len());
1174-
unsafe { Some(self.ring.unsafe_get(self.head)) }
1174+
unsafe { Some(self.ring.get_unchecked(self.head)) }
11751175
}
11761176
}
11771177

@@ -1190,7 +1190,7 @@ impl<'a, T> RandomAccessIterator<&'a T> for Iter<'a, T> {
11901190
None
11911191
} else {
11921192
let idx = wrap_index(self.tail + j, self.ring.len());
1193-
unsafe { Some(self.ring.unsafe_get(idx)) }
1193+
unsafe { Some(self.ring.get_unchecked(idx)) }
11941194
}
11951195
}
11961196
}

0 commit comments

Comments
 (0)