mirror of
https://github.com/rust-lang/rust
synced 2024-09-15 22:50:55 +00:00
rollup merge of #23886: demelev/remove_as_slice_usage
This commit is contained in:
commit
6d2c640cf0
|
@ -110,7 +110,7 @@
|
|||
/// let child_numbers = shared_numbers.clone();
|
||||
///
|
||||
/// thread::spawn(move || {
|
||||
/// let local_numbers = child_numbers.as_slice();
|
||||
/// let local_numbers = &child_numbers[..];
|
||||
///
|
||||
/// // Work with the local numbers
|
||||
/// });
|
||||
|
|
|
@ -557,7 +557,6 @@ pub fn as_ptr(&self) -> *const T {
|
|||
/// ```rust
|
||||
/// # #![feature(core)]
|
||||
/// let s = [0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55];
|
||||
/// let s = s.as_slice();
|
||||
///
|
||||
/// let seek = 13;
|
||||
/// assert_eq!(s.binary_search_by(|probe| probe.cmp(&seek)), Ok(9));
|
||||
|
@ -924,7 +923,6 @@ pub fn sort(&mut self) where T: Ord {
|
|||
/// ```rust
|
||||
/// # #![feature(core)]
|
||||
/// let s = [0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55];
|
||||
/// let s = s.as_slice();
|
||||
///
|
||||
/// assert_eq!(s.binary_search(&13), Ok(9));
|
||||
/// assert_eq!(s.binary_search(&4), Err(7));
|
||||
|
|
|
@ -1470,12 +1470,12 @@ pub fn parse<F: FromStr>(&self) -> Result<F, F::Err> {
|
|||
/// let gr1 = "a\u{310}e\u{301}o\u{308}\u{332}".graphemes(true).collect::<Vec<&str>>();
|
||||
/// let b: &[_] = &["a\u{310}", "e\u{301}", "o\u{308}\u{332}"];
|
||||
///
|
||||
/// assert_eq!(gr1.as_slice(), b);
|
||||
/// assert_eq!(&gr1[..], b);
|
||||
///
|
||||
/// let gr2 = "a\r\nb🇷🇺🇸🇹".graphemes(true).collect::<Vec<&str>>();
|
||||
/// let b: &[_] = &["a", "\r\n", "b", "🇷🇺🇸🇹"];
|
||||
///
|
||||
/// assert_eq!(gr2.as_slice(), b);
|
||||
/// assert_eq!(&gr2[..], b);
|
||||
/// ```
|
||||
#[unstable(feature = "unicode",
|
||||
reason = "this functionality may only be provided by libunicode")]
|
||||
|
@ -1493,7 +1493,7 @@ pub fn graphemes(&self, is_extended: bool) -> Graphemes {
|
|||
/// let gr_inds = "a̐éö̲\r\n".grapheme_indices(true).collect::<Vec<(usize, &str)>>();
|
||||
/// let b: &[_] = &[(0, "a̐"), (3, "é"), (6, "ö̲"), (11, "\r\n")];
|
||||
///
|
||||
/// assert_eq!(gr_inds.as_slice(), b);
|
||||
/// assert_eq!(&gr_inds[..], b);
|
||||
/// ```
|
||||
#[unstable(feature = "unicode",
|
||||
reason = "this functionality may only be provided by libunicode")]
|
||||
|
|
|
@ -93,7 +93,7 @@ pub fn with_capacity(capacity: usize) -> String {
|
|||
/// ```
|
||||
/// # #![feature(collections, core)]
|
||||
/// let s = String::from_str("hello");
|
||||
/// assert_eq!(s.as_slice(), "hello");
|
||||
/// assert_eq!(&s[..], "hello");
|
||||
/// ```
|
||||
#[inline]
|
||||
#[unstable(feature = "collections",
|
||||
|
|
|
@ -823,13 +823,13 @@ pub fn is_empty(&self) -> bool { self.len() == 0 }
|
|||
/// # #![feature(collections, core)]
|
||||
/// let v = vec![0, 1, 2];
|
||||
/// let w = v.map_in_place(|i| i + 3);
|
||||
/// assert_eq!(w.as_slice(), [3, 4, 5].as_slice());
|
||||
/// assert_eq!(&w[..], &[3, 4, 5]);
|
||||
///
|
||||
/// #[derive(PartialEq, Debug)]
|
||||
/// struct Newtype(u8);
|
||||
/// let bytes = vec![0x11, 0x22];
|
||||
/// let newtyped_bytes = bytes.map_in_place(|x| Newtype(x));
|
||||
/// assert_eq!(newtyped_bytes.as_slice(), [Newtype(0x11), Newtype(0x22)].as_slice());
|
||||
/// assert_eq!(&newtyped_bytes[..], &[Newtype(0x11), Newtype(0x22)]);
|
||||
/// ```
|
||||
#[unstable(feature = "collections",
|
||||
reason = "API may change to provide stronger guarantees")]
|
||||
|
|
|
@ -527,7 +527,8 @@ pub fn truncate(&mut self, len: usize) {
|
|||
/// buf.push_back(3);
|
||||
/// buf.push_back(4);
|
||||
/// let b: &[_] = &[&5, &3, &4];
|
||||
/// assert_eq!(buf.iter().collect::<Vec<&i32>>().as_slice(), b);
|
||||
/// let c: Vec<&i32> = buf.iter().collect();
|
||||
/// assert_eq!(&c[..], b);
|
||||
/// ```
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
pub fn iter(&self) -> Iter<T> {
|
||||
|
|
|
@ -13,5 +13,5 @@
|
|||
#[test]
|
||||
fn test_format() {
|
||||
let s = fmt::format(format_args!("Hello, {}!", "world"));
|
||||
assert_eq!(s.as_slice(), "Hello, world!");
|
||||
assert_eq!(&s[..], "Hello, world!");
|
||||
}
|
||||
|
|
|
@ -59,7 +59,7 @@ fn test_from_elem() {
|
|||
// Test on-heap from_elem.
|
||||
v = vec![20; 6];
|
||||
{
|
||||
let v = v.as_slice();
|
||||
let v = &v[..];
|
||||
assert_eq!(v[0], 20);
|
||||
assert_eq!(v[1], 20);
|
||||
assert_eq!(v[2], 20);
|
||||
|
|
|
@ -1470,9 +1470,9 @@ fn t(s: &str, sep: &str, u: &[&str]) {
|
|||
fn test_str_default() {
|
||||
use std::default::Default;
|
||||
|
||||
fn t<S: Default + Str>() {
|
||||
fn t<S: Default + AsRef<str>>() {
|
||||
let s: S = Default::default();
|
||||
assert_eq!(s.as_slice(), "");
|
||||
assert_eq!(s.as_ref(), "");
|
||||
}
|
||||
|
||||
t::<&str>();
|
||||
|
|
|
@ -624,7 +624,7 @@ fn all<F>(&mut self, mut f: F) -> bool where
|
|||
/// let a = [1, 2, 3, 4, 5];
|
||||
/// let mut it = a.iter();
|
||||
/// assert!(it.any(|x| *x == 3));
|
||||
/// assert_eq!(it.as_slice(), [4, 5]);
|
||||
/// assert_eq!(&it[..], [4, 5]);
|
||||
///
|
||||
/// ```
|
||||
#[inline]
|
||||
|
@ -648,7 +648,7 @@ fn any<F>(&mut self, mut f: F) -> bool where
|
|||
/// let a = [1, 2, 3, 4, 5];
|
||||
/// let mut it = a.iter();
|
||||
/// assert_eq!(it.find(|&x| *x == 3).unwrap(), &3);
|
||||
/// assert_eq!(it.as_slice(), [4, 5]);
|
||||
/// assert_eq!(&it[..], [4, 5]);
|
||||
#[inline]
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
fn find<P>(&mut self, mut predicate: P) -> Option<Self::Item> where
|
||||
|
@ -672,7 +672,7 @@ fn find<P>(&mut self, mut predicate: P) -> Option<Self::Item> where
|
|||
/// let a = [1, 2, 3, 4, 5];
|
||||
/// let mut it = a.iter();
|
||||
/// assert_eq!(it.position(|x| *x == 3).unwrap(), 2);
|
||||
/// assert_eq!(it.as_slice(), [4, 5]);
|
||||
/// assert_eq!(&it[..], [4, 5]);
|
||||
#[inline]
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
fn position<P>(&mut self, mut predicate: P) -> Option<usize> where
|
||||
|
@ -702,7 +702,7 @@ fn position<P>(&mut self, mut predicate: P) -> Option<usize> where
|
|||
/// let a = [1, 2, 2, 4, 5];
|
||||
/// let mut it = a.iter();
|
||||
/// assert_eq!(it.rposition(|x| *x == 2).unwrap(), 2);
|
||||
/// assert_eq!(it.as_slice(), [1, 2]);
|
||||
/// assert_eq!(&it[..], [1, 2]);
|
||||
#[inline]
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
fn rposition<P>(&mut self, mut predicate: P) -> Option<usize> where
|
||||
|
|
|
@ -84,7 +84,7 @@
|
|||
//!
|
||||
//! fn edges(&'a self) -> dot::Edges<'a,Ed> {
|
||||
//! let &Edges(ref edges) = self;
|
||||
//! edges.as_slice().into_cow()
|
||||
//! (&edges[..]).into_cow()
|
||||
//! }
|
||||
//!
|
||||
//! fn source(&self, e: &Ed) -> Nd { let &(s,_) = e; s }
|
||||
|
|
|
@ -198,7 +198,7 @@ fn rand<R: Rng>(other: &mut R) -> ChaChaRng {
|
|||
for word in &mut key {
|
||||
*word = other.gen();
|
||||
}
|
||||
SeedableRng::from_seed(key.as_slice())
|
||||
SeedableRng::from_seed(&key[..])
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -154,7 +154,7 @@ fn next_f64(&mut self) -> f64 {
|
|||
///
|
||||
/// let mut v = [0; 13579];
|
||||
/// thread_rng().fill_bytes(&mut v);
|
||||
/// println!("{:?}", v.as_slice());
|
||||
/// println!("{:?}", v);
|
||||
/// ```
|
||||
fn fill_bytes(&mut self, dest: &mut [u8]) {
|
||||
// this could, in theory, be done by transmuting dest to a
|
||||
|
@ -310,9 +310,9 @@ fn choose<'a, T>(&mut self, values: &'a [T]) -> Option<&'a T> {
|
|||
/// let mut rng = thread_rng();
|
||||
/// let mut y = [1, 2, 3];
|
||||
/// rng.shuffle(&mut y);
|
||||
/// println!("{:?}", y.as_slice());
|
||||
/// println!("{:?}", y);
|
||||
/// rng.shuffle(&mut y);
|
||||
/// println!("{:?}", y.as_slice());
|
||||
/// println!("{:?}", y);
|
||||
/// ```
|
||||
fn shuffle<T>(&mut self, values: &mut [T]) {
|
||||
let mut i = values.len();
|
||||
|
|
|
@ -100,7 +100,7 @@
|
|||
//! let encoded = json::encode(&object).unwrap();
|
||||
//!
|
||||
//! // Deserialize using `json::decode`
|
||||
//! let decoded: TestStruct = json::decode(encoded.as_slice()).unwrap();
|
||||
//! let decoded: TestStruct = json::decode(&encoded[..]).unwrap();
|
||||
//! }
|
||||
//! ```
|
||||
//!
|
||||
|
|
|
@ -1333,7 +1333,7 @@ fn copy_file_ok() {
|
|||
check!(fs::copy(&input, &out));
|
||||
let mut v = Vec::new();
|
||||
check!(check!(File::open(&out)).read_to_end(&mut v));
|
||||
assert_eq!(v.as_slice(), b"hello");
|
||||
assert_eq!(&v[..], b"hello");
|
||||
|
||||
assert_eq!(check!(input.metadata()).permissions(),
|
||||
check!(out.metadata()).permissions());
|
||||
|
@ -1628,7 +1628,7 @@ fn binary_file() {
|
|||
check!(check!(File::create(&tmpdir.join("test"))).write(&bytes));
|
||||
let mut v = Vec::new();
|
||||
check!(check!(File::open(&tmpdir.join("test"))).read_to_end(&mut v));
|
||||
assert!(v == bytes.as_slice());
|
||||
assert!(v == &bytes[..]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
|
|
@ -281,19 +281,19 @@ fn read_to_end() {
|
|||
#[test]
|
||||
fn test_slice_reader() {
|
||||
let in_buf = vec![0, 1, 2, 3, 4, 5, 6, 7];
|
||||
let mut reader = &mut in_buf.as_slice();
|
||||
let mut reader = &mut &in_buf[..];
|
||||
let mut buf = [];
|
||||
assert_eq!(reader.read(&mut buf), Ok(0));
|
||||
let mut buf = [0];
|
||||
assert_eq!(reader.read(&mut buf), Ok(1));
|
||||
assert_eq!(reader.len(), 7);
|
||||
let b: &[_] = &[0];
|
||||
assert_eq!(buf.as_slice(), b);
|
||||
assert_eq!(buf, b);
|
||||
let mut buf = [0; 4];
|
||||
assert_eq!(reader.read(&mut buf), Ok(4));
|
||||
assert_eq!(reader.len(), 3);
|
||||
let b: &[_] = &[1, 2, 3, 4];
|
||||
assert_eq!(buf.as_slice(), b);
|
||||
assert_eq!(buf, b);
|
||||
assert_eq!(reader.read(&mut buf), Ok(3));
|
||||
let b: &[_] = &[5, 6, 7];
|
||||
assert_eq!(&buf[..3], b);
|
||||
|
@ -303,7 +303,7 @@ fn test_slice_reader() {
|
|||
#[test]
|
||||
fn test_buf_reader() {
|
||||
let in_buf = vec![0, 1, 2, 3, 4, 5, 6, 7];
|
||||
let mut reader = Cursor::new(in_buf.as_slice());
|
||||
let mut reader = Cursor::new(&in_buf[..]);
|
||||
let mut buf = [];
|
||||
assert_eq!(reader.read(&mut buf), Ok(0));
|
||||
assert_eq!(reader.position(), 0);
|
||||
|
|
|
@ -1639,7 +1639,7 @@ fn binary_file() {
|
|||
|
||||
check!(File::create(&tmpdir.join("test")).write(&bytes));
|
||||
let actual = check!(File::open(&tmpdir.join("test")).read_to_end());
|
||||
assert!(actual == bytes.as_slice());
|
||||
assert!(actual == &bytes[..]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
|
|
@ -744,7 +744,7 @@ fn bench_buf_writer(b: &mut Bencher) {
|
|||
wr.write(&[5; 10]).unwrap();
|
||||
}
|
||||
}
|
||||
assert_eq!(buf.as_slice(), [5; 100].as_slice());
|
||||
assert_eq!(buf.as_ref(), [5; 100].as_ref());
|
||||
});
|
||||
}
|
||||
|
||||
|
|
|
@ -435,7 +435,7 @@ fn from_str(s: &str) -> Result<SocketAddr, ParseError> {
|
|||
/// let tcp_l = TcpListener::bind("localhost:12345");
|
||||
///
|
||||
/// let mut udp_s = UdpSocket::bind(("127.0.0.1", 23451)).unwrap();
|
||||
/// udp_s.send_to([7, 7, 7].as_slice(), (Ipv4Addr(127, 0, 0, 1), 23451));
|
||||
/// udp_s.send_to([7, 7, 7].as_ref(), (Ipv4Addr(127, 0, 0, 1), 23451));
|
||||
/// }
|
||||
/// ```
|
||||
pub trait ToSocketAddr {
|
||||
|
|
|
@ -376,8 +376,8 @@ pub fn spawn(&self) -> IoResult<Process> {
|
|||
/// };
|
||||
///
|
||||
/// println!("status: {}", output.status);
|
||||
/// println!("stdout: {}", String::from_utf8_lossy(output.output.as_slice()));
|
||||
/// println!("stderr: {}", String::from_utf8_lossy(output.error.as_slice()));
|
||||
/// println!("stdout: {}", String::from_utf8_lossy(output.output.as_ref()));
|
||||
/// println!("stderr: {}", String::from_utf8_lossy(output.error.as_ref()));
|
||||
/// ```
|
||||
pub fn output(&self) -> IoResult<ProcessOutput> {
|
||||
self.spawn().and_then(|p| p.wait_with_output())
|
||||
|
|
|
@ -311,7 +311,7 @@ pub fn split_paths<T: BytesContainer>(unparsed: T) -> Vec<Path> {
|
|||
/// let key = "PATH";
|
||||
/// let mut paths = os::getenv_as_bytes(key).map_or(Vec::new(), os::split_paths);
|
||||
/// paths.push(Path::new("/home/xyz/bin"));
|
||||
/// os::setenv(key, os::join_paths(paths.as_slice()).unwrap());
|
||||
/// os::setenv(key, os::join_paths(&paths[..]).unwrap());
|
||||
/// ```
|
||||
#[unstable(feature = "os")]
|
||||
pub fn join_paths<T: BytesContainer>(paths: &[T]) -> Result<Vec<u8>, &'static str> {
|
||||
|
|
|
@ -678,7 +678,7 @@ fn test_process_output_fail_to_start() {
|
|||
fn test_process_output_output() {
|
||||
let Output {status, stdout, stderr}
|
||||
= Command::new("echo").arg("hello").output().unwrap();
|
||||
let output_str = str::from_utf8(stdout.as_slice()).unwrap();
|
||||
let output_str = str::from_utf8(&stdout[..]).unwrap();
|
||||
|
||||
assert!(status.success());
|
||||
assert_eq!(output_str.trim().to_string(), "hello");
|
||||
|
@ -720,7 +720,7 @@ fn test_wait_with_output_once() {
|
|||
let prog = Command::new("echo").arg("hello").stdout(Stdio::piped())
|
||||
.spawn().unwrap();
|
||||
let Output {status, stdout, stderr} = prog.wait_with_output().unwrap();
|
||||
let output_str = str::from_utf8(stdout.as_slice()).unwrap();
|
||||
let output_str = str::from_utf8(&stdout[..]).unwrap();
|
||||
|
||||
assert!(status.success());
|
||||
assert_eq!(output_str.trim().to_string(), "hello");
|
||||
|
@ -855,7 +855,7 @@ fn test_override_env() {
|
|||
cmd.env("PATH", &p);
|
||||
}
|
||||
let result = cmd.output().unwrap();
|
||||
let output = String::from_utf8_lossy(result.stdout.as_slice()).to_string();
|
||||
let output = String::from_utf8_lossy(&result.stdout[..]).to_string();
|
||||
|
||||
assert!(output.contains("RUN_TEST_NEW_ENV=123"),
|
||||
"didn't find RUN_TEST_NEW_ENV inside of:\n\n{}", output);
|
||||
|
@ -864,7 +864,7 @@ fn test_override_env() {
|
|||
#[test]
|
||||
fn test_add_to_env() {
|
||||
let result = env_cmd().env("RUN_TEST_NEW_ENV", "123").output().unwrap();
|
||||
let output = String::from_utf8_lossy(result.stdout.as_slice()).to_string();
|
||||
let output = String::from_utf8_lossy(&result.stdout[..]).to_string();
|
||||
|
||||
assert!(output.contains("RUN_TEST_NEW_ENV=123"),
|
||||
"didn't find RUN_TEST_NEW_ENV inside of:\n\n{}", output);
|
||||
|
|
|
@ -77,6 +77,6 @@ fn main() {
|
|||
let mut tc = TestCalls { count: 1 };
|
||||
// we should never get use this filename, but lets make sure they are valid args.
|
||||
let args = vec!["compiler-calls".to_string(), "foo.rs".to_string()];
|
||||
rustc_driver::run_compiler(args.as_slice(), &mut tc);
|
||||
rustc_driver::run_compiler(&args[..], &mut tc);
|
||||
assert!(tc.count == 30);
|
||||
}
|
||||
|
|
|
@ -29,7 +29,7 @@ fn foo<'a>(map: RefCell<HashMap<&'static str, &'a [u8]>>) {
|
|||
// supposed to match the lifetime `'a`) ...
|
||||
fn foo<'a>(map: RefCell<HashMap<&'static str, &'a [u8]>>) {
|
||||
let one = [1];
|
||||
assert_eq!(map.borrow().get("one"), Some(&one.as_slice()));
|
||||
assert_eq!(map.borrow().get("one"), Some(&&one[..]));
|
||||
}
|
||||
|
||||
#[cfg(all(not(cannot_use_this_yet),not(cannot_use_this_yet_either)))]
|
||||
|
|
Loading…
Reference in a new issue