user0/rust
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Auto merge of #58081 - Centril:liballoc-2018, r=oli-obk

Browse source 
Transition liballoc to Rust 2018

This transitions liballoc to Rust 2018 edition and applies relevant idiom lints.
I also did a small bit of drive-by cleanup along the way.

r? @oli-obk

I started with liballoc since it seemed easiest. In particular, adding `edition = "2018"` to libcore gave me way too many errors due to stdsimd. Ideally we should be able to continue this crate-by-crate until all crates use 2018.
This commit is contained in:
bors 2019-02-03 18:40:23 +00:00
commit 4f4f4a40b6
34 changed files with 359 additions and 392 deletions
Download patch file Download diff file Expand all files Collapse all files

1
src/liballoc/Cargo.toml
View file

@ -4,6 +4,7 @@ name = "alloc"
version = "0.0.0"
autotests = false
autobenches = false
edition = "2018"
[lib]
name = "alloc"

6
src/liballoc/alloc.rs
View file

@ -227,9 +227,9 @@ pub fn handle_alloc_error(layout: Layout) -> ! {
#[cfg(test)]
mod tests {
extern crate test;
use self::test::Bencher;
use boxed::Box;
use alloc::{Global, Alloc, Layout, handle_alloc_error};
use test::Bencher;
use crate::boxed::Box;
use crate::alloc::{Global, Alloc, Layout, handle_alloc_error};
#[test]
fn allocate_zeroed() {

1
src/liballoc/benches/btree/map.rs
View file

@ -1,6 +1,7 @@
use std::iter::Iterator;
use std::vec::Vec;
use std::collections::BTreeMap;
use rand::{Rng, seq::SliceRandom, thread_rng};
use test::{Bencher, black_box};

6
src/liballoc/benches/slice.rs
View file

@ -1,8 +1,6 @@
use rand::{thread_rng};
use std::mem;
use std::ptr;
use std::{mem, ptr};
use rand::{Rng, SeedableRng};
use rand::{thread_rng, Rng, SeedableRng};
use rand::distributions::{Standard, Alphanumeric};
use rand_xorshift::XorShiftRng;
use test::{Bencher, black_box};

34
src/liballoc/borrow.rs
View file

@ -6,14 +6,14 @@ use core::cmp::Ordering;
use core::hash::{Hash, Hasher};
use core::ops::{Add, AddAssign, Deref};
use fmt;
use string::String;
use self::Cow::*;
#[stable(feature = "rust1", since = "1.0.0")]
pub use core::borrow::{Borrow, BorrowMut};
use crate::fmt;
use crate::string::String;
use Cow::*;
#[stable(feature = "rust1", since = "1.0.0")]
impl<'a, B: ?Sized> Borrow<B> for Cow<'a, B>
where B: ToOwned,
@ -182,9 +182,7 @@ pub enum Cow<'a, B: ?Sized + 'a>
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<'a, B: ?Sized> Clone for Cow<'a, B>
where B: ToOwned
{
impl<'a, B: ?Sized + ToOwned> Clone for Cow<'a, B> {
fn clone(&self) -> Cow<'a, B> {
match *self {
Borrowed(b) => Borrowed(b),
@ -207,9 +205,7 @@ impl<'a, B: ?Sized> Clone for Cow<'a, B>
}
}
impl<'a, B: ?Sized> Cow<'a, B>
where B: ToOwned
{
impl<B: ?Sized + ToOwned> Cow<'_, B> {
/// Acquires a mutable reference to the owned form of the data.
///
/// Clones the data if it is not already owned.
@ -285,9 +281,7 @@ impl<'a, B: ?Sized> Cow<'a, B>
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<'a, B: ?Sized> Deref for Cow<'a, B>
where B: ToOwned
{
impl<B: ?Sized + ToOwned> Deref for Cow<'_, B> {
type Target = B;
fn deref(&self) -> &B {
@ -299,7 +293,7 @@ impl<'a, B: ?Sized> Deref for Cow<'a, B>
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<'a, B: ?Sized> Eq for Cow<'a, B> where B: Eq + ToOwned {}
impl<B: ?Sized> Eq for Cow<'_, B> where B: Eq + ToOwned {}
#[stable(feature = "rust1", since = "1.0.0")]
impl<'a, B: ?Sized> Ord for Cow<'a, B>
@ -333,11 +327,11 @@ impl<'a, B: ?Sized> PartialOrd for Cow<'a, B>
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<'a, B: ?Sized> fmt::Debug for Cow<'a, B>
impl<B: ?Sized> fmt::Debug for Cow<'_, B>
where B: fmt::Debug + ToOwned,
<B as ToOwned>::Owned: fmt::Debug
{
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match *self {
Borrowed(ref b) => fmt::Debug::fmt(b, f),
Owned(ref o) => fmt::Debug::fmt(o, f),
@ -346,11 +340,11 @@ impl<'a, B: ?Sized> fmt::Debug for Cow<'a, B>
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<'a, B: ?Sized> fmt::Display for Cow<'a, B>
impl<B: ?Sized> fmt::Display for Cow<'_, B>
where B: fmt::Display + ToOwned,
<B as ToOwned>::Owned: fmt::Display
{
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match *self {
Borrowed(ref b) => fmt::Display::fmt(b, f),
Owned(ref o) => fmt::Display::fmt(o, f),
@ -380,7 +374,7 @@ impl<'a, B: ?Sized> Hash for Cow<'a, B>
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<'a, T: ?Sized + ToOwned> AsRef<T> for Cow<'a, T> {
impl<T: ?Sized + ToOwned> AsRef<T> for Cow<'_, T> {
fn as_ref(&self) -> &T {
self
}

16
src/liballoc/boxed.rs
View file

@ -73,9 +73,9 @@ use core::ops::{
use core::ptr::{self, NonNull, Unique};
use core::task::{LocalWaker, Poll};
use vec::Vec;
use raw_vec::RawVec;
use str::from_boxed_utf8_unchecked;
use crate::vec::Vec;
use crate::raw_vec::RawVec;
use crate::str::from_boxed_utf8_unchecked;
/// A pointer type for heap allocation.
///
@ -603,21 +603,21 @@ impl Box<dyn Any + Send> {
#[stable(feature = "rust1", since = "1.0.0")]
impl<T: fmt::Display + ?Sized> fmt::Display for Box<T> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
fmt::Display::fmt(&**self, f)
}
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<T: fmt::Debug + ?Sized> fmt::Debug for Box<T> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
fmt::Debug::fmt(&**self, f)
}
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<T: ?Sized> fmt::Pointer for Box<T> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
// It's not possible to extract the inner Uniq directly from the Box,
// instead we cast it to a *const which aliases the Unique
let ptr: *const T = &**self;
@ -737,7 +737,7 @@ impl<A, F> FnBox<A> for F
#[unstable(feature = "fnbox",
reason = "will be deprecated if and when `Box<FnOnce>` becomes usable", issue = "28796")]
impl<'a, A, R> FnOnce<A> for Box<dyn FnBox<A, Output = R> + 'a> {
impl<A, R> FnOnce<A> for Box<dyn FnBox<A, Output = R> + '_> {
type Output = R;
extern "rust-call" fn call_once(self, args: A) -> R {
@ -747,7 +747,7 @@ impl<'a, A, R> FnOnce<A> for Box<dyn FnBox<A, Output = R> + 'a> {
#[unstable(feature = "fnbox",
reason = "will be deprecated if and when `Box<FnOnce>` becomes usable", issue = "28796")]
impl<'a, A, R> FnOnce<A> for Box<dyn FnBox<A, Output = R> + Send + 'a> {
impl<A, R> FnOnce<A> for Box<dyn FnBox<A, Output = R> + Send + '_> {
type Output = R;
extern "rust-call" fn call_once(self, args: A) -> R {

42
src/liballoc/collections/binary_heap.rs
View file

@ -151,8 +151,8 @@ use core::mem::{swap, size_of, ManuallyDrop};
use core::ptr;
use core::fmt;
use slice;
use vec::{self, Vec};
use crate::slice;
use crate::vec::{self, Vec};
use super::SpecExtend;
@ -227,8 +227,8 @@ pub struct PeekMut<'a, T: 'a + Ord> {
}
#[stable(feature = "collection_debug", since = "1.17.0")]
impl<'a, T: Ord + fmt::Debug> fmt::Debug for PeekMut<'a, T> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
impl<T: Ord + fmt::Debug> fmt::Debug for PeekMut<'_, T> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_tuple("PeekMut")
.field(&self.heap.data[0])
.finish()
@ -236,7 +236,7 @@ impl<'a, T: Ord + fmt::Debug> fmt::Debug for PeekMut<'a, T> {
}
#[stable(feature = "binary_heap_peek_mut", since = "1.12.0")]
impl<'a, T: Ord> Drop for PeekMut<'a, T> {
impl<T: Ord> Drop for PeekMut<'_, T> {
fn drop(&mut self) {
if self.sift {
self.heap.sift_down(0);
@ -245,7 +245,7 @@ impl<'a, T: Ord> Drop for PeekMut<'a, T> {
}
#[stable(feature = "binary_heap_peek_mut", since = "1.12.0")]
impl<'a, T: Ord> Deref for PeekMut<'a, T> {
impl<T: Ord> Deref for PeekMut<'_, T> {
type Target = T;
fn deref(&self) -> &T {
&self.heap.data[0]
@ -253,7 +253,7 @@ impl<'a, T: Ord> Deref for PeekMut<'a, T> {
}
#[stable(feature = "binary_heap_peek_mut", since = "1.12.0")]
impl<'a, T: Ord> DerefMut for PeekMut<'a, T> {
impl<T: Ord> DerefMut for PeekMut<'_, T> {
fn deref_mut(&mut self) -> &mut T {
&mut self.heap.data[0]
}
@ -291,7 +291,7 @@ impl<T: Ord> Default for BinaryHeap<T> {
#[stable(feature = "binaryheap_debug", since = "1.4.0")]
impl<T: fmt::Debug + Ord> fmt::Debug for BinaryHeap<T> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_list().entries(self.iter()).finish()
}
}
@ -349,7 +349,7 @@ impl<T: Ord> BinaryHeap<T> {
/// }
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
pub fn iter(&self) -> Iter<T> {
pub fn iter(&self) -> Iter<'_, T> {
Iter { iter: self.data.iter() }
}
@ -400,7 +400,7 @@ impl<T: Ord> BinaryHeap<T> {
/// assert_eq!(heap.peek(), Some(&2));
/// ```
#[stable(feature = "binary_heap_peek_mut", since = "1.12.0")]
pub fn peek_mut(&mut self) -> Option<PeekMut<T>> {
pub fn peek_mut(&mut self) -> Option<PeekMut<'_, T>> {
if self.is_empty() {
None
} else {
@ -761,7 +761,7 @@ impl<T: Ord> BinaryHeap<T> {
/// ```
#[inline]
#[stable(feature = "drain", since = "1.6.0")]
pub fn drain(&mut self) -> Drain<T> {
pub fn drain(&mut self) -> Drain<'_, T> {
Drain { iter: self.data.drain(..) }
}
@ -908,7 +908,7 @@ impl<'a, T> Hole<'a, T> {
}
}
impl<'a, T> Drop for Hole<'a, T> {
impl<T> Drop for Hole<'_, T> {
#[inline]
fn drop(&mut self) {
// fill the hole again
@ -932,8 +932,8 @@ pub struct Iter<'a, T: 'a> {
}
#[stable(feature = "collection_debug", since = "1.17.0")]
impl<'a, T: 'a + fmt::Debug> fmt::Debug for Iter<'a, T> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
impl<T: fmt::Debug> fmt::Debug for Iter<'_, T> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_tuple("Iter")
.field(&self.iter.as_slice())
.finish()
@ -972,14 +972,14 @@ impl<'a, T> DoubleEndedIterator for Iter<'a, T> {
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<'a, T> ExactSizeIterator for Iter<'a, T> {
impl<T> ExactSizeIterator for Iter<'_, T> {
fn is_empty(&self) -> bool {
self.iter.is_empty()
}
}
#[stable(feature = "fused", since = "1.26.0")]
impl<'a, T> FusedIterator for Iter<'a, T> {}
impl<T> FusedIterator for Iter<'_, T> {}
/// An owning iterator over the elements of a `BinaryHeap`.
///
@ -996,7 +996,7 @@ pub struct IntoIter<T> {
#[stable(feature = "collection_debug", since = "1.17.0")]
impl<T: fmt::Debug> fmt::Debug for IntoIter<T> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_tuple("IntoIter")
.field(&self.iter.as_slice())
.finish()
@ -1050,7 +1050,7 @@ pub struct Drain<'a, T: 'a> {
}
#[stable(feature = "drain", since = "1.6.0")]
impl<'a, T: 'a> Iterator for Drain<'a, T> {
impl<T> Iterator for Drain<'_, T> {
type Item = T;
#[inline]
@ -1065,7 +1065,7 @@ impl<'a, T: 'a> Iterator for Drain<'a, T> {
}
#[stable(feature = "drain", since = "1.6.0")]
impl<'a, T: 'a> DoubleEndedIterator for Drain<'a, T> {
impl<T> DoubleEndedIterator for Drain<'_, T> {
#[inline]
fn next_back(&mut self) -> Option<T> {
self.iter.next_back()
@ -1073,14 +1073,14 @@ impl<'a, T: 'a> DoubleEndedIterator for Drain<'a, T> {
}
#[stable(feature = "drain", since = "1.6.0")]
impl<'a, T: 'a> ExactSizeIterator for Drain<'a, T> {
impl<T> ExactSizeIterator for Drain<'_, T> {
fn is_empty(&self) -> bool {
self.iter.is_empty()
}
}
#[stable(feature = "fused", since = "1.26.0")]
impl<'a, T: 'a> FusedIterator for Drain<'a, T> {}
impl<T> FusedIterator for Drain<'_, T> {}
#[stable(feature = "binary_heap_extras_15", since = "1.5.0")]
impl<T: Ord> From<Vec<T>> for BinaryHeap<T> {

94
src/liballoc/collections/btree/map.rs
View file

@ -1,23 +1,18 @@
use core::borrow::Borrow;
use core::cmp::Ordering;
use core::fmt::Debug;
use core::hash::{Hash, Hasher};
use core::iter::{FromIterator, Peekable, FusedIterator};
use core::marker::PhantomData;
use core::ops::Bound::{Excluded, Included, Unbounded};
use core::ops::Index;
use core::ops::RangeBounds;
use core::ops::{Index, RangeBounds};
use core::{fmt, intrinsics, mem, ptr};
use borrow::Borrow;
use super::node::{self, Handle, NodeRef, marker, InsertResult::*, ForceResult::*};
use super::search::{self, SearchResult::*};
use super::node::{self, Handle, NodeRef, marker};
use super::search;
use super::node::InsertResult::*;
use super::node::ForceResult::*;
use super::search::SearchResult::*;
use self::UnderflowResult::*;
use self::Entry::*;
use UnderflowResult::*;
use Entry::*;
/// A map based on a B-Tree.
///
@ -248,7 +243,7 @@ impl<K, Q: ?Sized> super::Recover<Q> for BTreeMap<K, ()>
fn replace(&mut self, key: K) -> Option<K> {
self.ensure_root_is_owned();
match search::search_tree::<marker::Mut, K, (), K>(self.root.as_mut(), &key) {
match search::search_tree::<marker::Mut<'_>, K, (), K>(self.root.as_mut(), &key) {
Found(handle) => Some(mem::replace(handle.into_kv_mut().0, key)),
GoDown(handle) => {
VacantEntry {
@ -278,8 +273,8 @@ pub struct Iter<'a, K: 'a, V: 'a> {
}
#[stable(feature = "collection_debug", since = "1.17.0")]
impl<'a, K: 'a + fmt::Debug, V: 'a + fmt::Debug> fmt::Debug for Iter<'a, K, V> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
impl<K: fmt::Debug, V: fmt::Debug> fmt::Debug for Iter<'_, K, V> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_list().entries(self.clone()).finish()
}
}
@ -314,7 +309,7 @@ pub struct IntoIter<K, V> {
#[stable(feature = "collection_debug", since = "1.17.0")]
impl<K: fmt::Debug, V: fmt::Debug> fmt::Debug for IntoIter<K, V> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let range = Range {
front: self.front.reborrow(),
back: self.back.reborrow(),
@ -336,8 +331,8 @@ pub struct Keys<'a, K: 'a, V: 'a> {
}
#[stable(feature = "collection_debug", since = "1.17.0")]
impl<'a, K: 'a + fmt::Debug, V: 'a> fmt::Debug for Keys<'a, K, V> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
impl<K: fmt::Debug, V> fmt::Debug for Keys<'_, K, V> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_list().entries(self.clone()).finish()
}
}
@ -355,8 +350,8 @@ pub struct Values<'a, K: 'a, V: 'a> {
}
#[stable(feature = "collection_debug", since = "1.17.0")]
impl<'a, K: 'a, V: 'a + fmt::Debug> fmt::Debug for Values<'a, K, V> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
impl<K, V: fmt::Debug> fmt::Debug for Values<'_, K, V> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_list().entries(self.clone()).finish()
}
}
@ -388,8 +383,8 @@ pub struct Range<'a, K: 'a, V: 'a> {
}
#[stable(feature = "collection_debug", since = "1.17.0")]
impl<'a, K: 'a + fmt::Debug, V: 'a + fmt::Debug> fmt::Debug for Range<'a, K, V> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
impl<K: fmt::Debug, V: fmt::Debug> fmt::Debug for Range<'_, K, V> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_list().entries(self.clone()).finish()
}
}
@ -411,8 +406,8 @@ pub struct RangeMut<'a, K: 'a, V: 'a> {
}
#[stable(feature = "collection_debug", since = "1.17.0")]
impl<'a, K: 'a + fmt::Debug, V: 'a + fmt::Debug> fmt::Debug for RangeMut<'a, K, V> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
impl<K: fmt::Debug, V: fmt::Debug> fmt::Debug for RangeMut<'_, K, V> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let range = Range {
front: self.front.reborrow(),
back: self.back.reborrow(),
@ -441,8 +436,8 @@ pub enum Entry<'a, K: 'a, V: 'a> {
}
#[stable(feature= "debug_btree_map", since = "1.12.0")]
impl<'a, K: 'a + Debug + Ord, V: 'a + Debug> Debug for Entry<'a, K, V> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
impl<K: Debug + Ord, V: Debug> Debug for Entry<'_, K, V> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match *self {
Vacant(ref v) => f.debug_tuple("Entry")
.field(v)
@ -469,8 +464,8 @@ pub struct VacantEntry<'a, K: 'a, V: 'a> {
}
#[stable(feature= "debug_btree_map", since = "1.12.0")]
impl<'a, K: 'a + Debug + Ord, V: 'a> Debug for VacantEntry<'a, K, V> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
impl<K: Debug + Ord, V> Debug for VacantEntry<'_, K, V> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_tuple("VacantEntry")
.field(self.key())
.finish()
@ -492,8 +487,8 @@ pub struct OccupiedEntry<'a, K: 'a, V: 'a> {
}
#[stable(feature= "debug_btree_map", since = "1.12.0")]
impl<'a, K: 'a + Debug + Ord, V: 'a + Debug> Debug for OccupiedEntry<'a, K, V> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
impl<K: Debug + Ord, V: Debug> Debug for OccupiedEntry<'_, K, V> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("OccupiedEntry")
.field("key", self.key())
.field("value", self.get())
@ -817,7 +812,7 @@ impl<K: Ord, V> BTreeMap<K, V> {
/// assert_eq!(Some((&5, &"b")), map.range(4..).next());
/// ```
#[stable(feature = "btree_range", since = "1.17.0")]
pub fn range<T: ?Sized, R>(&self, range: R) -> Range<K, V>
pub fn range<T: ?Sized, R>(&self, range: R) -> Range<'_, K, V>
where T: Ord, K: Borrow<T>, R: RangeBounds<T>
{
let root1 = self.root.as_ref();
@ -858,7 +853,7 @@ impl<K: Ord, V> BTreeMap<K, V> {
/// }
/// ```
#[stable(feature = "btree_range", since = "1.17.0")]
pub fn range_mut<T: ?Sized, R>(&mut self, range: R) -> RangeMut<K, V>
pub fn range_mut<T: ?Sized, R>(&mut self, range: R) -> RangeMut<'_, K, V>
where T: Ord, K: Borrow<T>, R: RangeBounds<T>
{
let root1 = self.root.as_mut();
@ -891,7 +886,7 @@ impl<K: Ord, V> BTreeMap<K, V> {
/// assert_eq!(count["a"], 3);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
pub fn entry(&mut self, key: K) -> Entry<K, V> {
pub fn entry(&mut self, key: K) -> Entry<'_, K, V> {
// FIXME(@porglezomp) Avoid allocating if we don't insert
self.ensure_root_is_owned();
match search::search_tree(self.root.as_mut(), &key) {
@ -1201,7 +1196,7 @@ impl<'a, K: 'a, V: 'a> Iterator for Iter<'a, K, V> {
}
#[stable(feature = "fused", since = "1.26.0")]
impl<'a, K, V> FusedIterator for Iter<'a, K, V> {}
impl<K, V> FusedIterator for Iter<'_, K, V> {}
#[stable(feature = "rust1", since = "1.0.0")]
impl<'a, K: 'a, V: 'a> DoubleEndedIterator for Iter<'a, K, V> {
@ -1216,7 +1211,7 @@ impl<'a, K: 'a, V: 'a> DoubleEndedIterator for Iter<'a, K, V> {
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<'a, K: 'a, V: 'a> ExactSizeIterator for Iter<'a, K, V> {
impl<K, V> ExactSizeIterator for Iter<'_, K, V> {
fn len(&self) -> usize {
self.length
}
@ -1273,14 +1268,14 @@ impl<'a, K: 'a, V: 'a> DoubleEndedIterator for IterMut<'a, K, V> {
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<'a, K: 'a, V: 'a> ExactSizeIterator for IterMut<'a, K, V> {
impl<K, V> ExactSizeIterator for IterMut<'_, K, V> {
fn len(&self) -> usize {
self.length
}
}
#[stable(feature = "fused", since = "1.26.0")]
impl<'a, K, V> FusedIterator for IterMut<'a, K, V> {}
impl<K, V> FusedIterator for IterMut<'_, K, V> {}
#[stable(feature = "rust1", since = "1.0.0")]
impl<K, V> IntoIterator for BTreeMap<K, V> {
@ -1436,14 +1431,14 @@ impl<'a, K, V> DoubleEndedIterator for Keys<'a, K, V> {
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<'a, K, V> ExactSizeIterator for Keys<'a, K, V> {
impl<K, V> ExactSizeIterator for Keys<'_, K, V> {
fn len(&self) -> usize {
self.inner.len()
}
}
#[stable(feature = "fused", since = "1.26.0")]
impl<'a, K, V> FusedIterator for Keys<'a, K, V> {}
impl<K, V> FusedIterator for Keys<'_, K, V> {}
#[stable(feature = "rust1", since = "1.0.0")]
impl<'a, K, V> Clone for Keys<'a, K, V> {
@ -1473,14 +1468,14 @@ impl<'a, K, V> DoubleEndedIterator for Values<'a, K, V> {
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<'a, K, V> ExactSizeIterator for Values<'a, K, V> {
impl<K, V> ExactSizeIterator for Values<'_, K, V> {
fn len(&self) -> usize {
self.inner.len()
}
}
#[stable(feature = "fused", since = "1.26.0")]
impl<'a, K, V> FusedIterator for Values<'a, K, V> {}
impl<K, V> FusedIterator for Values<'_, K, V> {}
#[stable(feature = "rust1", since = "1.0.0")]
impl<'a, K, V> Clone for Values<'a, K, V> {
@ -1523,15 +1518,14 @@ impl<'a, K, V> DoubleEndedIterator for ValuesMut<'a, K, V> {
}
#[stable(feature = "map_values_mut", since = "1.10.0")]
impl<'a, K, V> ExactSizeIterator for ValuesMut<'a, K, V> {
impl<K, V> ExactSizeIterator for ValuesMut<'_, K, V> {
fn len(&self) -> usize {
self.inner.len()
}
}
#[stable(feature = "fused", since = "1.26.0")]
impl<'a, K, V> FusedIterator for ValuesMut<'a, K, V> {}
impl<K, V> FusedIterator for ValuesMut<'_, K, V> {}
impl<'a, K, V> Range<'a, K, V> {
unsafe fn next_unchecked(&mut self) -> (&'a K, &'a V) {
@ -1609,7 +1603,7 @@ impl<'a, K, V> Range<'a, K, V> {
}
#[stable(feature = "fused", since = "1.26.0")]
impl<'a, K, V> FusedIterator for Range<'a, K, V> {}
impl<K, V> FusedIterator for Range<'_, K, V> {}
#[stable(feature = "btree_range", since = "1.17.0")]
impl<'a, K, V> Clone for Range<'a, K, V> {
@ -1678,7 +1672,7 @@ impl<'a, K, V> DoubleEndedIterator for RangeMut<'a, K, V> {
}
#[stable(feature = "fused", since = "1.26.0")]
impl<'a, K, V> FusedIterator for RangeMut<'a, K, V> {}
impl<K, V> FusedIterator for RangeMut<'_, K, V> {}
impl<'a, K, V> RangeMut<'a, K, V> {
unsafe fn next_back_unchecked(&mut self) -> (&'a K, &'a mut V) {
@ -1783,13 +1777,13 @@ impl<K: Ord, V: Ord> Ord for BTreeMap<K, V> {
#[stable(feature = "rust1", since = "1.0.0")]
impl<K: Debug, V: Debug> Debug for BTreeMap<K, V> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_map().entries(self.iter()).finish()
}
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<'a, K: Ord, Q: ?Sized, V> Index<&'a Q> for BTreeMap<K, V>
impl<K: Ord, Q: ?Sized, V> Index<&Q> for BTreeMap<K, V>
where K: Borrow<Q>,
Q: Ord
{
@ -1940,7 +1934,7 @@ impl<K, V> BTreeMap<K, V> {
/// assert_eq!((*first_key, *first_value), (1, "a"));
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
pub fn iter(&self) -> Iter<K, V> {
pub fn iter(&self) -> Iter<'_, K, V> {
Iter {
range: Range {
front: first_leaf_edge(self.root.as_ref()),
@ -1972,7 +1966,7 @@ impl<K, V> BTreeMap<K, V> {
/// }
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
pub fn iter_mut(&mut self) -> IterMut<K, V> {
pub fn iter_mut(&mut self) -> IterMut<'_, K, V> {
let root1 = self.root.as_mut();
let root2 = unsafe { ptr::read(&root1) };
IterMut {
@ -2049,7 +2043,7 @@ impl<K, V> BTreeMap<K, V> {
/// String::from("goodbye!")]);
/// ```
#[stable(feature = "map_values_mut", since = "1.10.0")]
pub fn values_mut(&mut self) -> ValuesMut<K, V> {
pub fn values_mut(&mut self) -> ValuesMut<'_, K, V> {
ValuesMut { inner: self.iter_mut() }
}

24
src/liballoc/collections/btree/node.rs
View file

@ -36,8 +36,8 @@ use core::mem::{self, MaybeUninit};
use core::ptr::{self, Unique, NonNull};
use core::slice;
use alloc::{Global, Alloc, Layout};
use boxed::Box;
use crate::alloc::{Global, Alloc, Layout};
use crate::boxed::Box;
const B: usize = 6;
pub const MIN_LEN: usize = B - 1;
@ -226,7 +226,7 @@ impl<K, V> Root<K, V> {
}
pub fn as_ref(&self)
-> NodeRef<marker::Immut, K, V, marker::LeafOrInternal> {
-> NodeRef<marker::Immut<'_>, K, V, marker::LeafOrInternal> {
NodeRef {
height: self.height,
node: self.node.as_ptr(),
@ -236,7 +236,7 @@ impl<K, V> Root<K, V> {
}
pub fn as_mut(&mut self)
-> NodeRef<marker::Mut, K, V, marker::LeafOrInternal> {
-> NodeRef<marker::Mut<'_>, K, V, marker::LeafOrInternal> {
NodeRef {
height: self.height,
node: self.node.as_ptr(),
@ -258,7 +258,7 @@ impl<K, V> Root<K, V> {
/// Adds a new internal node with a single edge, pointing to the previous root, and make that
/// new node the root. This increases the height by 1 and is the opposite of `pop_level`.
pub fn push_level(&mut self)
-> NodeRef<marker::Mut, K, V, marker::Internal> {
-> NodeRef<marker::Mut<'_>, K, V, marker::Internal> {
debug_assert!(!self.is_shared_root());
let mut new_node = Box::new(unsafe { InternalNode::new() });
new_node.edges[0].set(unsafe { BoxedNode::from_ptr(self.node.as_ptr()) });
@ -531,7 +531,7 @@ impl<'a, K, V, Type> NodeRef<marker::Mut<'a>, K, V, Type> {
/// Unsafely asserts to the compiler some static information about whether this
/// node is a `Leaf`.
unsafe fn cast_unchecked<NewType>(&mut self)
-> NodeRef<marker::Mut, K, V, NewType> {
-> NodeRef<marker::Mut<'_>, K, V, NewType> {
NodeRef {
height: self.height,
@ -551,7 +551,7 @@ impl<'a, K, V, Type> NodeRef<marker::Mut<'a>, K, V, Type> {
/// of a reborrowed handle, out of bounds.
// FIXME(@gereeter) consider adding yet another type parameter to `NodeRef` that restricts
// the use of `ascend` and `into_root_mut` on reborrowed pointers, preventing this unsafety.
unsafe fn reborrow_mut(&mut self) -> NodeRef<marker::Mut, K, V, Type> {
unsafe fn reborrow_mut(&mut self) -> NodeRef<marker::Mut<'_>, K, V, Type> {
NodeRef {
height: self.height,
node: self.node,
@ -928,7 +928,7 @@ impl<BorrowType, K, V, NodeType, HandleType>
/// Temporarily takes out another, immutable handle on the same location.
pub fn reborrow(&self)
-> Handle<NodeRef<marker::Immut, K, V, NodeType>, HandleType> {
-> Handle<NodeRef<marker::Immut<'_>, K, V, NodeType>, HandleType> {
// We can't use Handle::new_kv or Handle::new_edge because we don't know our type
Handle {
@ -953,7 +953,7 @@ impl<'a, K, V, NodeType, HandleType>
// FIXME(@gereeter) consider adding yet another type parameter to `NodeRef` that restricts
// the use of `ascend` and `into_root_mut` on reborrowed pointers, preventing this unsafety.
pub unsafe fn reborrow_mut(&mut self)
-> Handle<NodeRef<marker::Mut, K, V, NodeType>, HandleType> {
-> Handle<NodeRef<marker::Mut<'_>, K, V, NodeType>, HandleType> {
// We can't use Handle::new_kv or Handle::new_edge because we don't know our type
Handle {
@ -1068,7 +1068,7 @@ impl<'a, K, V> Handle<NodeRef<marker::Mut<'a>, K, V, marker::Internal>, marker::
/// Unsafely asserts to the compiler some static information about whether the underlying
/// node of this handle is a `Leaf`.
unsafe fn cast_unchecked<NewType>(&mut self)
-> Handle<NodeRef<marker::Mut, K, V, NewType>, marker::Edge> {
-> Handle<NodeRef<marker::Mut<'_>, K, V, NewType>, marker::Edge> {
Handle::new_edge(self.node.cast_unchecked(), self.idx)
}
@ -1558,8 +1558,8 @@ unsafe fn move_kv<K, V>(
// Source and destination must have the same height.
unsafe fn move_edges<K, V>(
mut source: NodeRef<marker::Mut, K, V, marker::Internal>, source_offset: usize,
mut dest: NodeRef<marker::Mut, K, V, marker::Internal>, dest_offset: usize,
mut source: NodeRef<marker::Mut<'_>, K, V, marker::Internal>, source_offset: usize,
mut dest: NodeRef<marker::Mut<'_>, K, V, marker::Internal>, dest_offset: usize,
count: usize)
{
let source_ptr = source.as_internal_mut().edges.as_mut_ptr();

8
src/liballoc/collections/btree/search.rs
View file

@ -1,11 +1,9 @@
use core::borrow::Borrow;
use core::cmp::Ordering;
use borrow::Borrow;
use super::node::{Handle, NodeRef, marker, ForceResult::*};
use super::node::{Handle, NodeRef, marker};
use super::node::ForceResult::*;
use self::SearchResult::*;
use SearchResult::*;
pub enum SearchResult<BorrowType, K, V, FoundType, GoDownType> {
Found(Handle<NodeRef<BorrowType, K, V, FoundType>, marker::KV>),

55
src/liballoc/collections/btree/set.rs
View file

@ -1,15 +1,14 @@
// This is pretty much entirely stolen from TreeSet, since BTreeMap has an identical interface
// to TreeMap
use core::borrow::Borrow;
use core::cmp::Ordering::{self, Less, Greater, Equal};
use core::cmp::{min, max};
use core::fmt::Debug;
use core::fmt;
use core::fmt::{self, Debug};
use core::iter::{Peekable, FromIterator, FusedIterator};
use core::ops::{BitOr, BitAnd, BitXor, Sub, RangeBounds};
use borrow::Borrow;
use collections::btree_map::{self, BTreeMap, Keys};
use crate::collections::btree_map::{self, BTreeMap, Keys};
use super::Recover;
// FIXME(conventions): implement bounded iterators
@ -76,8 +75,8 @@ pub struct Iter<'a, T: 'a> {
}
#[stable(feature = "collection_debug", since = "1.17.0")]
impl<'a, T: 'a + fmt::Debug> fmt::Debug for Iter<'a, T> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
impl<T: fmt::Debug> fmt::Debug for Iter<'_, T> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_tuple("Iter")
.field(&self.iter.clone())
.finish()
@ -124,8 +123,8 @@ pub struct Difference<'a, T: 'a> {
}
#[stable(feature = "collection_debug", since = "1.17.0")]
impl<'a, T: 'a + fmt::Debug> fmt::Debug for Difference<'a, T> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
impl<T: fmt::Debug> fmt::Debug for Difference<'_, T> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_tuple("Difference")
.field(&self.a)
.field(&self.b)
@ -147,8 +146,8 @@ pub struct SymmetricDifference<'a, T: 'a> {
}
#[stable(feature = "collection_debug", since = "1.17.0")]
impl<'a, T: 'a + fmt::Debug> fmt::Debug for SymmetricDifference<'a, T> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
impl<T: fmt::Debug> fmt::Debug for SymmetricDifference<'_, T> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_tuple("SymmetricDifference")
.field(&self.a)
.field(&self.b)
@ -170,8 +169,8 @@ pub struct Intersection<'a, T: 'a> {
}
#[stable(feature = "collection_debug", since = "1.17.0")]
impl<'a, T: 'a + fmt::Debug> fmt::Debug for Intersection<'a, T> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
impl<T: fmt::Debug> fmt::Debug for Intersection<'_, T> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_tuple("Intersection")
.field(&self.a)
.field(&self.b)
@ -193,8 +192,8 @@ pub struct Union<'a, T: 'a> {
}
#[stable(feature = "collection_debug", since = "1.17.0")]
impl<'a, T: 'a + fmt::Debug> fmt::Debug for Union<'a, T> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
impl<T: fmt::Debug> fmt::Debug for Union<'_, T> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_tuple("Union")
.field(&self.a)
.field(&self.b)
@ -241,7 +240,7 @@ impl<T: Ord> BTreeSet<T> {
/// assert_eq!(Some(&5), set.range(4..).next());
/// ```
#[stable(feature = "btree_range", since = "1.17.0")]
pub fn range<K: ?Sized, R>(&self, range: R) -> Range<T>
pub fn range<K: ?Sized, R>(&self, range: R) -> Range<'_, T>
where K: Ord, T: Borrow<K>, R: RangeBounds<K>
{
Range { iter: self.map.range(range) }
@ -703,7 +702,7 @@ impl<T> BTreeSet<T> {
/// assert_eq!(set_iter.next(), None);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
pub fn iter(&self) -> Iter<T> {
pub fn iter(&self) -> Iter<'_, T> {
Iter { iter: self.map.keys() }
}
@ -809,7 +808,7 @@ impl<T: Ord> Default for BTreeSet<T> {
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<'a, 'b, T: Ord + Clone> Sub<&'b BTreeSet<T>> for &'a BTreeSet<T> {
impl<T: Ord + Clone> Sub<&BTreeSet<T>> for &BTreeSet<T> {
type Output = BTreeSet<T>;
/// Returns the difference of `self` and `rhs` as a new `BTreeSet<T>`.
@ -832,7 +831,7 @@ impl<'a, 'b, T: Ord + Clone> Sub<&'b BTreeSet<T>> for &'a BTreeSet<T> {
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<'a, 'b, T: Ord + Clone> BitXor<&'b BTreeSet<T>> for &'a BTreeSet<T> {
impl<T: Ord + Clone> BitXor<&BTreeSet<T>> for &BTreeSet<T> {
type Output = BTreeSet<T>;
/// Returns the symmetric difference of `self` and `rhs` as a new `BTreeSet<T>`.
@ -855,7 +854,7 @@ impl<'a, 'b, T: Ord + Clone> BitXor<&'b BTreeSet<T>> for &'a BTreeSet<T> {
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<'a, 'b, T: Ord + Clone> BitAnd<&'b BTreeSet<T>> for &'a BTreeSet<T> {
impl<T: Ord + Clone> BitAnd<&BTreeSet<T>> for &BTreeSet<T> {
type Output = BTreeSet<T>;
/// Returns the intersection of `self` and `rhs` as a new `BTreeSet<T>`.
@ -878,7 +877,7 @@ impl<'a, 'b, T: Ord + Clone> BitAnd<&'b BTreeSet<T>> for &'a BTreeSet<T> {
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<'a, 'b, T: Ord + Clone> BitOr<&'b BTreeSet<T>> for &'a BTreeSet<T> {
impl<T: Ord + Clone> BitOr<&BTreeSet<T>> for &BTreeSet<T> {
type Output = BTreeSet<T>;
/// Returns the union of `self` and `rhs` as a new `BTreeSet<T>`.
@ -902,7 +901,7 @@ impl<'a, 'b, T: Ord + Clone> BitOr<&'b BTreeSet<T>> for &'a BTreeSet<T> {
#[stable(feature = "rust1", since = "1.0.0")]
impl<T: Debug> Debug for BTreeSet<T> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_set().entries(self.iter()).finish()
}
}
@ -931,12 +930,12 @@ impl<'a, T> DoubleEndedIterator for Iter<'a, T> {
}
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<'a, T> ExactSizeIterator for Iter<'a, T> {
impl<T> ExactSizeIterator for Iter<'_, T> {
fn len(&self) -> usize { self.iter.len() }
}
#[stable(feature = "fused", since = "1.26.0")]
impl<'a, T> FusedIterator for Iter<'a, T> {}
impl<T> FusedIterator for Iter<'_, T> {}
#[stable(feature = "rust1", since = "1.0.0")]
impl<T> Iterator for IntoIter<T> {
@ -987,7 +986,7 @@ impl<'a, T> DoubleEndedIterator for Range<'a, T> {
}
#[stable(feature = "fused", since = "1.26.0")]
impl<'a, T> FusedIterator for Range<'a, T> {}
impl<T> FusedIterator for Range<'_, T> {}
/// Compare `x` and `y`, but return `short` if x is None and `long` if y is None
fn cmp_opt<T: Ord>(x: Option<&T>, y: Option<&T>, short: Ordering, long: Ordering) -> Ordering {
@ -1034,7 +1033,7 @@ impl<'a, T: Ord> Iterator for Difference<'a, T> {
}
#[stable(feature = "fused", since = "1.26.0")]
impl<'a, T: Ord> FusedIterator for Difference<'a, T> {}
impl<T: Ord> FusedIterator for Difference<'_, T> {}
#[stable(feature = "rust1", since = "1.0.0")]
impl<'a, T> Clone for SymmetricDifference<'a, T> {
@ -1068,7 +1067,7 @@ impl<'a, T: Ord> Iterator for SymmetricDifference<'a, T> {
}
#[stable(feature = "fused", since = "1.26.0")]
impl<'a, T: Ord> FusedIterator for SymmetricDifference<'a, T> {}
impl<T: Ord> FusedIterator for SymmetricDifference<'_, T> {}
#[stable(feature = "rust1", since = "1.0.0")]
impl<'a, T> Clone for Intersection<'a, T> {
@ -1106,7 +1105,7 @@ impl<'a, T: Ord> Iterator for Intersection<'a, T> {
}
#[stable(feature = "fused", since = "1.26.0")]
impl<'a, T: Ord> FusedIterator for Intersection<'a, T> {}
impl<T: Ord> FusedIterator for Intersection<'_, T> {}
#[stable(feature = "rust1", since = "1.0.0")]
impl<'a, T> Clone for Union<'a, T> {
@ -1140,4 +1139,4 @@ impl<'a, T: Ord> Iterator for Union<'a, T> {
}
#[stable(feature = "fused", since = "1.26.0")]
impl<'a, T: Ord> FusedIterator for Union<'a, T> {}
impl<T: Ord> FusedIterator for Union<'_, T> {}

40
src/liballoc/collections/linked_list.rs
View file

@ -20,7 +20,7 @@ use core::marker::PhantomData;
use core::mem;
use core::ptr::NonNull;
use boxed::Box;
use crate::boxed::Box;
use super::SpecExtend;
/// A doubly-linked list with owned nodes.
@ -61,8 +61,8 @@ pub struct Iter<'a, T: 'a> {
}
#[stable(feature = "collection_debug", since = "1.17.0")]
impl<'a, T: 'a + fmt::Debug> fmt::Debug for Iter<'a, T> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
impl<T: fmt::Debug> fmt::Debug for Iter<'_, T> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_tuple("Iter")
.field(&self.len)
.finish()
@ -71,7 +71,7 @@ impl<'a, T: 'a + fmt::Debug> fmt::Debug for Iter<'a, T> {
// FIXME(#26925) Remove in favor of `#[derive(Clone)]`
#[stable(feature = "rust1", since = "1.0.0")]
impl<'a, T> Clone for Iter<'a, T> {
impl<T> Clone for Iter<'_, T> {
fn clone(&self) -> Self {
Iter { ..*self }
}
@ -93,8 +93,8 @@ pub struct IterMut<'a, T: 'a> {
}
#[stable(feature = "collection_debug", since = "1.17.0")]
impl<'a, T: 'a + fmt::Debug> fmt::Debug for IterMut<'a, T> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
impl<T: fmt::Debug> fmt::Debug for IterMut<'_, T> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_tuple("IterMut")
.field(&self.list)
.field(&self.len)
@ -117,7 +117,7 @@ pub struct IntoIter<T> {
#[stable(feature = "collection_debug", since = "1.17.0")]
impl<T: fmt::Debug> fmt::Debug for IntoIter<T> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_tuple("IntoIter")
.field(&self.list)
.finish()
@ -331,7 +331,7 @@ impl<T> LinkedList<T> {
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
pub fn iter(&self) -> Iter<T> {
pub fn iter(&self) -> Iter<'_, T> {
Iter {
head: self.head,
tail: self.tail,
@ -365,7 +365,7 @@ impl<T> LinkedList<T> {
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
pub fn iter_mut(&mut self) -> IterMut<T> {
pub fn iter_mut(&mut self) -> IterMut<'_, T> {
IterMut {
head: self.head,
tail: self.tail,
@ -764,7 +764,7 @@ impl<T> LinkedList<T> {
/// assert_eq!(odds.into_iter().collect::<Vec<_>>(), vec![1, 3, 5, 9, 11, 13, 15]);
/// ```
#[unstable(feature = "drain_filter", reason = "recently added", issue = "43244")]
pub fn drain_filter<F>(&mut self, filter: F) -> DrainFilter<T, F>
pub fn drain_filter<F>(&mut self, filter: F) -> DrainFilter<'_, T, F>
where F: FnMut(&mut T) -> bool
{
// avoid borrow issues.
@ -832,10 +832,10 @@ impl<'a, T> DoubleEndedIterator for Iter<'a, T> {
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<'a, T> ExactSizeIterator for Iter<'a, T> {}
impl<T> ExactSizeIterator for Iter<'_, T> {}
#[stable(feature = "fused", since = "1.26.0")]
impl<'a, T> FusedIterator for Iter<'a, T> {}
impl<T> FusedIterator for Iter<'_, T> {}
#[stable(feature = "rust1", since = "1.0.0")]
impl<'a, T> Iterator for IterMut<'a, T> {
@ -881,12 +881,12 @@ impl<'a, T> DoubleEndedIterator for IterMut<'a, T> {
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<'a, T> ExactSizeIterator for IterMut<'a, T> {}
impl<T> ExactSizeIterator for IterMut<'_, T> {}
#[stable(feature = "fused", since = "1.26.0")]
impl<'a, T> FusedIterator for IterMut<'a, T> {}
impl<T> FusedIterator for IterMut<'_, T> {}
impl<'a, T> IterMut<'a, T> {
impl<T> IterMut<'_, T> {
/// Inserts the given element just after the element most recently returned by `.next()`.
/// The inserted element does not appear in the iteration.
///
@ -982,7 +982,7 @@ pub struct DrainFilter<'a, T: 'a, F: 'a>
}
#[unstable(feature = "drain_filter", reason = "recently added", issue = "43244")]
impl<'a, T, F> Iterator for DrainFilter<'a, T, F>
impl<T, F> Iterator for DrainFilter<'_, T, F>
where F: FnMut(&mut T) -> bool,
{
type Item = T;
@ -1009,7 +1009,7 @@ impl<'a, T, F> Iterator for DrainFilter<'a, T, F>
}
#[unstable(feature = "drain_filter", reason = "recently added", issue = "43244")]
impl<'a, T, F> Drop for DrainFilter<'a, T, F>
impl<T, F> Drop for DrainFilter<'_, T, F>
where F: FnMut(&mut T) -> bool,
{
fn drop(&mut self) {
@ -1018,10 +1018,10 @@ impl<'a, T, F> Drop for DrainFilter<'a, T, F>
}
#[unstable(feature = "drain_filter", reason = "recently added", issue = "43244")]
impl<'a, T: 'a + fmt::Debug, F> fmt::Debug for DrainFilter<'a, T, F>
impl<T: fmt::Debug, F> fmt::Debug for DrainFilter<'_, T, F>
where F: FnMut(&mut T) -> bool
{
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_tuple("DrainFilter")
.field(&self.list)
.finish()
@ -1164,7 +1164,7 @@ impl<T: Clone> Clone for LinkedList<T> {
#[stable(feature = "rust1", since = "1.0.0")]
impl<T: fmt::Debug> fmt::Debug for LinkedList<T> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_list().entries(self).finish()
}
}

12
src/liballoc/collections/mod.rs
View file

@ -23,25 +23,25 @@ pub mod btree_set {
#[stable(feature = "rust1", since = "1.0.0")]
#[doc(no_inline)]
pub use self::binary_heap::BinaryHeap;
pub use binary_heap::BinaryHeap;
#[stable(feature = "rust1", since = "1.0.0")]
#[doc(no_inline)]
pub use self::btree_map::BTreeMap;
pub use btree_map::BTreeMap;
#[stable(feature = "rust1", since = "1.0.0")]
#[doc(no_inline)]
pub use self::btree_set::BTreeSet;
pub use btree_set::BTreeSet;
#[stable(feature = "rust1", since = "1.0.0")]
#[doc(no_inline)]
pub use self::linked_list::LinkedList;
pub use linked_list::LinkedList;
#[stable(feature = "rust1", since = "1.0.0")]
#[doc(no_inline)]
pub use self::vec_deque::VecDeque;
pub use vec_deque::VecDeque;
use alloc::{AllocErr, LayoutErr};
use crate::alloc::{AllocErr, LayoutErr};
/// Augments `AllocErr` with a CapacityOverflow variant.
#[derive(Clone, PartialEq, Eq, Debug)]

79
src/liballoc/collections/vec_deque.rs
View file

@ -7,22 +7,19 @@
#![stable(feature = "rust1", since = "1.0.0")]
use core::cmp::Ordering;
use core::cmp::{self, Ordering};
use core::fmt;
use core::iter::{repeat_with, FromIterator, FusedIterator};
use core::mem;
use core::ops::Bound::{Excluded, Included, Unbounded};
use core::ops::{Index, IndexMut, RangeBounds, Try};
use core::ptr;
use core::ptr::NonNull;
use core::ptr::{self, NonNull};
use core::slice;
use core::hash::{Hash, Hasher};
use core::cmp;
use collections::CollectionAllocErr;
use raw_vec::RawVec;
use vec::Vec;
use crate::collections::CollectionAllocErr;
use crate::raw_vec::RawVec;
use crate::vec::Vec;
const INITIAL_CAPACITY: usize = 7; // 2^3 - 1
const MINIMUM_CAPACITY: usize = 1; // 2 - 1
@ -798,7 +795,7 @@ impl<T> VecDeque<T> {
/// assert_eq!(&c[..], b);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
pub fn iter(&self) -> Iter<T> {
pub fn iter(&self) -> Iter<'_, T> {
Iter {
tail: self.tail,
head: self.head,
@ -824,7 +821,7 @@ impl<T> VecDeque<T> {
/// assert_eq!(&buf.iter_mut().collect::<Vec<&mut i32>>()[..], b);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
pub fn iter_mut(&mut self) -> IterMut<T> {
pub fn iter_mut(&mut self) -> IterMut<'_, T> {
IterMut {
tail: self.tail,
head: self.head,
@ -958,7 +955,7 @@ impl<T> VecDeque<T> {
/// ```
#[inline]
#[stable(feature = "drain", since = "1.6.0")]
pub fn drain<R>(&mut self, range: R) -> Drain<T>
pub fn drain<R>(&mut self, range: R) -> Drain<'_, T>
where R: RangeBounds<usize>
{
// Memory safety
@ -2083,7 +2080,7 @@ trait RingSlices: Sized {
}
}
impl<'a, T> RingSlices for &'a [T] {
impl<T> RingSlices for &[T] {
fn slice(self, from: usize, to: usize) -> Self {
&self[from..to]
}
@ -2092,7 +2089,7 @@ impl<'a, T> RingSlices for &'a [T] {
}
}
impl<'a, T> RingSlices for &'a mut [T] {
impl<T> RingSlices for &mut [T] {
fn slice(self, from: usize, to: usize) -> Self {
&mut self[from..to]
}
@ -2123,8 +2120,8 @@ pub struct Iter<'a, T: 'a> {
}
#[stable(feature = "collection_debug", since = "1.17.0")]
impl<'a, T: 'a + fmt::Debug> fmt::Debug for Iter<'a, T> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
impl<T: fmt::Debug> fmt::Debug for Iter<'_, T> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let (front, back) = RingSlices::ring_slices(self.ring, self.head, self.tail);
f.debug_tuple("Iter")
.field(&front)
@ -2203,14 +2200,14 @@ impl<'a, T> DoubleEndedIterator for Iter<'a, T> {
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<'a, T> ExactSizeIterator for Iter<'a, T> {
impl<T> ExactSizeIterator for Iter<'_, T> {
fn is_empty(&self) -> bool {
self.head == self.tail
}
}
#[stable(feature = "fused", since = "1.26.0")]
impl<'a, T> FusedIterator for Iter<'a, T> {}
impl<T> FusedIterator for Iter<'_, T> {}
/// A mutable iterator over the elements of a `VecDeque`.
@ -2228,8 +2225,8 @@ pub struct IterMut<'a, T: 'a> {
}
#[stable(feature = "collection_debug", since = "1.17.0")]
impl<'a, T: 'a + fmt::Debug> fmt::Debug for IterMut<'a, T> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
impl<'a, T: fmt::Debug> fmt::Debug for IterMut<'_, T> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let (front, back) = RingSlices::ring_slices(&*self.ring, self.head, self.tail);
f.debug_tuple("IterMut")
.field(&front)
@ -2296,14 +2293,14 @@ impl<'a, T> DoubleEndedIterator for IterMut<'a, T> {
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<'a, T> ExactSizeIterator for IterMut<'a, T> {
impl<T> ExactSizeIterator for IterMut<'_, T> {
fn is_empty(&self) -> bool {
self.head == self.tail
}
}
#[stable(feature = "fused", since = "1.26.0")]
impl<'a, T> FusedIterator for IterMut<'a, T> {}
impl<T> FusedIterator for IterMut<'_, T> {}
/// An owning iterator over the elements of a `VecDeque`.
///
@ -2320,7 +2317,7 @@ pub struct IntoIter<T> {
#[stable(feature = "collection_debug", since = "1.17.0")]
impl<T: fmt::Debug> fmt::Debug for IntoIter<T> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_tuple("IntoIter")
.field(&self.inner)
.finish()
@ -2377,8 +2374,8 @@ pub struct Drain<'a, T: 'a> {
}
#[stable(feature = "collection_debug", since = "1.17.0")]
impl<'a, T: 'a + fmt::Debug> fmt::Debug for Drain<'a, T> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
impl<T: fmt::Debug> fmt::Debug for Drain<'_, T> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_tuple("Drain")
.field(&self.after_tail)
.field(&self.after_head)
@ -2388,12 +2385,12 @@ impl<'a, T: 'a + fmt::Debug> fmt::Debug for Drain<'a, T> {
}
#[stable(feature = "drain", since = "1.6.0")]
unsafe impl<'a, T: Sync> Sync for Drain<'a, T> {}
unsafe impl<T: Sync> Sync for Drain<'_, T> {}
#[stable(feature = "drain", since = "1.6.0")]
unsafe impl<'a, T: Send> Send for Drain<'a, T> {}
unsafe impl<T: Send> Send for Drain<'_, T> {}
#[stable(feature = "drain", since = "1.6.0")]
impl<'a, T: 'a> Drop for Drain<'a, T> {
impl<T> Drop for Drain<'_, T> {
fn drop(&mut self) {
self.for_each(drop);
@ -2440,7 +2437,7 @@ impl<'a, T: 'a> Drop for Drain<'a, T> {
}
#[stable(feature = "drain", since = "1.6.0")]
impl<'a, T: 'a> Iterator for Drain<'a, T> {
impl<T> Iterator for Drain<'_, T> {
type Item = T;
#[inline]
@ -2455,7 +2452,7 @@ impl<'a, T: 'a> Iterator for Drain<'a, T> {
}
#[stable(feature = "drain", since = "1.6.0")]
impl<'a, T: 'a> DoubleEndedIterator for Drain<'a, T> {
impl<T> DoubleEndedIterator for Drain<'_, T> {
#[inline]
fn next_back(&mut self) -> Option<T> {
self.iter.next_back().map(|elt| unsafe { ptr::read(elt) })
@ -2463,10 +2460,10 @@ impl<'a, T: 'a> DoubleEndedIterator for Drain<'a, T> {
}
#[stable(feature = "drain", since = "1.6.0")]
impl<'a, T: 'a> ExactSizeIterator for Drain<'a, T> {}
impl<T> ExactSizeIterator for Drain<'_, T> {}
#[stable(feature = "fused", since = "1.26.0")]
impl<'a, T: 'a> FusedIterator for Drain<'a, T> {}
impl<T> FusedIterator for Drain<'_, T> {}
#[stable(feature = "rust1", since = "1.0.0")]
impl<A: PartialEq> PartialEq for VecDeque<A> {
@ -2516,7 +2513,7 @@ macro_rules! __impl_slice_eq1 {
};
($Lhs: ty, $Rhs: ty, $Bound: ident) => {
#[stable(feature = "vec_deque_partial_eq_slice", since = "1.17.0")]
impl<'a, 'b, A: $Bound, B> PartialEq<$Rhs> for $Lhs where A: PartialEq<B> {
impl<A: $Bound, B> PartialEq<$Rhs> for $Lhs where A: PartialEq<B> {
fn eq(&self, other: &$Rhs) -> bool {
if self.len() != other.len() {
return false;
@ -2530,15 +2527,15 @@ macro_rules! __impl_slice_eq1 {
}
__impl_slice_eq1! { VecDeque<A>, Vec<B> }
__impl_slice_eq1! { VecDeque<A>, &'b [B] }
__impl_slice_eq1! { VecDeque<A>, &'b mut [B] }
__impl_slice_eq1! { VecDeque<A>, &[B] }
__impl_slice_eq1! { VecDeque<A>, &mut [B] }
macro_rules! array_impls {
($($N: expr)+) => {
$(
__impl_slice_eq1! { VecDeque<A>, [B; $N] }
__impl_slice_eq1! { VecDeque<A>, &'b [B; $N] }
__impl_slice_eq1! { VecDeque<A>, &'b mut [B; $N] }
__impl_slice_eq1! { VecDeque<A>, &[B; $N] }
__impl_slice_eq1! { VecDeque<A>, &mut [B; $N] }
)+
}
}
@ -2654,7 +2651,7 @@ impl<'a, T: 'a + Copy> Extend<&'a T> for VecDeque<T> {
#[stable(feature = "rust1", since = "1.0.0")]
impl<T: fmt::Debug> fmt::Debug for VecDeque<T> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_list().entries(self).finish()
}
}
@ -2758,7 +2755,7 @@ impl<T> From<VecDeque<T>> for Vec<T> {
#[cfg(test)]
mod tests {
use test;
use ::test;
use super::VecDeque;
@ -3036,7 +3033,7 @@ mod tests {
#[test]
fn test_from_vec() {
use vec::Vec;
use crate::vec::Vec;
for cap in 0..35 {
for len in 0..=cap {
let mut vec = Vec::with_capacity(cap);
@ -3052,7 +3049,7 @@ mod tests {
#[test]
fn test_vec_from_vecdeque() {
use vec::Vec;
use crate::vec::Vec;
fn create_vec_and_test_convert(cap: usize, offset: usize, len: usize) {
let mut vd = VecDeque::with_capacity(cap);
@ -3114,7 +3111,7 @@ mod tests {
#[test]
fn issue_53529() {
use boxed::Box;
use crate::boxed::Box;
let mut dst = VecDeque::new();
dst.push_front(Box::new(1));

4
src/liballoc/fmt.rs
View file

@ -527,7 +527,7 @@ pub use core::fmt::{DebugList, DebugMap, DebugSet, DebugStruct, DebugTuple};
#[stable(feature = "fmt_flags_align", since = "1.28.0")]
pub use core::fmt::{Alignment};
use string;
use crate::string;
/// The `format` function takes an [`Arguments`] struct and returns the resulting
/// formatted string.
@ -557,7 +557,7 @@ use string;
/// [`format_args!`]: ../../std/macro.format_args.html
/// [`format!`]: ../../std/macro.format.html
#[stable(feature = "rust1", since = "1.0.0")]
pub fn format(args: Arguments) -> string::String {
pub fn format(args: Arguments<'_>) -> string::String {
let capacity = args.estimated_capacity();
let mut output = string::String::with_capacity(capacity);
output

7
src/liballoc/lib.rs
View file

@ -63,6 +63,9 @@
#![no_std]
#![needs_allocator]
#![deny(rust_2018_idioms)]
#![allow(explicit_outlives_requirements)]
#![warn(deprecated_in_future)]
#![warn(intra_doc_link_resolution_failure)]
#![warn(missing_debug_implementations)]
@ -121,8 +124,6 @@
extern crate std;
#[cfg(test)]
extern crate test;
#[cfg(test)]
extern crate rand;
// Module with internal macros used by other modules (needs to be included before other modules).
#[macro_use]
@ -164,5 +165,5 @@ pub mod vec;
#[cfg(not(test))]
mod std {
pub use core::ops; // RangeFull
pub use core::ops; // RangeFull
}

10
src/liballoc/prelude.rs
View file

@ -12,8 +12,8 @@
#![unstable(feature = "alloc", issue = "27783")]
#[unstable(feature = "alloc", issue = "27783")] pub use borrow::ToOwned;
#[unstable(feature = "alloc", issue = "27783")] pub use boxed::Box;
#[unstable(feature = "alloc", issue = "27783")] pub use slice::SliceConcatExt;
#[unstable(feature = "alloc", issue = "27783")] pub use string::{String, ToString};
#[unstable(feature = "alloc", issue = "27783")] pub use vec::Vec;
#[unstable(feature = "alloc", issue = "27783")] pub use crate::borrow::ToOwned;
#[unstable(feature = "alloc", issue = "27783")] pub use crate::boxed::Box;
#[unstable(feature = "alloc", issue = "27783")] pub use crate::slice::SliceConcatExt;
#[unstable(feature = "alloc", issue = "27783")] pub use crate::string::{String, ToString};
#[unstable(feature = "alloc", issue = "27783")] pub use crate::vec::Vec;

17
src/liballoc/raw_vec.rs
View file

@ -7,10 +7,9 @@ use core::ops::Drop;
use core::ptr::{self, NonNull, Unique};
use core::slice;
use alloc::{Alloc, Layout, Global, handle_alloc_error};
use collections::CollectionAllocErr;
use collections::CollectionAllocErr::*;
use boxed::Box;
use crate::alloc::{Alloc, Layout, Global, handle_alloc_error};
use crate::collections::CollectionAllocErr::{self, *};
use crate::boxed::Box;
/// A low-level utility for more ergonomically allocating, reallocating, and deallocating
/// a buffer of memory on the heap without having to worry about all the corner cases
@ -621,14 +620,14 @@ enum Fallibility {
Infallible,
}
use self::Fallibility::*;
use Fallibility::*;
enum ReserveStrategy {
Exact,
Amortized,
}
use self::ReserveStrategy::*;
use ReserveStrategy::*;
impl<T, A: Alloc> RawVec<T, A> {
fn reserve_internal(
@ -639,7 +638,7 @@ impl<T, A: Alloc> RawVec<T, A> {
strategy: ReserveStrategy,
) -> Result<(), CollectionAllocErr> {
unsafe {
use alloc::AllocErr;
use crate::alloc::AllocErr;
// NOTE: we don't early branch on ZSTs here because we want this
// to actually catch "asking for more than usize::MAX" in that case.
@ -733,7 +732,7 @@ unsafe impl<#[may_dangle] T, A: Alloc> Drop for RawVec<T, A> {
#[inline]
fn alloc_guard(alloc_size: usize) -> Result<(), CollectionAllocErr> {
if mem::size_of::<usize>() < 8 && alloc_size > ::core::isize::MAX as usize {
if mem::size_of::<usize>() < 8 && alloc_size > core::isize::MAX as usize {
Err(CapacityOverflow)
} else {
Ok(())
@ -753,7 +752,7 @@ mod tests {
#[test]
fn allocator_param() {
use alloc::AllocErr;
use crate::alloc::AllocErr;
// Writing a test of integration between third-party
// allocators and RawVec is a little tricky because the RawVec

28
src/liballoc/rc.rs
View file

@ -227,7 +227,7 @@
#![stable(feature = "rust1", since = "1.0.0")]
#[cfg(not(test))]
use boxed::Box;
use crate::boxed::Box;
#[cfg(test)]
use std::boxed::Box;
@ -238,19 +238,18 @@ use core::cmp::Ordering;
use core::fmt;
use core::hash::{Hash, Hasher};
use core::intrinsics::abort;
use core::marker;
use core::marker::{Unpin, Unsize, PhantomData};
use core::marker::{self, Unpin, Unsize, PhantomData};
use core::mem::{self, align_of_val, forget, size_of_val};
use core::ops::{Deref, Receiver};
use core::ops::{CoerceUnsized, DispatchFromDyn};
use core::ops::{Deref, Receiver, CoerceUnsized, DispatchFromDyn};
use core::pin::Pin;
use core::ptr::{self, NonNull};
use core::slice::from_raw_parts_mut;
use core::convert::From;
use core::usize;
use alloc::{Global, Alloc, Layout, box_free, handle_alloc_error};
use string::String;
use vec::Vec;
use crate::alloc::{Global, Alloc, Layout, box_free, handle_alloc_error};
use crate::string::String;
use crate::vec::Vec;
struct RcBox<T: ?Sized> {
strong: Cell<usize>,
@ -766,8 +765,6 @@ impl<T: Clone> RcFromSlice<T> for Rc<[T]> {
impl<T> Drop for Guard<T> {
fn drop(&mut self) {
use core::slice::from_raw_parts_mut;
unsafe {
let slice = from_raw_parts_mut(self.elems, self.n_elems);
ptr::drop_in_place(slice);
@ -1121,21 +1118,21 @@ impl<T: ?Sized + Hash> Hash for Rc<T> {
#[stable(feature = "rust1", since = "1.0.0")]
impl<T: ?Sized + fmt::Display> fmt::Display for Rc<T> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
fmt::Display::fmt(&**self, f)
}
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<T: ?Sized + fmt::Debug> fmt::Debug for Rc<T> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
fmt::Debug::fmt(&**self, f)
}
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<T: ?Sized> fmt::Pointer for Rc<T> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
fmt::Pointer::fmt(&(&**self as *const T), f)
}
}
@ -1459,7 +1456,7 @@ impl<T: ?Sized> Clone for Weak<T> {
#[stable(feature = "rc_weak", since = "1.4.0")]
impl<T: ?Sized + fmt::Debug> fmt::Debug for Weak<T> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "(Weak)")
}
}
@ -1564,8 +1561,7 @@ mod tests {
use super::{Rc, Weak};
use std::boxed::Box;
use std::cell::RefCell;
use std::option::Option;
use std::option::Option::{None, Some};
use std::option::Option::{self, None, Some};
use std::result::Result::{Err, Ok};
use std::mem::drop;
use std::clone::Clone;

20
src/liballoc/slice.rs
View file

@ -87,15 +87,15 @@
// It's cleaner to just turn off the unused_imports warning than to fix them.
#![cfg_attr(test, allow(unused_imports, dead_code))]
use core::borrow::{Borrow, BorrowMut};
use core::cmp::Ordering::{self, Less};
use core::mem::size_of;
use core::mem;
use core::mem::{self, size_of};
use core::ptr;
use core::{u8, u16, u32};
use borrow::{Borrow, BorrowMut, ToOwned};
use boxed::Box;
use vec::Vec;
use crate::borrow::ToOwned;
use crate::boxed::Box;
use crate::vec::Vec;
#[stable(feature = "rust1", since = "1.0.0")]
pub use core::slice::{Chunks, Windows};
@ -125,24 +125,24 @@ pub use core::slice::{RChunks, RChunksMut, RChunksExact, RChunksExactMut};
// HACK(japaric) needed for the implementation of `vec!` macro during testing
// NB see the hack module in this file for more details
#[cfg(test)]
pub use self::hack::into_vec;
pub use hack::into_vec;
// HACK(japaric) needed for the implementation of `Vec::clone` during testing
// NB see the hack module in this file for more details
#[cfg(test)]
pub use self::hack::to_vec;
pub use hack::to_vec;
// HACK(japaric): With cfg(test) `impl [T]` is not available, these three
// functions are actually methods that are in `impl [T]` but not in
// `core::slice::SliceExt` - we need to supply these functions for the
// `test_permutations` test
mod hack {
use boxed::Box;
use core::mem;
use crate::boxed::Box;
use crate::vec::Vec;
#[cfg(test)]
use string::ToString;
use vec::Vec;
use crate::string::ToString;
pub fn into_vec<T>(mut b: Box<[T]>) -> Vec<T> {
unsafe {

14
src/liballoc/str.rs
View file

@ -28,20 +28,20 @@
// It's cleaner to just turn off the unused_imports warning than to fix them.
#![allow(unused_imports)]
use core::borrow::Borrow;
use core::fmt;
use core::str as core_str;
use core::str::pattern::Pattern;
use core::str::pattern::{Searcher, ReverseSearcher, DoubleEndedSearcher};
use core::str::pattern::{Pattern, Searcher, ReverseSearcher, DoubleEndedSearcher};
use core::mem;
use core::ptr;
use core::iter::FusedIterator;
use core::unicode::conversions;
use borrow::{Borrow, ToOwned};
use boxed::Box;
use slice::{SliceConcatExt, SliceIndex};
use string::String;
use vec::Vec;
use crate::borrow::ToOwned;
use crate::boxed::Box;
use crate::slice::{SliceConcatExt, SliceIndex};
use crate::string::String;
use crate::vec::Vec;
#[stable(feature = "rust1", since = "1.0.0")]
pub use core::str::{FromStr, Utf8Error};

53
src/liballoc/string.rs
View file

@ -50,17 +50,16 @@ use core::char::{decode_utf16, REPLACEMENT_CHARACTER};
use core::fmt;
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::Bound::{Excluded, Included, Unbounded};
use core::ptr;
use core::str::pattern::Pattern;
use core::str::lossy;
use core::str::{pattern::Pattern, lossy};
use collections::CollectionAllocErr;
use borrow::{Cow, ToOwned};
use boxed::Box;
use str::{self, from_boxed_utf8_unchecked, FromStr, Utf8Error, Chars};
use vec::Vec;
use crate::borrow::{Cow, ToOwned};
use crate::collections::CollectionAllocErr;
use crate::boxed::Box;
use crate::str::{self, from_boxed_utf8_unchecked, FromStr, Utf8Error, Chars};
use crate::vec::Vec;
/// A UTF-8 encoded, growable string.
///
@ -1485,7 +1484,7 @@ impl String {
/// assert_eq!(s, "");
/// ```
#[stable(feature = "drain", since = "1.6.0")]
pub fn drain<R>(&mut self, range: R) -> Drain
pub fn drain<R>(&mut self, range: R) -> Drain<'_>
where R: RangeBounds<usize>
{
// Memory safety
@ -1669,14 +1668,14 @@ impl FromUtf8Error {
#[stable(feature = "rust1", since = "1.0.0")]
impl fmt::Display for FromUtf8Error {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
fmt::Display::fmt(&self.error, f)
}
}
#[stable(feature = "rust1", since = "1.0.0")]
impl fmt::Display for FromUtf16Error {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
fmt::Display::fmt("invalid utf-16: lone surrogate found", f)
}
}
@ -1867,7 +1866,7 @@ impl Default for String {
#[stable(feature = "rust1", since = "1.0.0")]
impl fmt::Display for String {
#[inline]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
fmt::Display::fmt(&**self, f)
}
}
@ -1875,7 +1874,7 @@ impl fmt::Display for String {
#[stable(feature = "rust1", since = "1.0.0")]
impl fmt::Debug for String {
#[inline]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
fmt::Debug::fmt(&**self, f)
}
}
@ -1926,7 +1925,7 @@ impl hash::Hash for String {
/// let c = a.to_string() + b;
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
impl<'a> Add<&'a str> for String {
impl Add<&str> for String {
type Output = String;
#[inline]
@ -1940,7 +1939,7 @@ impl<'a> Add<&'a str> for String {
///
/// This has the same behavior as the [`push_str`][String::push_str] method.
#[stable(feature = "stringaddassign", since = "1.12.0")]
impl<'a> AddAssign<&'a str> for String {
impl AddAssign<&str> for String {
#[inline]
fn add_assign(&mut self, other: &str) {
self.push_str(other);
@ -2097,14 +2096,14 @@ impl Clone for ParseError {
#[stable(feature = "str_parse_error", since = "1.5.0")]
impl fmt::Debug for ParseError {
fn fmt(&self, _: &mut fmt::Formatter) -> fmt::Result {
fn fmt(&self, _: &mut fmt::Formatter<'_>) -> fmt::Result {
match *self {}
}
}
#[stable(feature = "str_parse_error2", since = "1.8.0")]
impl fmt::Display for ParseError {
fn fmt(&self, _: &mut fmt::Formatter) -> fmt::Result {
fn fmt(&self, _: &mut fmt::Formatter<'_>) -> fmt::Result {
match *self {}
}
}
@ -2156,7 +2155,7 @@ pub trait ToString {
impl<T: fmt::Display + ?Sized> ToString for T {
#[inline]
default fn to_string(&self) -> String {
use core::fmt::Write;
use fmt::Write;
let mut buf = String::new();
buf.write_fmt(format_args!("{}", self))
.expect("a Display implementation returned an error unexpectedly");
@ -2174,7 +2173,7 @@ impl ToString for str {
}
#[stable(feature = "cow_str_to_string_specialization", since = "1.17.0")]
impl<'a> ToString for Cow<'a, str> {
impl ToString for Cow<'_, str> {
#[inline]
fn to_string(&self) -> String {
self[..].to_owned()
@ -2364,19 +2363,19 @@ pub struct Drain<'a> {
}
#[stable(feature = "collection_debug", since = "1.17.0")]
impl<'a> fmt::Debug for Drain<'a> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
impl fmt::Debug for Drain<'_> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.pad("Drain { .. }")
}
}
#[stable(feature = "drain", since = "1.6.0")]
unsafe impl<'a> Sync for Drain<'a> {}
unsafe impl Sync for Drain<'_> {}
#[stable(feature = "drain", since = "1.6.0")]
unsafe impl<'a> Send for Drain<'a> {}
unsafe impl Send for Drain<'_> {}
#[stable(feature = "drain", since = "1.6.0")]
impl<'a> Drop for Drain<'a> {
impl Drop for Drain<'_> {
fn drop(&mut self) {
unsafe {
// Use Vec::drain. "Reaffirm" the bounds checks to avoid
@ -2390,7 +2389,7 @@ impl<'a> Drop for Drain<'a> {
}
#[stable(feature = "drain", since = "1.6.0")]
impl<'a> Iterator for Drain<'a> {
impl Iterator for Drain<'_> {
type Item = char;
#[inline]
@ -2404,7 +2403,7 @@ impl<'a> Iterator for Drain<'a> {
}
#[stable(feature = "drain", since = "1.6.0")]
impl<'a> DoubleEndedIterator for Drain<'a> {
impl DoubleEndedIterator for Drain<'_> {
#[inline]
fn next_back(&mut self) -> Option<char> {
self.iter.next_back()
@ -2412,4 +2411,4 @@ impl<'a> DoubleEndedIterator for Drain<'a> {
}
#[stable(feature = "fused", since = "1.26.0")]
impl<'a> FusedIterator for Drain<'a> {}
impl FusedIterator for Drain<'_> {}

36
src/liballoc/sync.rs
View file

@ -14,20 +14,20 @@ use core::fmt;
use core::cmp::{self, Ordering};
use core::intrinsics::abort;
use core::mem::{self, align_of_val, size_of_val};
use core::ops::{Deref, Receiver};
use core::ops::{CoerceUnsized, DispatchFromDyn};
use core::ops::{Deref, Receiver, CoerceUnsized, DispatchFromDyn};
use core::pin::Pin;
use core::ptr::{self, NonNull};
use core::marker::{Unpin, Unsize, PhantomData};
use core::hash::{Hash, Hasher};
use core::{isize, usize};
use core::convert::From;
use core::slice::from_raw_parts_mut;
use alloc::{Global, Alloc, Layout, box_free, handle_alloc_error};
use boxed::Box;
use rc::is_dangling;
use string::String;
use vec::Vec;
use crate::alloc::{Global, Alloc, Layout, box_free, handle_alloc_error};
use crate::boxed::Box;
use crate::rc::is_dangling;
use crate::string::String;
use crate::vec::Vec;
/// A soft limit on the amount of references that may be made to an `Arc`.
///
@ -251,7 +251,7 @@ impl<T: ?Sized + Unsize<U>, U: ?Sized> DispatchFromDyn<Weak<U>> for Weak<T> {}
#[stable(feature = "arc_weak", since = "1.4.0")]
impl<T: ?Sized + fmt::Debug> fmt::Debug for Weak<T> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "(Weak)")
}
}
@ -672,8 +672,6 @@ impl<T: Clone> ArcFromSlice<T> for Arc<[T]> {
impl<T> Drop for Guard<T> {
fn drop(&mut self) {
use core::slice::from_raw_parts_mut;
unsafe {
let slice = from_raw_parts_mut(self.elems, self.n_elems);
ptr::drop_in_place(slice);
@ -1550,21 +1548,21 @@ impl<T: ?Sized + Eq> Eq for Arc<T> {}
#[stable(feature = "rust1", since = "1.0.0")]
impl<T: ?Sized + fmt::Display> fmt::Display for Arc<T> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
fmt::Display::fmt(&**self, f)
}
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<T: ?Sized + fmt::Debug> fmt::Debug for Arc<T> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
fmt::Debug::fmt(&**self, f)
}
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<T: ?Sized> fmt::Pointer for Arc<T> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
fmt::Pointer::fmt(&(&**self as *const T), f)
}
}
@ -1601,7 +1599,7 @@ impl<T> From<T> for Arc<T> {
}
#[stable(feature = "shared_from_slice", since = "1.21.0")]
impl<'a, T: Clone> From<&'a [T]> for Arc<[T]> {
impl<T: Clone> From<&[T]> for Arc<[T]> {
#[inline]
fn from(v: &[T]) -> Arc<[T]> {
<Self as ArcFromSlice<T>>::from_slice(v)
@ -1609,7 +1607,7 @@ impl<'a, T: Clone> From<&'a [T]> for Arc<[T]> {
}
#[stable(feature = "shared_from_slice", since = "1.21.0")]
impl<'a> From<&'a str> for Arc<str> {
impl From<&str> for Arc<str> {
#[inline]
fn from(v: &str) -> Arc<str> {
let arc = Arc::<[u8]>::from(v.as_bytes());
@ -1655,16 +1653,14 @@ mod tests {
use std::sync::mpsc::channel;
use std::mem::drop;
use std::ops::Drop;
use std::option::Option;
use std::option::Option::{None, Some};
use std::sync::atomic;
use std::sync::atomic::Ordering::{Acquire, SeqCst};
use std::option::Option::{self, None, Some};
use std::sync::atomic::{self, Ordering::{Acquire, SeqCst}};
use std::thread;
use std::sync::Mutex;
use std::convert::From;
use super::{Arc, Weak};
use vec::Vec;
use crate::vec::Vec;
struct Canary(*mut atomic::AtomicUsize);

4
src/liballoc/task.rs
View file

@ -3,7 +3,7 @@
pub use core::task::*;
#[cfg(all(target_has_atomic = "ptr", target_has_atomic = "cas"))]
pub use self::if_arc::*;
pub use if_arc::*;
#[cfg(all(target_has_atomic = "ptr", target_has_atomic = "cas"))]
mod if_arc {
@ -11,7 +11,7 @@ mod if_arc {
use core::marker::PhantomData;
use core::mem;
use core::ptr::{self, NonNull};
use sync::Arc;
use crate::sync::Arc;
/// A way of waking up a specific task.
///

4
src/liballoc/tests/btree/map.rs
View file

@ -2,8 +2,8 @@ use std::collections::BTreeMap;
use std::collections::btree_map::Entry::{Occupied, Vacant};
use std::ops::Bound::{self, Excluded, Included, Unbounded};
use std::rc::Rc;
use std::iter::FromIterator;
use super::DeterministicRng;
#[test]
@ -199,7 +199,7 @@ fn test_range_inclusive() {
#[test]
fn test_range_inclusive_max_value() {
let max = ::std::usize::MAX;
let max = std::usize::MAX;
let map: BTreeMap<_, _> = vec![(max, 0)].into_iter().collect();
assert_eq!(map.range(max..=max).collect::<Vec<_>>(), &[(&max, &0)]);

6
src/liballoc/tests/btree/set.rs
View file

@ -1,6 +1,6 @@
use std::collections::BTreeSet;
use std::iter::FromIterator;
use super::DeterministicRng;
#[test]
@ -15,6 +15,8 @@ fn test_clone_eq() {
#[test]
fn test_hash() {
use crate::hash;
let mut x = BTreeSet::new();
let mut y = BTreeSet::new();
@ -26,7 +28,7 @@ fn test_hash() {
y.insert(2);
y.insert(1);
assert!(::hash(&x) == ::hash(&y));
assert!(hash(&x) == hash(&y));
}
fn check<F>(a: &[i32], b: &[i32], expected: &[i32], f: F)

6
src/liballoc/tests/linked_list.rs
View file

@ -241,10 +241,12 @@ fn test_eq() {
#[test]
fn test_hash() {
use crate::hash;
let mut x = LinkedList::new();
let mut y = LinkedList::new();
assert!(::hash(&x) == ::hash(&y));
assert!(hash(&x) == hash(&y));
x.push_back(1);
x.push_back(2);
@ -254,7 +256,7 @@ fn test_hash() {
y.push_front(2);
y.push_front(1);
assert!(::hash(&x) == ::hash(&y));
assert!(hash(&x) == hash(&y));
}
#[test]

11
src/liballoc/tests/slice.rs
View file

@ -1,14 +1,13 @@
use std::cell::Cell;
use std::cmp::Ordering::{Equal, Greater, Less};
use std::cmp::Ordering;
use std::cmp::Ordering::{self, Equal, Greater, Less};
use std::mem;
use std::panic;
use std::rc::Rc;
use std::sync::atomic::Ordering::Relaxed;
use std::sync::atomic::AtomicUsize;
use std::sync::atomic::{Ordering::Relaxed, AtomicUsize};
use std::thread;
use rand::{Rng, RngCore, thread_rng, seq::SliceRandom};
use rand::{Rng, RngCore, thread_rng};
use rand::seq::SliceRandom;
use rand::distributions::Standard;
fn square(n: usize) -> usize {
@ -476,7 +475,7 @@ fn test_sort_stability() {
// the second item represents which occurrence of that
// number this element is, i.e., the second elements
// will occur in sorted order.
let mut orig: Vec<_> = (0..len)
let orig: Vec<_> = (0..len)
.map(|_| {
let n = thread_rng().gen::<usize>() % 10;
counts[n] += 1;

11
src/liballoc/tests/str.rs
View file

@ -584,7 +584,7 @@ mod slice_index {
}
mod boundary {
const DATA: &'static str = "abcαβγ";
const DATA: &str = "abcαβγ";
const BAD_START: usize = 4;
const GOOD_START: usize = 3;
@ -648,7 +648,7 @@ mod slice_index {
}
}
const LOREM_PARAGRAPH: &'static str = "\
const LOREM_PARAGRAPH: &str = "\
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Suspendisse quis lorem \
sit amet dolor ultricies condimentum. Praesent iaculis purus elit, ac malesuada \
quam malesuada in. Duis sed orci eros. Suspendisse sit amet magna mollis, mollis \
@ -1068,7 +1068,7 @@ fn test_rev_iterator() {
#[test]
fn test_chars_decoding() {
let mut bytes = [0; 4];
for c in (0..0x110000).filter_map(::std::char::from_u32) {
for c in (0..0x110000).filter_map(std::char::from_u32) {
let s = c.encode_utf8(&mut bytes);
if Some(c) != s.chars().next() {
panic!("character {:x}={} does not decode correctly", c as u32, c);
@ -1079,7 +1079,7 @@ fn test_chars_decoding() {
#[test]
fn test_chars_rev_decoding() {
let mut bytes = [0; 4];
for c in (0..0x110000).filter_map(::std::char::from_u32) {
for c in (0..0x110000).filter_map(std::char::from_u32) {
let s = c.encode_utf8(&mut bytes);
if Some(c) != s.chars().rev().next() {
panic!("character {:x}={} does not decode correctly", c as u32, c);
@ -1599,8 +1599,7 @@ fn test_repeat() {
}
mod pattern {
use std::str::pattern::Pattern;
use std::str::pattern::{Searcher, ReverseSearcher};
use std::str::pattern::{Pattern, Searcher, ReverseSearcher};
use std::str::pattern::SearchStep::{self, Match, Reject, Done};
macro_rules! make_test {

4
src/liballoc/tests/string.rs
View file

@ -21,7 +21,7 @@ impl<'a> IntoCow<'a, str> for &'a str {
#[test]
fn test_from_str() {
let owned: Option<::std::string::String> = "string".parse().ok();
let owned: Option<std::string::String> = "string".parse().ok();
assert_eq!(owned.as_ref().map(|s| &**s), Some("string"));
}
@ -122,7 +122,7 @@ fn test_from_utf16() {
let s_as_utf16 = s.encode_utf16().collect::<Vec<u16>>();
let u_as_string = String::from_utf16(&u).unwrap();
assert!(::core::char::decode_utf16(u.iter().cloned()).all(|r| r.is_ok()));
assert!(core::char::decode_utf16(u.iter().cloned()).all(|r| r.is_ok()));
assert_eq!(s_as_utf16, u);
assert_eq!(u_as_string, s);

4
src/liballoc/tests/vec.rs
View file

@ -8,7 +8,7 @@ struct DropCounter<'a> {
count: &'a mut u32,
}
impl<'a> Drop for DropCounter<'a> {
impl Drop for DropCounter<'_> {
fn drop(&mut self) {
*self.count += 1;
}
@ -638,7 +638,7 @@ fn test_splice_unbounded() {
fn test_splice_forget() {
let mut v = vec![1, 2, 3, 4, 5];
let a = [10, 11, 12];
::std::mem::forget(v.splice(2..4, a.iter().cloned()));
std::mem::forget(v.splice(2..4, a.iter().cloned()));
assert_eq!(v, &[1, 2]);
}

15
src/liballoc/tests/vec_deque.rs
View file

@ -1,12 +1,13 @@
use std::collections::VecDeque;
use std::fmt::Debug;
use std::collections::vec_deque::{Drain};
use std::collections::{VecDeque, vec_deque::Drain};
use std::collections::CollectionAllocErr::*;
use std::mem::size_of;
use std::{usize, isize};
use self::Taggy::*;
use self::Taggypar::*;
use crate::hash;
use Taggy::*;
use Taggypar::*;
#[test]
fn test_simple() {
@ -583,7 +584,7 @@ fn test_hash() {
y.push_back(2);
y.push_back(3);
assert!(::hash(&x) == ::hash(&y));
assert!(hash(&x) == hash(&y));
}
#[test]
@ -599,7 +600,7 @@ fn test_hash_after_rotation() {
*elt -= 1;
}
ring.push_back(len - 1);
assert_eq!(::hash(&orig), ::hash(&ring));
assert_eq!(hash(&orig), hash(&ring));
assert_eq!(orig, ring);
assert_eq!(ring, orig);
}
@ -998,7 +999,7 @@ struct DropCounter<'a> {
count: &'a mut u32,
}
impl<'a> Drop for DropCounter<'a> {
impl Drop for DropCounter<'_> {
fn drop(&mut self) {
*self.count += 1;
}

77
src/liballoc/vec.rs
View file

@ -63,18 +63,15 @@ use core::intrinsics::{arith_offset, assume};
use core::iter::{FromIterator, FusedIterator, TrustedLen};
use core::marker::PhantomData;
use core::mem;
use core::ops::{self, Index, IndexMut, RangeBounds};
use core::ops::Bound::{Excluded, Included, Unbounded};
use core::ops::{Index, IndexMut, RangeBounds};
use core::ops;
use core::ptr;
use core::ptr::NonNull;
use core::slice;
use core::ptr::{self, NonNull};
use core::slice::{self, SliceIndex};
use collections::CollectionAllocErr;
use borrow::ToOwned;
use borrow::Cow;
use boxed::Box;
use raw_vec::RawVec;
use crate::borrow::{ToOwned, Cow};
use crate::collections::CollectionAllocErr;
use crate::boxed::Box;
use crate::raw_vec::RawVec;
/// A contiguous growable array type, written `Vec<T>` but pronounced 'vector'.
///
@ -1118,7 +1115,7 @@ impl<T> Vec<T> {
/// assert_eq!(v, &[]);
/// ```
#[stable(feature = "drain", since = "1.6.0")]
pub fn drain<R>(&mut self, range: R) -> Drain<T>
pub fn drain<R>(&mut self, range: R) -> Drain<'_, T>
where R: RangeBounds<usize>
{
// Memory safety
@ -1477,7 +1474,7 @@ impl<'a> SetLenOnDrop<'a> {
}
}
impl<'a> Drop for SetLenOnDrop<'a> {
impl Drop for SetLenOnDrop<'_> {
#[inline]
fn drop(&mut self) {
*self.len = self.local_len;
@ -1646,7 +1643,7 @@ impl<T: Clone> Clone for Vec<T> {
// NB see the slice::hack module in slice.rs for more information
#[cfg(test)]
fn clone(&self) -> Vec<T> {
::slice::to_vec(&**self)
crate::slice::to_vec(&**self)
}
fn clone_from(&mut self, other: &Vec<T>) {
@ -1667,10 +1664,7 @@ impl<T: Hash> Hash for Vec<T> {
message="vector indices are of type `usize` or ranges of `usize`",
label="vector indices are of type `usize` or ranges of `usize`",
)]
impl<T, I> Index<I> for Vec<T>
where
I: ::core::slice::SliceIndex<[T]>,
{
impl<T, I: SliceIndex<[T]>> Index<I> for Vec<T> {
type Output = I::Output;
#[inline]
@ -1684,10 +1678,7 @@ where
message="vector indices are of type `usize` or ranges of `usize`",
label="vector indices are of type `usize` or ranges of `usize`",
)]
impl<T, I> IndexMut<I> for Vec<T>
where
I: ::core::slice::SliceIndex<[T]>,
{
impl<T, I: SliceIndex<[T]>> IndexMut<I> for Vec<T> {
#[inline]
fn index_mut(&mut self, index: I) -> &mut Self::Output {
IndexMut::index_mut(&mut **self, index)
@ -1981,7 +1972,7 @@ impl<T> Vec<T> {
/// ```
#[inline]
#[stable(feature = "vec_splice", since = "1.21.0")]
pub fn splice<R, I>(&mut self, range: R, replace_with: I) -> Splice<I::IntoIter>
pub fn splice<R, I>(&mut self, range: R, replace_with: I) -> Splice<'_, I::IntoIter>
where R: RangeBounds<usize>, I: IntoIterator<Item=T>
{
Splice {
@ -2036,7 +2027,7 @@ impl<T> Vec<T> {
/// assert_eq!(odds, vec![1, 3, 5, 9, 11, 13, 15]);
/// ```
#[unstable(feature = "drain_filter", reason = "recently added", issue = "43244")]
pub fn drain_filter<F>(&mut self, filter: F) -> DrainFilter<T, F>
pub fn drain_filter<F>(&mut self, filter: F) -> DrainFilter<'_, T, F>
where F: FnMut(&mut T) -> bool,
{
let old_len = self.len();
@ -2152,7 +2143,7 @@ impl<T> Default for Vec<T> {
#[stable(feature = "rust1", since = "1.0.0")]
impl<T: fmt::Debug> fmt::Debug for Vec<T> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
fmt::Debug::fmt(&**self, f)
}
}
@ -2193,7 +2184,7 @@ impl<'a, T: Clone> From<&'a [T]> for Vec<T> {
}
#[cfg(test)]
fn from(s: &'a [T]) -> Vec<T> {
::slice::to_vec(s)
crate::slice::to_vec(s)
}
}
@ -2205,7 +2196,7 @@ impl<'a, T: Clone> From<&'a mut [T]> for Vec<T> {
}
#[cfg(test)]
fn from(s: &'a mut [T]) -> Vec<T> {
::slice::to_vec(s)
crate::slice::to_vec(s)
}
}
@ -2295,7 +2286,7 @@ pub struct IntoIter<T> {
#[stable(feature = "vec_intoiter_debug", since = "1.13.0")]
impl<T: fmt::Debug> fmt::Debug for IntoIter<T> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_tuple("IntoIter")
.field(&self.as_slice())
.finish()
@ -2465,7 +2456,7 @@ pub struct Drain<'a, T: 'a> {
#[stable(feature = "collection_debug", since = "1.17.0")]
impl<'a, T: 'a + fmt::Debug> fmt::Debug for Drain<'a, T> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_tuple("Drain")
.field(&self.iter.as_slice())
.finish()
@ -2473,12 +2464,12 @@ impl<'a, T: 'a + fmt::Debug> fmt::Debug for Drain<'a, T> {
}
#[stable(feature = "drain", since = "1.6.0")]
unsafe impl<'a, T: Sync> Sync for Drain<'a, T> {}
unsafe impl<T: Sync> Sync for Drain<'_, T> {}
#[stable(feature = "drain", since = "1.6.0")]
unsafe impl<'a, T: Send> Send for Drain<'a, T> {}
unsafe impl<T: Send> Send for Drain<'_, T> {}
#[stable(feature = "drain", since = "1.6.0")]
impl<'a, T> Iterator for Drain<'a, T> {
impl<T> Iterator for Drain<'_, T> {
type Item = T;
#[inline]
@ -2492,7 +2483,7 @@ impl<'a, T> Iterator for Drain<'a, T> {
}
#[stable(feature = "drain", since = "1.6.0")]
impl<'a, T> DoubleEndedIterator for Drain<'a, T> {
impl<T> DoubleEndedIterator for Drain<'_, T> {
#[inline]
fn next_back(&mut self) -> Option<T> {
self.iter.next_back().map(|elt| unsafe { ptr::read(elt as *const _) })
@ -2500,7 +2491,7 @@ impl<'a, T> DoubleEndedIterator for Drain<'a, T> {
}
#[stable(feature = "drain", since = "1.6.0")]
impl<'a, T> Drop for Drain<'a, T> {
impl<T> Drop for Drain<'_, T> {
fn drop(&mut self) {
// exhaust self first
self.for_each(drop);
@ -2524,14 +2515,14 @@ impl<'a, T> Drop for Drain<'a, T> {
#[stable(feature = "drain", since = "1.6.0")]
impl<'a, T> ExactSizeIterator for Drain<'a, T> {
impl<T> ExactSizeIterator for Drain<'_, T> {
fn is_empty(&self) -> bool {
self.iter.is_empty()
}
}
#[stable(feature = "fused", since = "1.26.0")]
impl<'a, T> FusedIterator for Drain<'a, T> {}
impl<T> FusedIterator for Drain<'_, T> {}
/// A splicing iterator for `Vec`.
///
@ -2548,7 +2539,7 @@ pub struct Splice<'a, I: Iterator + 'a> {
}
#[stable(feature = "vec_splice", since = "1.21.0")]
impl<'a, I: Iterator> Iterator for Splice<'a, I> {
impl<I: Iterator> Iterator for Splice<'_, I> {
type Item = I::Item;
fn next(&mut self) -> Option<Self::Item> {
@ -2561,18 +2552,18 @@ impl<'a, I: Iterator> Iterator for Splice<'a, I> {
}
#[stable(feature = "vec_splice", since = "1.21.0")]
impl<'a, I: Iterator> DoubleEndedIterator for Splice<'a, I> {
impl<I: Iterator> DoubleEndedIterator for Splice<'_, I> {
fn next_back(&mut self) -> Option<Self::Item> {
self.drain.next_back()
}
}
#[stable(feature = "vec_splice", since = "1.21.0")]
impl<'a, I: Iterator> ExactSizeIterator for Splice<'a, I> {}
impl<I: Iterator> ExactSizeIterator for Splice<'_, I> {}
#[stable(feature = "vec_splice", since = "1.21.0")]
impl<'a, I: Iterator> Drop for Splice<'a, I> {
impl<I: Iterator> Drop for Splice<'_, I> {
fn drop(&mut self) {
self.drain.by_ref().for_each(drop);
@ -2613,7 +2604,7 @@ impl<'a, I: Iterator> Drop for Splice<'a, I> {
}
/// Private helper methods for `Splice::drop`
impl<'a, T> Drain<'a, T> {
impl<T> Drain<'_, T> {
/// The range from `self.vec.len` to `self.tail_start` contains elements
/// that have been moved out.
/// Fill that range as much as possible with new elements from the `replace_with` iterator.
@ -2654,7 +2645,7 @@ impl<'a, T> Drain<'a, T> {
/// An iterator produced by calling `drain_filter` on Vec.
#[unstable(feature = "drain_filter", reason = "recently added", issue = "43244")]
#[derive(Debug)]
pub struct DrainFilter<'a, T: 'a, F>
pub struct DrainFilter<'a, T, F>
where F: FnMut(&mut T) -> bool,
{
vec: &'a mut Vec<T>,
@ -2665,7 +2656,7 @@ pub struct DrainFilter<'a, T: 'a, F>
}
#[unstable(feature = "drain_filter", reason = "recently added", issue = "43244")]
impl<'a, T, F> Iterator for DrainFilter<'a, T, F>
impl<T, F> Iterator for DrainFilter<'_, T, F>
where F: FnMut(&mut T) -> bool,
{
type Item = T;
@ -2699,7 +2690,7 @@ impl<'a, T, F> Iterator for DrainFilter<'a, T, F>
}
#[unstable(feature = "drain_filter", reason = "recently added", issue = "43244")]
impl<'a, T, F> Drop for DrainFilter<'a, T, F>
impl<T, F> Drop for DrainFilter<'_, T, F>
where F: FnMut(&mut T) -> bool,
{
fn drop(&mut self) {

2
src/test/run-make-fulldeps/alloc-extern-crates/Makefile
View file

@ -2,4 +2,4 @@
all:
$(RUSTC) fakealloc.rs
$(RUSTC) --crate-type=rlib ../../../liballoc/lib.rs --cfg feature=\"external_crate\" --extern external=$(TMPDIR)/$(shell $(RUSTC) --print file-names fakealloc.rs)
$(RUSTC) --edition=2018 --crate-type=rlib ../../../liballoc/lib.rs --cfg feature=\"external_crate\" --extern external=$(TMPDIR)/$(shell $(RUSTC) --print file-names fakealloc.rs)