OpenE2K/rust
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Auto merge of #72378 - Dylan-DPC:rollup-m87bp2d, r=Dylan-DPC

Browse Source 
Rollup of 6 pull requests

Successful merges:

 - #71863 (Suggest fixes and add error recovery for `use foo::self`)
 - #72139 (Make `fold` standalone.)
 - #72275 (Continue lowering for unsupported async generator instead of returning an error.)
 - #72361 (split_inclusive: add tracking issue number (72360))
 - #72364 (Remove unused dependencies)
 - #72366 (Adjust the zero check in `RawVec::grow`.)

Failed merges:

r? @ghost
This commit is contained in:
bors 2020-05-20 19:29:01 +00:00
commit 0aa6751c19
28 changed files with 415 additions and 110 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
Cargo.lock
View File

@ -4088,7 +4088,6 @@ dependencies = [
"log",
"measureme",
"polonius-engine",
"rustc-rayon",
"rustc-rayon-core",
"rustc_apfloat",
"rustc_ast",
@ -4151,7 +4150,6 @@ dependencies = [
"rustc_hir",
"rustc_index",
"rustc_infer",
"rustc_macros",
"rustc_middle",
"rustc_session",
"rustc_span",
@ -4295,7 +4293,6 @@ dependencies = [
"rustc_errors",
"rustc_feature",
"rustc_fs_util",
"rustc_index",
"rustc_span",
"rustc_target",
"serialize",
@ -4328,7 +4325,6 @@ dependencies = [
"rustc_ast",
"rustc_data_structures",
"rustc_hir",
"rustc_metadata",
"rustc_middle",
"rustc_session",
"rustc_span",

7
src/liballoc/raw_vec.rs
View File

@ -401,16 +401,15 @@ impl<T, A: AllocRef> RawVec<T, A> {
needed_extra_capacity: usize,
placement: ReallocPlacement,
) -> Result<(), TryReserveError> {
// This is ensured by the calling contexts.
debug_assert!(needed_extra_capacity > 0);
if mem::size_of::<T>() == 0 {
// Since we return a capacity of `usize::MAX` when `elem_size` is
// 0, getting to here necessarily means the `RawVec` is overfull.
return Err(CapacityOverflow);
}
if needed_extra_capacity == 0 {
return Ok(());
}
// Nothing we can really do about these checks, sadly.
let required_cap =
used_capacity.checked_add(needed_extra_capacity).ok_or(CapacityOverflow)?;

144
src/libcore/iter/adapters/mod.rs
View File

@ -512,6 +512,9 @@ where
acc = self.iter.try_fold(acc, &mut f)?;
}
}
// No `fold` override, because `fold` doesn't make much sense for `Cycle`,
// and we can't do anything better than the default.
}
#[stable(feature = "fused", since = "1.26.0")]
@ -643,6 +646,25 @@ where
}
from_fn(nth(&mut self.iter, self.step)).try_fold(acc, f)
}
fn fold<Acc, F>(mut self, mut acc: Acc, mut f: F) -> Acc
where
F: FnMut(Acc, Self::Item) -> Acc,
{
#[inline]
fn nth<I: Iterator>(iter: &mut I, step: usize) -> impl FnMut() -> Option<I::Item> + '_ {
move || iter.nth(step)
}
if self.first_take {
self.first_take = false;
match self.iter.next() {
None => return acc,
Some(x) => acc = f(acc, x),
}
}
from_fn(nth(&mut self.iter, self.step)).fold(acc, f)
}
}
impl<I> StepBy<I>
@ -702,6 +724,29 @@ where
}
}
}
#[inline]
fn rfold<Acc, F>(mut self, init: Acc, mut f: F) -> Acc
where
Self: Sized,
F: FnMut(Acc, Self::Item) -> Acc,
{
#[inline]
fn nth_back<I: DoubleEndedIterator>(
iter: &mut I,
step: usize,
) -> impl FnMut() -> Option<I::Item> + '_ {
move || iter.nth_back(step)
}
match self.next_back() {
None => init,
Some(x) => {
let acc = f(init, x);
from_fn(nth_back(&mut self.iter, self.step)).fold(acc, f)
}
}
}
}
// StepBy can only make the iterator shorter, so the len will still fit.
@ -1767,6 +1812,20 @@ where
self.iter.try_fold(init, check(flag, p, fold)).into_try()
}
}
#[inline]
fn fold<Acc, Fold>(mut self, init: Acc, fold: Fold) -> Acc
where
Self: Sized,
Fold: FnMut(Acc, Self::Item) -> Acc,
{
#[inline]
fn ok<B, T>(mut f: impl FnMut(B, T) -> B) -> impl FnMut(B, T) -> Result<B, !> {
move |acc, x| Ok(f(acc, x))
}
self.try_fold(init, ok(fold)).unwrap()
}
}
#[stable(feature = "fused", since = "1.26.0")]
@ -1838,6 +1897,20 @@ where
})
.into_try()
}
#[inline]
fn fold<Acc, Fold>(mut self, init: Acc, fold: Fold) -> Acc
where
Self: Sized,
Fold: FnMut(Acc, Self::Item) -> Acc,
{
#[inline]
fn ok<B, T>(mut f: impl FnMut(B, T) -> B) -> impl FnMut(B, T) -> Result<B, !> {
move |acc, x| Ok(f(acc, x))
}
self.try_fold(init, ok(fold)).unwrap()
}
}
/// An iterator that skips over `n` elements of `iter`.
@ -2006,6 +2079,18 @@ where
self.iter.try_rfold(init, check(n, fold)).into_try()
}
}
fn rfold<Acc, Fold>(mut self, init: Acc, fold: Fold) -> Acc
where
Fold: FnMut(Acc, Self::Item) -> Acc,
{
#[inline]
fn ok<Acc, T>(mut f: impl FnMut(Acc, T) -> Acc) -> impl FnMut(Acc, T) -> Result<Acc, !> {
move |acc, x| Ok(f(acc, x))
}
self.try_rfold(init, ok(fold)).unwrap()
}
}
#[stable(feature = "fused", since = "1.26.0")]
@ -2105,6 +2190,20 @@ where
self.iter.try_fold(init, check(n, fold)).into_try()
}
}
#[inline]
fn fold<Acc, Fold>(mut self, init: Acc, fold: Fold) -> Acc
where
Self: Sized,
Fold: FnMut(Acc, Self::Item) -> Acc,
{
#[inline]
fn ok<B, T>(mut f: impl FnMut(B, T) -> B) -> impl FnMut(B, T) -> Result<B, !> {
move |acc, x| Ok(f(acc, x))
}
self.try_fold(init, ok(fold)).unwrap()
}
}
#[stable(feature = "double_ended_take_iterator", since = "1.38.0")]
@ -2156,6 +2255,24 @@ where
}
}
}
#[inline]
fn rfold<Acc, Fold>(mut self, init: Acc, fold: Fold) -> Acc
where
Self: Sized,
Fold: FnMut(Acc, Self::Item) -> Acc,
{
if self.n == 0 {
init
} else {
let len = self.iter.len();
if len > self.n && self.iter.nth_back(len - self.n - 1).is_none() {
init
} else {
self.iter.rfold(init, fold)
}
}
}
}
#[stable(feature = "rust1", since = "1.0.0")]
@ -2237,6 +2354,20 @@ where
let f = &mut self.f;
self.iter.try_fold(init, scan(state, f, fold)).into_try()
}
#[inline]
fn fold<Acc, Fold>(mut self, init: Acc, fold: Fold) -> Acc
where
Self: Sized,
Fold: FnMut(Acc, Self::Item) -> Acc,
{
#[inline]
fn ok<B, T>(mut f: impl FnMut(B, T) -> B) -> impl FnMut(B, T) -> Result<B, !> {
move |acc, x| Ok(f(acc, x))
}
self.try_fold(init, ok(fold)).unwrap()
}
}
/// An iterator that calls a function with a reference to each element before
@ -2444,4 +2575,17 @@ where
})
.into_try()
}
fn fold<B, F>(mut self, init: B, fold: F) -> B
where
Self: Sized,
F: FnMut(B, Self::Item) -> B,
{
#[inline]
fn ok<B, T>(mut f: impl FnMut(B, T) -> B) -> impl FnMut(B, T) -> Result<B, !> {
move |acc, x| Ok(f(acc, x))
}
self.try_fold(init, ok(fold)).unwrap()
}
}

28
src/libcore/iter/range.rs
View File

@ -658,6 +658,20 @@ impl<A: Step> Iterator for ops::RangeInclusive<A> {
Try::from_ok(accum)
}
#[inline]
fn fold<B, F>(mut self, init: B, f: F) -> B
where
Self: Sized,
F: FnMut(B, Self::Item) -> B,
{
#[inline]
fn ok<B, T>(mut f: impl FnMut(B, T) -> B) -> impl FnMut(B, T) -> Result<B, !> {
move |acc, x| Ok(f(acc, x))
}
self.try_fold(init, ok(f)).unwrap()
}
#[inline]
fn last(mut self) -> Option<A> {
self.next_back()
@ -746,6 +760,20 @@ impl<A: Step> DoubleEndedIterator for ops::RangeInclusive<A> {
Try::from_ok(accum)
}
#[inline]
fn rfold<B, F>(mut self, init: B, f: F) -> B
where
Self: Sized,
F: FnMut(B, Self::Item) -> B,
{
#[inline]
fn ok<B, T>(mut f: impl FnMut(B, T) -> B) -> impl FnMut(B, T) -> Result<B, !> {
move |acc, x| Ok(f(acc, x))
}
self.try_rfold(init, ok(f)).unwrap()
}
}
#[unstable(feature = "trusted_len", issue = "37572")]

11
src/libcore/iter/traits/double_ended.rs
View File

@ -221,17 +221,16 @@ pub trait DoubleEndedIterator: Iterator {
/// ```
#[inline]
#[stable(feature = "iter_rfold", since = "1.27.0")]
fn rfold<B, F>(mut self, accum: B, f: F) -> B
fn rfold<B, F>(mut self, init: B, mut f: F) -> B
where
Self: Sized,
F: FnMut(B, Self::Item) -> B,
{
#[inline]
fn ok<B, T>(mut f: impl FnMut(B, T) -> B) -> impl FnMut(B, T) -> Result<B, !> {
move |acc, x| Ok(f(acc, x))
let mut accum = init;
while let Some(x) = self.next_back() {
accum = f(accum, x);
}
self.try_rfold(accum, ok(f)).unwrap()
accum
}
/// Searches for an element of an iterator from the back that satisfies a predicate.

36
src/libcore/iter/traits/iterator.rs
View File

@ -1697,8 +1697,8 @@ pub trait Iterator {
mut f: impl FnMut(&T) -> bool + 'a,
left: &'a mut B,
right: &'a mut B,
) -> impl FnMut(T) + 'a {
move |x| {
) -> impl FnMut((), T) + 'a {
move |(), x| {
if f(&x) {
left.extend(Some(x));
} else {
@ -1710,7 +1710,7 @@ pub trait Iterator {
let mut left: B = Default::default();
let mut right: B = Default::default();
self.for_each(extend(f, &mut left, &mut right));
self.fold((), extend(f, &mut left, &mut right));
(left, right)
}
@ -1826,7 +1826,7 @@ pub trait Iterator {
///
/// # Note to Implementors
///
/// Most of the other (forward) methods have default implementations in
/// Several of the other (forward) methods have default implementations in
/// terms of this one, so try to implement this explicitly if it can
/// do something better than the default `for` loop implementation.
///
@ -1944,6 +1944,15 @@ pub trait Iterator {
/// may not terminate for infinite iterators, even on traits for which a
/// result is determinable in finite time.
///
/// # Note to Implementors
///
/// Several of the other (forward) methods have default implementations in
/// terms of this one, so try to implement this explicitly if it can
/// do something better than the default `for` loop implementation.
///
/// In particular, try to have this call `fold()` on the internal parts
/// from which this iterator is composed.
///
/// # Examples
///
/// Basic usage:
@ -1992,17 +2001,16 @@ pub trait Iterator {
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
fn fold<B, F>(mut self, init: B, f: F) -> B
fn fold<B, F>(mut self, init: B, mut f: F) -> B
where
Self: Sized,
F: FnMut(B, Self::Item) -> B,
{
#[inline]
fn ok<B, T>(mut f: impl FnMut(B, T) -> B) -> impl FnMut(B, T) -> Result<B, !> {
move |acc, x| Ok(f(acc, x))
let mut accum = init;
while let Some(x) = self.next() {
accum = f(accum, x);
}
self.try_fold(init, ok(f)).unwrap()
accum
}
/// The same as [`fold()`](#method.fold), but uses the first element in the
@ -2273,7 +2281,7 @@ pub trait Iterator {
F: FnMut(&Self::Item) -> R,
R: Try<Ok = bool, Error = E>,
{
self.try_for_each(move |x| match f(&x).into_result() {
self.try_fold((), move |(), x| match f(&x).into_result() {
Ok(false) => LoopState::Continue(()),
Ok(true) => LoopState::Break(Ok(x)),
Err(x) => LoopState::Break(Err(x)),
@ -2665,8 +2673,8 @@ pub trait Iterator {
fn extend<'a, A, B>(
ts: &'a mut impl Extend<A>,
us: &'a mut impl Extend<B>,
) -> impl FnMut((A, B)) + 'a {
move |(t, u)| {
) -> impl FnMut((), (A, B)) + 'a {
move |(), (t, u)| {
ts.extend(Some(t));
us.extend(Some(u));
}
@ -2675,7 +2683,7 @@ pub trait Iterator {
let mut ts: FromA = Default::default();
let mut us: FromB = Default::default();
self.for_each(extend(&mut ts, &mut us));
self.fold((), extend(&mut ts, &mut us));
(ts, us)
}

26
src/libcore/slice/mod.rs
View File

@ -1169,7 +1169,7 @@ impl<T> [T] {
/// assert_eq!(iter.next().unwrap(), &[10, 40, 33]);
/// assert!(iter.next().is_none());
/// ```
#[unstable(feature = "split_inclusive", issue = "none")]
#[unstable(feature = "split_inclusive", issue = "72360")]
#[inline]
pub fn split_inclusive<F>(&self, pred: F) -> SplitInclusive<'_, T, F>
where
@ -1194,7 +1194,7 @@ impl<T> [T] {
/// }
/// assert_eq!(v, [10, 40, 1, 20, 1, 1]);
/// ```
#[unstable(feature = "split_inclusive", issue = "none")]
#[unstable(feature = "split_inclusive", issue = "72360")]
#[inline]
pub fn split_inclusive_mut<F>(&mut self, pred: F) -> SplitInclusiveMut<'_, T, F>
where
@ -3852,7 +3852,7 @@ impl<T, P> FusedIterator for Split<'_, T, P> where P: FnMut(&T) -> bool {}
///
/// [`split_inclusive`]: ../../std/primitive.slice.html#method.split_inclusive
/// [slices]: ../../std/primitive.slice.html
#[unstable(feature = "split_inclusive", issue = "none")]
#[unstable(feature = "split_inclusive", issue = "72360")]
pub struct SplitInclusive<'a, T: 'a, P>
where
P: FnMut(&T) -> bool,
@ -3862,7 +3862,7 @@ where
finished: bool,
}
#[unstable(feature = "split_inclusive", issue = "none")]
#[unstable(feature = "split_inclusive", issue = "72360")]
impl<T: fmt::Debug, P> fmt::Debug for SplitInclusive<'_, T, P>
where
P: FnMut(&T) -> bool,
@ -3876,7 +3876,7 @@ where
}
// FIXME(#26925) Remove in favor of `#[derive(Clone)]`
#[unstable(feature = "split_inclusive", issue = "none")]
#[unstable(feature = "split_inclusive", issue = "72360")]
impl<T, P> Clone for SplitInclusive<'_, T, P>
where
P: Clone + FnMut(&T) -> bool,
@ -3886,7 +3886,7 @@ where
}
}
#[unstable(feature = "split_inclusive", issue = "none")]
#[unstable(feature = "split_inclusive", issue = "72360")]
impl<'a, T, P> Iterator for SplitInclusive<'a, T, P>
where
P: FnMut(&T) -> bool,
@ -3915,7 +3915,7 @@ where
}
}
#[unstable(feature = "split_inclusive", issue = "none")]
#[unstable(feature = "split_inclusive", issue = "72360")]
impl<'a, T, P> DoubleEndedIterator for SplitInclusive<'a, T, P>
where
P: FnMut(&T) -> bool,
@ -3940,7 +3940,7 @@ where
}
}
#[unstable(feature = "split_inclusive", issue = "none")]
#[unstable(feature = "split_inclusive", issue = "72360")]
impl<T, P> FusedIterator for SplitInclusive<'_, T, P> where P: FnMut(&T) -> bool {}
/// An iterator over the mutable subslices of the vector which are separated
@ -4065,7 +4065,7 @@ impl<T, P> FusedIterator for SplitMut<'_, T, P> where P: FnMut(&T) -> bool {}
///
/// [`split_inclusive_mut`]: ../../std/primitive.slice.html#method.split_inclusive_mut
/// [slices]: ../../std/primitive.slice.html
#[unstable(feature = "split_inclusive", issue = "none")]
#[unstable(feature = "split_inclusive", issue = "72360")]
pub struct SplitInclusiveMut<'a, T: 'a, P>
where
P: FnMut(&T) -> bool,
@ -4075,7 +4075,7 @@ where
finished: bool,
}
#[unstable(feature = "split_inclusive", issue = "none")]
#[unstable(feature = "split_inclusive", issue = "72360")]
impl<T: fmt::Debug, P> fmt::Debug for SplitInclusiveMut<'_, T, P>
where
P: FnMut(&T) -> bool,
@ -4088,7 +4088,7 @@ where
}
}
#[unstable(feature = "split_inclusive", issue = "none")]
#[unstable(feature = "split_inclusive", issue = "72360")]
impl<'a, T, P> Iterator for SplitInclusiveMut<'a, T, P>
where
P: FnMut(&T) -> bool,
@ -4128,7 +4128,7 @@ where
}
}
#[unstable(feature = "split_inclusive", issue = "none")]
#[unstable(feature = "split_inclusive", issue = "72360")]
impl<'a, T, P> DoubleEndedIterator for SplitInclusiveMut<'a, T, P>
where
P: FnMut(&T) -> bool,
@ -4162,7 +4162,7 @@ where
}
}
#[unstable(feature = "split_inclusive", issue = "none")]
#[unstable(feature = "split_inclusive", issue = "72360")]
impl<T, P> FusedIterator for SplitInclusiveMut<'_, T, P> where P: FnMut(&T) -> bool {}
/// An iterator over subslices separated by elements that match a predicate

14
src/libcore/str/mod.rs
View File

@ -3335,7 +3335,7 @@ impl str {
/// .split_inclusive('\n').collect();
/// assert_eq!(v, ["Mary had a little lamb\n", "little lamb\n", "little lamb.\n"]);
/// ```
#[unstable(feature = "split_inclusive", issue = "none")]
#[unstable(feature = "split_inclusive", issue = "72360")]
#[inline]
pub fn split_inclusive<'a, P: Pattern<'a>>(&'a self, pat: P) -> SplitInclusive<'a, P> {
SplitInclusive(SplitInternal {
@ -4575,7 +4575,7 @@ pub struct SplitAsciiWhitespace<'a> {
///
/// [`split_inclusive`]: ../../std/primitive.str.html#method.split_inclusive
/// [`str`]: ../../std/primitive.str.html
#[unstable(feature = "split_inclusive", issue = "none")]
#[unstable(feature = "split_inclusive", issue = "72360")]
pub struct SplitInclusive<'a, P: Pattern<'a>>(SplitInternal<'a, P>);
impl_fn_for_zst! {
@ -4668,7 +4668,7 @@ impl<'a> DoubleEndedIterator for SplitAsciiWhitespace<'a> {
#[stable(feature = "split_ascii_whitespace", since = "1.34.0")]
impl FusedIterator for SplitAsciiWhitespace<'_> {}
#[unstable(feature = "split_inclusive", issue = "none")]
#[unstable(feature = "split_inclusive", issue = "72360")]
impl<'a, P: Pattern<'a>> Iterator for SplitInclusive<'a, P> {
type Item = &'a str;
@ -4678,7 +4678,7 @@ impl<'a, P: Pattern<'a>> Iterator for SplitInclusive<'a, P> {
}
}
#[unstable(feature = "split_inclusive", issue = "none")]
#[unstable(feature = "split_inclusive", issue = "72360")]
impl<'a, P: Pattern<'a, Searcher: fmt::Debug>> fmt::Debug for SplitInclusive<'a, P> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("SplitInclusive").field("0", &self.0).finish()
@ -4686,14 +4686,14 @@ impl<'a, P: Pattern<'a, Searcher: fmt::Debug>> fmt::Debug for SplitInclusive<'a,
}
// FIXME(#26925) Remove in favor of `#[derive(Clone)]`
#[unstable(feature = "split_inclusive", issue = "none")]
#[unstable(feature = "split_inclusive", issue = "72360")]
impl<'a, P: Pattern<'a, Searcher: Clone>> Clone for SplitInclusive<'a, P> {
fn clone(&self) -> Self {
SplitInclusive(self.0.clone())
}
}
#[unstable(feature = "split_inclusive", issue = "none")]
#[unstable(feature = "split_inclusive", issue = "72360")]
impl<'a, P: Pattern<'a, Searcher: ReverseSearcher<'a>>> DoubleEndedIterator
for SplitInclusive<'a, P>
{
@ -4703,7 +4703,7 @@ impl<'a, P: Pattern<'a, Searcher: ReverseSearcher<'a>>> DoubleEndedIterator
}
}
#[unstable(feature = "split_inclusive", issue = "none")]
#[unstable(feature = "split_inclusive", issue = "72360")]
impl<'a, P: Pattern<'a>> FusedIterator for SplitInclusive<'a, P> {}
/// An iterator of [`u16`] over the string encoded as UTF-16.

1
src/librustc_ast_lowering/expr.rs
View File

@ -1322,7 +1322,6 @@ impl<'hir> LoweringContext<'_, 'hir> {
"`async` generators are not yet supported"
)
.emit();
return hir::ExprKind::Err;
}
None => self.generator_kind = Some(hir::GeneratorKind::Gen),
}

1
src/librustc_middle/Cargo.toml
View File

@ -14,7 +14,6 @@ arena = { path = "../libarena" }
bitflags = "1.2.1"
scoped-tls = "1.0"
log = { version = "0.4", features = ["release_max_level_info", "std"] }
rustc-rayon = "0.3.0"
rustc-rayon-core = "0.3.0"
polonius-engine = "0.12.0"
rustc_apfloat = { path = "../librustc_apfloat" }

17
src/librustc_middle/ty/context.rs
View File

@ -1114,16 +1114,13 @@ impl<'tcx> TyCtxt<'tcx> {
let mut trait_map: FxHashMap<_, FxHashMap<_, _>> = FxHashMap::default();
for (k, v) in resolutions.trait_map {
// FIXME(#71104) Should really be using just `node_id_to_hir_id` but
// some `NodeId` do not seem to have a corresponding HirId.
if let Some(hir_id) = definitions.opt_node_id_to_hir_id(k) {
let map = trait_map.entry(hir_id.owner).or_default();
let v = v
.into_iter()
.map(|tc| tc.map_import_ids(|id| definitions.node_id_to_hir_id(id)))
.collect();
map.insert(hir_id.local_id, StableVec::new(v));
}
let hir_id = definitions.node_id_to_hir_id(k);
let map = trait_map.entry(hir_id.owner).or_default();
let v = v
.into_iter()
.map(|tc| tc.map_import_ids(|id| definitions.node_id_to_hir_id(id)))
.collect();
map.insert(hir_id.local_id, StableVec::new(v));
}
GlobalCtxt {

1
src/librustc_mir_build/Cargo.toml
View File

@ -20,7 +20,6 @@ rustc_index = { path = "../librustc_index" }
rustc_errors = { path = "../librustc_errors" }
rustc_hir = { path = "../librustc_hir" }
rustc_infer = { path = "../librustc_infer" }
rustc_macros = { path = "../librustc_macros" }
rustc_serialize = { path = "../libserialize", package = "serialize" }
rustc_session = { path = "../librustc_session" }
rustc_span = { path = "../librustc_span" }

29
src/librustc_resolve/build_reduced_graph.rs
View File

@ -426,7 +426,7 @@ impl<'a, 'b> BuildReducedGraphVisitor<'a, 'b> {
return;
}
// Replace `use foo::self;` with `use foo;`
// Replace `use foo::{ self };` with `use foo;`
source = module_path.pop().unwrap();
if rename.is_none() {
ident = source.ident;
@ -435,10 +435,33 @@ impl<'a, 'b> BuildReducedGraphVisitor<'a, 'b> {
} else {
// Disallow `self`
if source.ident.name == kw::SelfLower {
let parent = module_path.last();
let span = match parent {
// only `::self` from `use foo::self as bar`
Some(seg) => seg.ident.span.shrink_to_hi().to(source.ident.span),
None => source.ident.span,
};
let span_with_rename = match rename {
// only `self as bar` from `use foo::self as bar`
Some(rename) => source.ident.span.to(rename.span),
None => source.ident.span,
};
self.r.report_error(
use_tree.span,
ResolutionError::SelfImportsOnlyAllowedWithin,
span,
ResolutionError::SelfImportsOnlyAllowedWithin {
root: parent.is_none(),
span_with_rename,
},
);
// Error recovery: replace `use foo::self;` with `use foo;`
if let Some(parent) = module_path.pop() {
source = parent;
if rename.is_none() {
ident = source.ident;
}
}
}
// Disallow `use $crate;`

41
src/librustc_resolve/diagnostics.rs
View File

@ -301,13 +301,40 @@ impl<'a> Resolver<'a> {
}
err
}
ResolutionError::SelfImportsOnlyAllowedWithin => struct_span_err!(
self.session,
span,
E0429,
"{}",
"`self` imports are only allowed within a { } list"
),
ResolutionError::SelfImportsOnlyAllowedWithin { root, span_with_rename } => {
let mut err = struct_span_err!(
self.session,
span,
E0429,
"{}",
"`self` imports are only allowed within a { } list"
);
// None of the suggestions below would help with a case like `use self`.
if !root {
// use foo::bar::self -> foo::bar
// use foo::bar::self as abc -> foo::bar as abc
err.span_suggestion(
span,
"consider importing the module directly",
"".to_string(),
Applicability::MachineApplicable,
);
// use foo::bar::self -> foo::bar::{self}
// use foo::bar::self as abc -> foo::bar::{self as abc}
let braces = vec![
(span_with_rename.shrink_to_lo(), "{".to_string()),
(span_with_rename.shrink_to_hi(), "}".to_string()),
];
err.multipart_suggestion(
"alternatively, use the multi-path `use` syntax to import `self`",
braces,
Applicability::MachineApplicable,
);
}
err
}
ResolutionError::SelfImportCanOnlyAppearOnceInTheList => {
let mut err = struct_span_err!(
self.session,

2
src/librustc_resolve/lib.rs
View File

@ -194,7 +194,7 @@ enum ResolutionError<'a> {
/// Error E0426: use of undeclared label.
UndeclaredLabel(&'a str, Option<Symbol>),
/// Error E0429: `self` imports are only allowed within a `{ }` list.
SelfImportsOnlyAllowedWithin,
SelfImportsOnlyAllowedWithin { root: bool, span_with_rename: Span },
/// Error E0430: `self` import can only appear once in the list.
SelfImportCanOnlyAppearOnceInTheList,
/// Error E0431: `self` import can only appear in an import list with a non-empty prefix.

1
src/librustc_session/Cargo.toml
View File

@ -17,7 +17,6 @@ rustc_target = { path = "../librustc_target" }
rustc_serialize = { path = "../libserialize", package = "serialize" }
rustc_data_structures = { path = "../librustc_data_structures" }
rustc_span = { path = "../librustc_span" }
rustc_index = { path = "../librustc_index" }
rustc_fs_util = { path = "../librustc_fs_util" }
num_cpus = "1.0"
rustc_ast = { path = "../librustc_ast" }

1
src/librustc_symbol_mangling/Cargo.toml
View File

@ -20,5 +20,4 @@ rustc_middle = { path = "../librustc_middle" }
rustc_hir = { path = "../librustc_hir" }
rustc_target = { path = "../librustc_target" }
rustc_data_structures = { path = "../librustc_data_structures" }
rustc_metadata = { path = "../librustc_metadata" }
rustc_session = { path = "../librustc_session" }

14
src/test/codegen/iter-fold-closure-no-dupes.rs
View File

@ -1,14 +0,0 @@
//! Check that fold closures aren't duplicated for each iterator type.
// compile-flags: -C opt-level=0
fn main() {
(0i32..10).by_ref().count();
(0i32..=10).by_ref().count();
}
// `count` calls `fold`, which calls `try_fold` -- find the `fold` closure:
// CHECK: {{^define.*Iterator::fold::.*closure}}
//
// Only one closure is needed for both `count` calls, even from different
// monomorphized iterator types, as it's only generic over the item type.
// CHECK-NOT: {{^define.*Iterator::fold::.*closure}}

10
src/test/codegen/iter-fold-closure-no-iterator.rs
View File

@ -1,10 +0,0 @@
//! Check that fold closures aren't generic in the iterator type.
// compile-flags: -C opt-level=0
fn main() {
(0i32..10).by_ref().count();
}
// `count` calls `fold`, which calls `try_fold` -- that `fold` closure should
// not be generic in the iterator type, only in the item type.
// CHECK-NOT: {{^define.*Iterator::fold::.*closure.*Range}}

13
src/test/ui/error-codes/E0429.stderr
View File

@ -1,8 +1,17 @@
error[E0429]: `self` imports are only allowed within a { } list
--> $DIR/E0429.rs:1:5
--> $DIR/E0429.rs:1:13
|
LL | use std::fmt::self;
| ^^^^^^^^^^^^^^
| ^^^^^^
|
help: consider importing the module directly
|
LL | use std::fmt;
| --
help: alternatively, use the multi-path `use` syntax to import `self`
|
LL | use std::fmt::{self};
| ^ ^
error: aborting due to previous error

2
src/test/ui/issues/issue-45829/import-self.rs
View File

@ -9,7 +9,7 @@ use foo::{self};
use foo as self;
//~^ ERROR expected identifier
use foo::self;
use foo::self; //~ ERROR is defined multiple times
//~^ ERROR `self` imports are only allowed within a { } list
use foo::A;

30
src/test/ui/issues/issue-45829/import-self.stderr
View File

@ -5,10 +5,19 @@ LL | use foo as self;
| ^^^^ expected identifier, found keyword
error[E0429]: `self` imports are only allowed within a { } list
--> $DIR/import-self.rs:12:5
--> $DIR/import-self.rs:12:8
|
LL | use foo::self;
| ^^^^^^^^^
| ^^^^^^
|
help: consider importing the module directly
|
LL | use foo;
| --
help: alternatively, use the multi-path `use` syntax to import `self`
|
LL | use foo::{self};
| ^ ^
error[E0255]: the name `foo` is defined multiple times
--> $DIR/import-self.rs:6:11
@ -25,6 +34,21 @@ help: you can use `as` to change the binding name of the import
LL | use foo::{self as other_foo};
| ^^^^^^^^^^^^^^^^^
error[E0255]: the name `foo` is defined multiple times
--> $DIR/import-self.rs:12:5
|
LL | mod foo {
| ------- previous definition of the module `foo` here
...
LL | use foo::self;
| ^^^^^^^^^ `foo` reimported here
|
= note: `foo` must be defined only once in the type namespace of this module
help: you can use `as` to change the binding name of the import
|
LL | use foo as other_foo;
| ^^^^^^^^^^^^^^^^
error[E0252]: the name `A` is defined multiple times
--> $DIR/import-self.rs:16:11
|
@ -39,7 +63,7 @@ help: you can use `as` to change the binding name of the import
LL | use foo::{self as OtherA};
| ^^^^^^^^^^^^^^
error: aborting due to 4 previous errors
error: aborting due to 5 previous errors
Some errors have detailed explanations: E0252, E0255, E0429.
For more information about an error, try `rustc --explain E0252`.

2
src/test/ui/use/use-keyword.stderr
View File

@ -2,7 +2,7 @@ error[E0429]: `self` imports are only allowed within a { } list
--> $DIR/use-keyword.rs:6:13
|
LL | use self as A;
| ^^^^^^^^^
| ^^^^
error[E0432]: unresolved import `super`
--> $DIR/use-keyword.rs:8:13

28
src/test/ui/use/use-mod/use-mod-4.stderr
View File

@ -1,20 +1,38 @@
error[E0429]: `self` imports are only allowed within a { } list
--> $DIR/use-mod-4.rs:1:5
--> $DIR/use-mod-4.rs:1:8
|
LL | use foo::self;
| ^^^^^^^^^
| ^^^^^^
|
help: consider importing the module directly
|
LL | use foo;
| --
help: alternatively, use the multi-path `use` syntax to import `self`
|
LL | use foo::{self};
| ^ ^
error[E0429]: `self` imports are only allowed within a { } list
--> $DIR/use-mod-4.rs:4:5
--> $DIR/use-mod-4.rs:4:13
|
LL | use std::mem::self;
| ^^^^^^^^^^^^^^
| ^^^^^^
|
help: consider importing the module directly
|
LL | use std::mem;
| --
help: alternatively, use the multi-path `use` syntax to import `self`
|
LL | use std::mem::{self};
| ^ ^
error[E0432]: unresolved import `foo`
--> $DIR/use-mod-4.rs:1:5
|
LL | use foo::self;
| ^^^ maybe a missing crate `foo`?
| ^^^^^^^^^ no `foo` in the root
error: aborting due to 3 previous errors

13
src/test/ui/use/use-mod/use-mod-5.rs Normal file
View File

@ -0,0 +1,13 @@
mod foo {
pub mod bar {
pub fn drop() {}
}
}
use foo::bar::self;
//~^ ERROR `self` imports are only allowed within a { } list
fn main() {
// Because of error recovery this shouldn't error
bar::drop();
}

18
src/test/ui/use/use-mod/use-mod-5.stderr Normal file
View File

@ -0,0 +1,18 @@
error[E0429]: `self` imports are only allowed within a { } list
--> $DIR/use-mod-5.rs:7:13
|
LL | use foo::bar::self;
| ^^^^^^
|
help: consider importing the module directly
|
LL | use foo::bar;
| --
help: alternatively, use the multi-path `use` syntax to import `self`
|
LL | use foo::bar::{self};
| ^ ^
error: aborting due to previous error
For more information about this error, try `rustc --explain E0429`.

13
src/test/ui/use/use-mod/use-mod-6.rs Normal file
View File

@ -0,0 +1,13 @@
mod foo {
pub mod bar {
pub fn drop() {}
}
}
use foo::bar::self as abc;
//~^ ERROR `self` imports are only allowed within a { } list
fn main() {
// Because of error recovery this shouldn't error
abc::drop();
}

18
src/test/ui/use/use-mod/use-mod-6.stderr Normal file
View File

@ -0,0 +1,18 @@
error[E0429]: `self` imports are only allowed within a { } list
--> $DIR/use-mod-6.rs:7:13
|
LL | use foo::bar::self as abc;
| ^^^^^^
|
help: consider importing the module directly
|
LL | use foo::bar as abc;
| --
help: alternatively, use the multi-path `use` syntax to import `self`
|
LL | use foo::bar::{self as abc};
| ^ ^
error: aborting due to previous error
For more information about this error, try `rustc --explain E0429`.