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

Auto merge of #88611 - m-ou-se:array-into-iter-new-deprecate, r=joshtriplett

Browse Source 
Deprecate array::IntoIter::new.
This commit is contained in:
bors 2021-12-05 12:53:01 +00:00
commit 1597728ef5
25 changed files with 69 additions and 99 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
compiler/rustc_ast_lowering/src/lib.rs
View File

@ -70,10 +70,9 @@
use tracing::{debug, trace};
macro_rules! arena_vec {
($this:expr; $($x:expr),*) => ({
let a = [$($x),*];
$this.arena.alloc_from_iter(std::array::IntoIter::new(a))
});
($this:expr; $($x:expr),*) => (
$this.arena.alloc_from_iter([$($x),*])
);
}
mod asm;

4
compiler/rustc_codegen_cranelift/scripts/cargo.rs
View File

@ -42,7 +42,7 @@ fn main() {
"RUSTFLAGS",
env::var("RUSTFLAGS").unwrap_or(String::new()) + " -Cprefer-dynamic",
);
std::array::IntoIter::new(["rustc".to_string()])
IntoIterator::into_iter(["rustc".to_string()])
.chain(env::args().skip(2))
.chain([
"--".to_string(),
@ -56,7 +56,7 @@ fn main() {
"RUSTFLAGS",
env::var("RUSTFLAGS").unwrap_or(String::new()) + " -Cprefer-dynamic",
);
std::array::IntoIter::new(["rustc".to_string()])
IntoIterator::into_iter(["rustc".to_string()])
.chain(env::args().skip(2))
.chain([
"--".to_string(),

5
compiler/rustc_expand/src/proc_macro_server.rs
View File

@ -466,13 +466,12 @@ fn expand_expr(&mut self, stream: &Self::TokenStream) -> Result<Self::TokenStrea
ast::ExprKind::Unary(ast::UnOp::Neg, e) => match &e.kind {
ast::ExprKind::Lit(l) => match l.token {
token::Lit { kind: token::Integer | token::Float, .. } => {
Ok(std::array::IntoIter::new([
Ok(Self::TokenStream::from_iter([
// FIXME: The span of the `-` token is lost when
// parsing, so we cannot faithfully recover it here.
tokenstream::TokenTree::token(token::BinOp(token::Minus), e.span),
tokenstream::TokenTree::token(token::Literal(l.token), l.span),
])
.collect())
]))
}
_ => Err(()),
},

6
compiler/rustc_hir/src/def.rs
View File

@ -443,11 +443,11 @@ pub fn map<U, F: FnMut(T) -> U>(self, mut f: F) -> PerNS<U> {
}
pub fn into_iter(self) -> IntoIter<T, 3> {
IntoIter::new([self.value_ns, self.type_ns, self.macro_ns])
[self.value_ns, self.type_ns, self.macro_ns].into_iter()
}
pub fn iter(&self) -> IntoIter<&T, 3> {
IntoIter::new([&self.value_ns, &self.type_ns, &self.macro_ns])
[&self.value_ns, &self.type_ns, &self.macro_ns].into_iter()
}
}
@ -481,7 +481,7 @@ pub fn is_empty(&self) -> bool {
/// Returns an iterator over the items which are `Some`.
pub fn present_items(self) -> impl Iterator<Item = T> {
IntoIter::new([self.type_ns, self.value_ns, self.macro_ns]).flatten()
[self.type_ns, self.value_ns, self.macro_ns].into_iter().flatten()
}
}

4
compiler/rustc_session/src/filesearch.rs
View File

@ -4,6 +4,7 @@
use std::env;
use std::fs;
use std::iter::FromIterator;
use std::path::{Path, PathBuf};
use crate::search_paths::{PathKind, SearchPath, SearchPathFile};
@ -91,8 +92,7 @@ pub fn search_path_dirs(&self) -> Vec<PathBuf> {
pub fn make_target_lib_path(sysroot: &Path, target_triple: &str) -> PathBuf {
let rustlib_path = rustc_target::target_rustlib_path(sysroot, target_triple);
std::array::IntoIter::new([sysroot, Path::new(&rustlib_path), Path::new("lib")])
.collect::<PathBuf>()
PathBuf::from_iter([sysroot, Path::new(&rustlib_path), Path::new("lib")])
}
/// This function checks if sysroot is found using env::args().next(), and if it

5
compiler/rustc_session/src/session.rs
View File

@ -792,12 +792,11 @@ pub fn host_filesearch(&self, kind: PathKind) -> filesearch::FileSearch<'_> {
/// Returns a list of directories where target-specific tool binaries are located.
pub fn get_tools_search_paths(&self, self_contained: bool) -> Vec<PathBuf> {
let rustlib_path = rustc_target::target_rustlib_path(&self.sysroot, &config::host_triple());
let p = std::array::IntoIter::new([
let p = PathBuf::from_iter([
Path::new(&self.sysroot),
Path::new(&rustlib_path),
Path::new("bin"),
])
.collect::<PathBuf>();
]);
if self_contained { vec![p.clone(), p.join("self-contained")] } else { vec![p] }
}

4
compiler/rustc_target/src/lib.rs
View File

@ -16,6 +16,7 @@
#![feature(min_specialization)]
#![feature(step_trait)]
use std::iter::FromIterator;
use std::path::{Path, PathBuf};
#[macro_use]
@ -47,12 +48,11 @@ pub trait HashStableContext {}
/// `"lib*/rustlib/x86_64-unknown-linux-gnu"`.
pub fn target_rustlib_path(sysroot: &Path, target_triple: &str) -> PathBuf {
let libdir = find_libdir(sysroot);
std::array::IntoIter::new([
PathBuf::from_iter([
Path::new(libdir.as_ref()),
Path::new(RUST_LIB_DIR),
Path::new(target_triple),
])
.collect::<PathBuf>()
}
/// The name of the directory rustc expects libraries to be located.

6
compiler/rustc_target/src/spec/mod.rs
View File

@ -42,6 +42,7 @@
use rustc_span::symbol::{sym, Symbol};
use std::collections::BTreeMap;
use std::convert::TryFrom;
use std::iter::FromIterator;
use std::ops::{Deref, DerefMut};
use std::path::{Path, PathBuf};
use std::str::FromStr;
@ -2173,12 +2174,11 @@ fn load_file(path: &Path) -> Result<(Target, TargetWarnings), String> {
// Additionally look in the sysroot under `lib/rustlib/<triple>/target.json`
// as a fallback.
let rustlib_path = crate::target_rustlib_path(&sysroot, &target_triple);
let p = std::array::IntoIter::new([
let p = PathBuf::from_iter([
Path::new(sysroot),
Path::new(&rustlib_path),
Path::new("target.json"),
])
.collect::<PathBuf>();
]);
if p.is_file() {
return load_file(&p);
}

8
compiler/rustc_trait_selection/src/traits/object_safety.rs
View File

@ -25,7 +25,6 @@
use rustc_span::{MultiSpan, Span};
use smallvec::SmallVec;
use std::array;
use std::iter;
use std::ops::ControlFlow;
@ -692,11 +691,8 @@ fn receiver_is_dispatchable<'tcx>(
.to_predicate(tcx)
};
let caller_bounds: Vec<Predicate<'tcx>> = param_env
.caller_bounds()
.iter()
.chain(array::IntoIter::new([unsize_predicate, trait_predicate]))
.collect();
let caller_bounds: Vec<Predicate<'tcx>> =
param_env.caller_bounds().iter().chain([unsize_predicate, trait_predicate]).collect();
ty::ParamEnv::new(tcx.intern_predicates(&caller_bounds), param_env.reveal())
};

3
compiler/rustc_typeck/src/astconv/mod.rs
View File

@ -35,7 +35,6 @@
use rustc_trait_selection::traits::wf::object_region_bounds;
use smallvec::SmallVec;
use std::array;
use std::collections::BTreeSet;
use std::slice;
@ -1635,7 +1634,7 @@ fn one_bound_for_assoc_type<I>(
debug!("one_bound_for_assoc_type: bound2 = {:?}", bound2);
let is_equality = is_equality();
let bounds = array::IntoIter::new([bound, bound2]).chain(matching_candidates);
let bounds = IntoIterator::into_iter([bound, bound2]).chain(matching_candidates);
let mut err = if is_equality.is_some() {
// More specific Error Index entry.
struct_span_err!(

2
compiler/rustc_typeck/src/check/wfcheck.rs
View File

@ -1822,7 +1822,7 @@ pub(super) fn impl_implied_bounds(
// Inherent impl: take implied bounds from the `self` type.
let self_ty = self.tcx.type_of(impl_def_id);
let self_ty = self.normalize_associated_types_in(span, self_ty);
std::array::IntoIter::new([self_ty]).collect()
FxHashSet::from_iter([self_ty])
}
}
}

2
library/alloc/src/collections/binary_heap.rs
View File

@ -1500,7 +1500,7 @@ fn from(vec: Vec<T>) -> BinaryHeap<T> {
/// }
/// ```
fn from(arr: [T; N]) -> Self {
core::array::IntoIter::new(arr).collect()
Self::from_iter(arr)
}
}

8
library/alloc/src/collections/btree/map.rs
View File

@ -1305,11 +1305,11 @@ pub fn into_values(self) -> IntoValues<K, V> {
pub(crate) fn bulk_build_from_sorted_iter<I>(iter: I) -> Self
where
K: Ord,
I: Iterator<Item = (K, V)>,
I: IntoIterator<Item = (K, V)>,
{
let mut root = Root::new();
let mut length = 0;
root.bulk_push(DedupSortedIter::new(iter), &mut length);
root.bulk_push(DedupSortedIter::new(iter.into_iter()), &mut length);
BTreeMap { root: Some(root), length }
}
}
@ -1944,7 +1944,7 @@ fn from_iter<T: IntoIterator<Item = (K, V)>>(iter: T) -> BTreeMap<K, V> {
// use stable sort to preserve the insertion order.
inputs.sort_by(|a, b| a.0.cmp(&b.0));
BTreeMap::bulk_build_from_sorted_iter(inputs.into_iter())
BTreeMap::bulk_build_from_sorted_iter(inputs)
}
}
@ -2061,7 +2061,7 @@ fn index(&self, key: &Q) -> &V {
// use stable sort to preserve the insertion order.
arr.sort_by(|a, b| a.0.cmp(&b.0));
BTreeMap::bulk_build_from_sorted_iter(core::array::IntoIter::new(arr))
BTreeMap::bulk_build_from_sorted_iter(arr)
}
}

2
library/alloc/src/collections/btree/set.rs
View File

@ -1106,7 +1106,7 @@ fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> BTreeSet<T> {
// use stable sort to preserve the insertion order.
arr.sort();
let iter = core::array::IntoIter::new(arr).map(|k| (k, ()));
let iter = IntoIterator::into_iter(arr).map(|k| (k, ()));
let map = BTreeMap::bulk_build_from_sorted_iter(iter);
BTreeSet { map }
}

2
library/alloc/src/collections/linked_list.rs
View File

@ -1961,7 +1961,7 @@ fn hash<H: Hasher>(&self, state: &mut H) {
/// assert_eq!(list1, list2);
/// ```
fn from(arr: [T; N]) -> Self {
core::array::IntoIter::new(arr).collect()
Self::from_iter(arr)
}
}

50
library/core/src/array/iter.rs
View File

@ -34,30 +34,23 @@ pub struct IntoIter<T, const N: usize> {
alive: Range<usize>,
}
impl<T, const N: usize> IntoIter<T, N> {
/// Creates a new iterator over the given `array`.
// Note: the `#[rustc_skip_array_during_method_dispatch]` on `trait IntoIterator`
// hides this implementation from explicit `.into_iter()` calls on editions < 2021,
// so those calls will still resolve to the slice implementation, by reference.
#[stable(feature = "array_into_iter_impl", since = "1.53.0")]
impl<T, const N: usize> IntoIterator for [T; N] {
type Item = T;
type IntoIter = IntoIter<T, N>;
/// Creates a consuming iterator, that is, one that moves each value out of
/// the array (from start to end). The array cannot be used after calling
/// this unless `T` implements `Copy`, so the whole array is copied.
///
/// *Note*: this method might be deprecated in the future,
/// since [`IntoIterator`] is now implemented for arrays.
/// Arrays have special behavior when calling `.into_iter()` prior to the
/// 2021 edition -- see the [array] Editions section for more information.
///
/// # Examples
///
/// ```
/// use std::array;
///
/// for value in array::IntoIter::new([1, 2, 3, 4, 5]) {
/// // The type of `value` is an `i32` here, instead of `&i32`
/// let _: i32 = value;
/// }
///
/// // Since Rust 1.53, arrays implement IntoIterator directly:
/// for value in [1, 2, 3, 4, 5] {
/// // The type of `value` is an `i32` here, instead of `&i32`
/// let _: i32 = value;
/// }
/// ```
#[stable(feature = "array_value_iter", since = "1.51.0")]
pub fn new(array: [T; N]) -> Self {
/// [array]: prim@array
fn into_iter(self) -> Self::IntoIter {
// SAFETY: The transmute here is actually safe. The docs of `MaybeUninit`
// promise:
//
@ -76,11 +69,20 @@ impl<T, const N: usize> IntoIter<T, N> {
// Until then, we can use `mem::transmute_copy` to create a bitwise copy
// as a different type, then forget `array` so that it is not dropped.
unsafe {
let iter = Self { data: mem::transmute_copy(&array), alive: 0..N };
mem::forget(array);
let iter = IntoIter { data: mem::transmute_copy(&self), alive: 0..N };
mem::forget(self);
iter
}
}
}
impl<T, const N: usize> IntoIter<T, N> {
/// Creates a new iterator over the given `array`.
#[stable(feature = "array_value_iter", since = "1.51.0")]
#[rustc_deprecated(since = "1.59.0", reason = "use `IntoIterator::into_iter` instead")]
pub fn new(array: [T; N]) -> Self {
IntoIterator::into_iter(array)
}
/// Returns an immutable slice of all elements that have not been yielded
/// yet.

21
library/core/src/array/mod.rs
View File

@ -243,27 +243,6 @@ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
}
}
// Note: the `#[rustc_skip_array_during_method_dispatch]` on `trait IntoIterator`
// hides this implementation from explicit `.into_iter()` calls on editions < 2021,
// so those calls will still resolve to the slice implementation, by reference.
#[stable(feature = "array_into_iter_impl", since = "1.53.0")]
impl<T, const N: usize> IntoIterator for [T; N] {
type Item = T;
type IntoIter = IntoIter<T, N>;
/// Creates a consuming iterator, that is, one that moves each value out of
/// the array (from start to end). The array cannot be used after calling
/// this unless `T` implements `Copy`, so the whole array is copied.
///
/// Arrays have special behavior when calling `.into_iter()` prior to the
/// 2021 edition -- see the [array] Editions section for more information.
///
/// [array]: prim@array
fn into_iter(self) -> Self::IntoIter {
IntoIter::new(self)
}
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<'a, T, const N: usize> IntoIterator for &'a [T; N] {
type Item = &'a T;

3
library/core/src/primitive_docs.rs
View File

@ -606,8 +606,7 @@ mod prim_pointer {}
/// println!("array[{}] = {}", i, x);
/// }
///
/// // You can explicitly iterate an array by value using
/// // `IntoIterator::into_iter` or `std::array::IntoIter::new`:
/// // You can explicitly iterate an array by value using `IntoIterator::into_iter`
/// for item in IntoIterator::into_iter(array).enumerate() {
/// let (i, x): (usize, i32) = item;
/// println!("array[{}] = {}", i, x);

11
library/core/tests/iter/adapters/flatten.rs
View File

@ -1,5 +1,4 @@
use super::*;
use core::array;
use core::iter::*;
#[test]
@ -134,7 +133,7 @@ fn test_double_ended_flatten() {
#[test]
fn test_trusted_len_flatten() {
fn assert_trusted_len<T: TrustedLen>(_: &T) {}
let mut iter = array::IntoIter::new([[0; 3]; 4]).flatten();
let mut iter = IntoIterator::into_iter([[0; 3]; 4]).flatten();
assert_trusted_len(&iter);
assert_eq!(iter.size_hint(), (12, Some(12)));
@ -143,21 +142,21 @@ fn assert_trusted_len<T: TrustedLen>(_: &T) {}
iter.next_back();
assert_eq!(iter.size_hint(), (10, Some(10)));
let iter = array::IntoIter::new([[(); usize::MAX]; 1]).flatten();
let iter = IntoIterator::into_iter([[(); usize::MAX]; 1]).flatten();
assert_eq!(iter.size_hint(), (usize::MAX, Some(usize::MAX)));
let iter = array::IntoIter::new([[(); usize::MAX]; 2]).flatten();
let iter = IntoIterator::into_iter([[(); usize::MAX]; 2]).flatten();
assert_eq!(iter.size_hint(), (usize::MAX, None));
let mut a = [(); 10];
let mut b = [(); 10];
let iter = array::IntoIter::new([&mut a, &mut b]).flatten();
let iter = IntoIterator::into_iter([&mut a, &mut b]).flatten();
assert_trusted_len(&iter);
assert_eq!(iter.size_hint(), (20, Some(20)));
core::mem::drop(iter);
let iter = array::IntoIter::new([&a, &b]).flatten();
let iter = IntoIterator::into_iter([&a, &b]).flatten();
assert_trusted_len(&iter);
assert_eq!(iter.size_hint(), (20, Some(20)));

2
library/std/src/collections/hash/map.rs
View File

@ -1186,7 +1186,7 @@ fn index(&self, key: &Q) -> &V {
/// assert_eq!(map1, map2);
/// ```
fn from(arr: [(K, V); N]) -> Self {
crate::array::IntoIter::new(arr).collect()
Self::from_iter(arr)
}
}

2
library/std/src/collections/hash/set.rs
View File

@ -1022,7 +1022,7 @@ fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> HashSet<T, S> {
/// assert_eq!(set1, set2);
/// ```
fn from(arr: [T; N]) -> Self {
crate::array::IntoIter::new(arr).collect()
Self::from_iter(arr)
}
}

3
library/std/src/primitive_docs.rs
View File

@ -606,8 +606,7 @@ mod prim_pointer {}
/// println!("array[{}] = {}", i, x);
/// }
///
/// // You can explicitly iterate an array by value using
/// // `IntoIterator::into_iter` or `std::array::IntoIter::new`:
/// // You can explicitly iterate an array by value using `IntoIterator::into_iter`
/// for item in IntoIterator::into_iter(array).enumerate() {
/// let (i, x): (usize, i32) = item;
/// println!("array[{}] = {}", i, x);

2
src/bootstrap/lib.rs
View File

@ -1043,7 +1043,7 @@ fn lld_flags(&self, target: TargetSelection) -> impl Iterator<Item = String> {
options[1] = Some(format!("-Clink-arg=-Wl,{}", threads));
}
std::array::IntoIter::new(options).flatten()
IntoIterator::into_iter(options).flatten()
}
/// Returns if this target should statically link the C runtime, if specified

3
src/test/ui/proc-macro/auxiliary/custom-quote.rs
View File

@ -6,6 +6,7 @@
#![crate_type = "proc-macro"]
extern crate proc_macro;
use std::iter::FromIterator;
use std::str::FromStr;
use proc_macro::*;
@ -23,7 +24,7 @@ pub fn custom_quote(input: TokenStream) -> TokenStream {
let set_span_method = TokenStream::from_str("ident.set_span").unwrap();
let set_span_arg = TokenStream::from(TokenTree::Group(Group::new(Delimiter::Parenthesis, quoted_span)));
let suffix = TokenStream::from_str(";proc_macro::TokenStream::from(proc_macro::TokenTree::Ident(ident))").unwrap();
let full_stream: TokenStream = std::array::IntoIter::new([prefix, set_span_method, set_span_arg, suffix]).collect();
let full_stream = TokenStream::from_iter([prefix, set_span_method, set_span_arg, suffix]);
full_stream
}
_ => unreachable!()

3
src/tools/clippy/clippy_lints/src/matches.rs
View File

@ -13,7 +13,6 @@
remove_blocks, strip_pat_refs,
};
use clippy_utils::{paths, search_same, SpanlessEq, SpanlessHash};
use core::array;
use core::iter::{once, ExactSizeIterator};
use if_chain::if_chain;
use rustc_ast::ast::{Attribute, LitKind};
@ -1306,7 +1305,7 @@ fn check_match_like_matches<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>)
return find_matches_sugg(
cx,
let_expr,
array::IntoIter::new([(&[][..], Some(let_pat), if_then, None), (&[][..], None, if_else, None)]),
IntoIterator::into_iter([(&[][..], Some(let_pat), if_then, None), (&[][..], None, if_else, None)]),
expr,
true,
);