From a31f103fd27bde3f83b9dd54af8e41d64e5001f4 Mon Sep 17 00:00:00 2001 From: Yoshua Wuyts Date: Sun, 17 May 2020 19:44:56 +0200 Subject: [PATCH 01/35] Add core::future::{poll_fn, PollFn} --- src/libcore/future/mod.rs | 4 +++ src/libcore/future/poll_fn.rs | 66 +++++++++++++++++++++++++++++++++++ 2 files changed, 70 insertions(+) create mode 100644 src/libcore/future/poll_fn.rs diff --git a/src/libcore/future/mod.rs b/src/libcore/future/mod.rs index b5a102916a07e..f56d19d66248a 100644 --- a/src/libcore/future/mod.rs +++ b/src/libcore/future/mod.rs @@ -11,6 +11,7 @@ use crate::{ mod future; mod pending; +mod poll_fn; mod ready; #[stable(feature = "futures_api", since = "1.36.0")] @@ -21,6 +22,9 @@ pub use pending::{pending, Pending}; #[unstable(feature = "future_readiness_fns", issue = "70921")] pub use ready::{ready, Ready}; +#[unstable(feature = "future_poll_fn", issue = "72302")] +pub use poll_fn::{poll_fn, PollFn}; + /// This type is needed because: /// /// a) Generators cannot implement `for<'a, 'b> Generator<&'a mut Context<'b>>`, so we need to pass diff --git a/src/libcore/future/poll_fn.rs b/src/libcore/future/poll_fn.rs new file mode 100644 index 0000000000000..9ab3bfcea1c71 --- /dev/null +++ b/src/libcore/future/poll_fn.rs @@ -0,0 +1,66 @@ +use crate::fmt; +use crate::future::Future; +use crate::pin::Pin; +use crate::task::{Context, Poll}; + +/// Creates a future that wraps a function returning `Poll`. +/// +/// Polling the future delegates to the wrapped function. +/// +/// # Examples +/// +/// ``` +/// #![feature(future_poll_fn)] +/// # async fn run() { +/// use core::future::poll_fn; +/// use core::task::{Context, Poll}; +/// +/// fn read_line(_cx: &mut Context<'_>) -> Poll { +/// Poll::Ready("Hello, World!".into()) +/// } +/// +/// let read_future = poll_fn(read_line); +/// assert_eq!(read_future.await, "Hello, World!".to_owned()); +/// # }; +/// ``` +#[unstable(feature = "future_poll_fn", issue = "72302")] +pub fn poll_fn(f: F) -> PollFn +where + F: FnMut(&mut Context<'_>) -> Poll, +{ + PollFn { f } +} + +/// A Future that wraps a function returning `Poll`. +/// +/// This `struct` is created by the [`poll_fn`] function. See its +/// documentation for more. +/// +/// [`poll_fn`]: fn.poll_fn.html +#[must_use = "futures do nothing unless you `.await` or poll them"] +#[unstable(feature = "future_poll_fn", issue = "72302")] +pub struct PollFn { + f: F, +} + +#[unstable(feature = "future_poll_fn", issue = "72302")] +impl Unpin for PollFn {} + +#[unstable(feature = "future_poll_fn", issue = "72302")] +impl fmt::Debug for PollFn { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_struct("PollFn").finish() + } +} + +#[unstable(feature = "future_poll_fn", issue = "72302")] +impl Future for PollFn +where + F: FnMut(&mut Context<'_>) -> Poll, +{ + type Output = T; + + fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll { + (&mut self.f)(cx) + } +} From 7e682d3f6f5761471e05fefc21e5de6ce4a52444 Mon Sep 17 00:00:00 2001 From: Oliver Scherer Date: Mon, 29 Jun 2020 17:01:44 +0200 Subject: [PATCH 02/35] Stabilize casts and coercions to `&[T]` in const fn --- src/librustc_middle/ty/layout.rs | 2 +- .../transform/qualify_min_const_fn.rs | 13 +++++++++++-- src/test/ui/consts/array-to-slice-cast.rs | 13 +++++++++++++ .../const-extern-fn-min-const-fn.rs | 1 - .../const-extern-fn-min-const-fn.stderr | 17 ++++------------- .../ui/consts/min_const_fn/cast_errors.rs | 1 - .../ui/consts/min_const_fn/cast_errors.stderr | 19 +++++-------------- 7 files changed, 34 insertions(+), 32 deletions(-) create mode 100644 src/test/ui/consts/array-to-slice-cast.rs diff --git a/src/librustc_middle/ty/layout.rs b/src/librustc_middle/ty/layout.rs index e4cc96dd83bfb..f6788e317aeee 100644 --- a/src/librustc_middle/ty/layout.rs +++ b/src/librustc_middle/ty/layout.rs @@ -527,7 +527,7 @@ impl<'tcx> LayoutCx<'tcx, TyCtxt<'tcx>> { size: Size::ZERO, }), - // Potentially-fat pointers. + // Potentially-wide pointers. ty::Ref(_, pointee, _) | ty::RawPtr(ty::TypeAndMut { ty: pointee, .. }) => { let mut data_ptr = scalar_unit(Pointer); if !ty.is_unsafe_ptr() { diff --git a/src/librustc_mir/transform/qualify_min_const_fn.rs b/src/librustc_mir/transform/qualify_min_const_fn.rs index 5a3663384fb87..28d9a3ad63c89 100644 --- a/src/librustc_mir/transform/qualify_min_const_fn.rs +++ b/src/librustc_mir/transform/qualify_min_const_fn.rs @@ -191,8 +191,17 @@ fn check_rvalue( _, _, ) => Err((span, "function pointer casts are not allowed in const fn".into())), - Rvalue::Cast(CastKind::Pointer(PointerCast::Unsize), _, _) => { - Err((span, "unsizing casts are not allowed in const fn".into())) + Rvalue::Cast(CastKind::Pointer(PointerCast::Unsize), op, cast_ty) => { + let pointee_ty = cast_ty.builtin_deref(true).unwrap().ty; + let unsized_ty = tcx.struct_tail_erasing_lifetimes(pointee_ty, tcx.param_env(def_id)); + if let ty::Slice(_) | ty::Str = unsized_ty.kind { + check_operand(tcx, op, span, def_id, body)?; + // Casting/coercing things to slices is fine. + Ok(()) + } else { + // We just can't allow trait objects until we have figured out trait method calls. + Err((span, "unsizing casts are not allowed in const fn".into())) + } } // binops are fine on integers Rvalue::BinaryOp(_, lhs, rhs) | Rvalue::CheckedBinaryOp(_, lhs, rhs) => { diff --git a/src/test/ui/consts/array-to-slice-cast.rs b/src/test/ui/consts/array-to-slice-cast.rs new file mode 100644 index 0000000000000..796f9d1b71f76 --- /dev/null +++ b/src/test/ui/consts/array-to-slice-cast.rs @@ -0,0 +1,13 @@ +// check-pass + +fn main() {} + +const fn foo() { + let x = [1, 2, 3, 4, 5]; + let y: &[_] = &x; + + struct Foo(bool, T); + + let x: Foo<[u8; 3]> = Foo(true, [1, 2, 3]); + let y: &Foo<[u8]> = &x; +} diff --git a/src/test/ui/consts/const-extern-fn/const-extern-fn-min-const-fn.rs b/src/test/ui/consts/const-extern-fn/const-extern-fn-min-const-fn.rs index 5619811768801..2854c08665716 100644 --- a/src/test/ui/consts/const-extern-fn/const-extern-fn-min-const-fn.rs +++ b/src/test/ui/consts/const-extern-fn/const-extern-fn-min-const-fn.rs @@ -1,7 +1,6 @@ #![feature(const_extern_fn)] const extern fn unsize(x: &[u8; 3]) -> &[u8] { x } -//~^ ERROR unsizing casts are not allowed in const fn const unsafe extern "C" fn closure() -> fn() { || {} } //~^ ERROR function pointers in const fn are unstable const unsafe extern fn use_float() { 1.0 + 1.0; } diff --git a/src/test/ui/consts/const-extern-fn/const-extern-fn-min-const-fn.stderr b/src/test/ui/consts/const-extern-fn/const-extern-fn-min-const-fn.stderr index f520bd358472c..146d119fc8f7f 100644 --- a/src/test/ui/consts/const-extern-fn/const-extern-fn-min-const-fn.stderr +++ b/src/test/ui/consts/const-extern-fn/const-extern-fn-min-const-fn.stderr @@ -1,14 +1,5 @@ -error[E0723]: unsizing casts are not allowed in const fn - --> $DIR/const-extern-fn-min-const-fn.rs:3:48 - | -LL | const extern fn unsize(x: &[u8; 3]) -> &[u8] { x } - | ^ - | - = note: see issue #57563 for more information - = help: add `#![feature(const_fn)]` to the crate attributes to enable - error[E0723]: function pointers in const fn are unstable - --> $DIR/const-extern-fn-min-const-fn.rs:5:41 + --> $DIR/const-extern-fn-min-const-fn.rs:4:41 | LL | const unsafe extern "C" fn closure() -> fn() { || {} } | ^^^^ @@ -17,7 +8,7 @@ LL | const unsafe extern "C" fn closure() -> fn() { || {} } = help: add `#![feature(const_fn)]` to the crate attributes to enable error[E0723]: only int, `bool` and `char` operations are stable in const fn - --> $DIR/const-extern-fn-min-const-fn.rs:7:38 + --> $DIR/const-extern-fn-min-const-fn.rs:6:38 | LL | const unsafe extern fn use_float() { 1.0 + 1.0; } | ^^^^^^^^^ @@ -26,7 +17,7 @@ LL | const unsafe extern fn use_float() { 1.0 + 1.0; } = help: add `#![feature(const_fn)]` to the crate attributes to enable error[E0723]: casting pointers to ints is unstable in const fn - --> $DIR/const-extern-fn-min-const-fn.rs:9:48 + --> $DIR/const-extern-fn-min-const-fn.rs:8:48 | LL | const extern "C" fn ptr_cast(val: *const u8) { val as usize; } | ^^^^^^^^^^^^ @@ -34,6 +25,6 @@ LL | const extern "C" fn ptr_cast(val: *const u8) { val as usize; } = note: see issue #57563 for more information = help: add `#![feature(const_fn)]` to the crate attributes to enable -error: aborting due to 4 previous errors +error: aborting due to 3 previous errors For more information about this error, try `rustc --explain E0723`. diff --git a/src/test/ui/consts/min_const_fn/cast_errors.rs b/src/test/ui/consts/min_const_fn/cast_errors.rs index 8648cd35387ce..8d730df16b0d1 100644 --- a/src/test/ui/consts/min_const_fn/cast_errors.rs +++ b/src/test/ui/consts/min_const_fn/cast_errors.rs @@ -1,7 +1,6 @@ fn main() {} const fn unsize(x: &[u8; 3]) -> &[u8] { x } -//~^ ERROR unsizing casts are not allowed in const fn const fn closure() -> fn() { || {} } //~^ ERROR function pointers in const fn are unstable const fn closure2() { diff --git a/src/test/ui/consts/min_const_fn/cast_errors.stderr b/src/test/ui/consts/min_const_fn/cast_errors.stderr index a6a05b522a5ae..583cb4e9720cc 100644 --- a/src/test/ui/consts/min_const_fn/cast_errors.stderr +++ b/src/test/ui/consts/min_const_fn/cast_errors.stderr @@ -1,14 +1,5 @@ -error[E0723]: unsizing casts are not allowed in const fn - --> $DIR/cast_errors.rs:3:41 - | -LL | const fn unsize(x: &[u8; 3]) -> &[u8] { x } - | ^ - | - = note: see issue #57563 for more information - = help: add `#![feature(const_fn)]` to the crate attributes to enable - error[E0723]: function pointers in const fn are unstable - --> $DIR/cast_errors.rs:5:23 + --> $DIR/cast_errors.rs:4:23 | LL | const fn closure() -> fn() { || {} } | ^^^^ @@ -17,7 +8,7 @@ LL | const fn closure() -> fn() { || {} } = help: add `#![feature(const_fn)]` to the crate attributes to enable error[E0723]: function pointers in const fn are unstable - --> $DIR/cast_errors.rs:8:5 + --> $DIR/cast_errors.rs:7:5 | LL | (|| {}) as fn(); | ^^^^^^^^^^^^^^^ @@ -26,7 +17,7 @@ LL | (|| {}) as fn(); = help: add `#![feature(const_fn)]` to the crate attributes to enable error[E0723]: function pointers in const fn are unstable - --> $DIR/cast_errors.rs:11:28 + --> $DIR/cast_errors.rs:10:28 | LL | const fn reify(f: fn()) -> unsafe fn() { f } | ^^^^^^^^^^^ @@ -35,7 +26,7 @@ LL | const fn reify(f: fn()) -> unsafe fn() { f } = help: add `#![feature(const_fn)]` to the crate attributes to enable error[E0723]: function pointers in const fn are unstable - --> $DIR/cast_errors.rs:13:21 + --> $DIR/cast_errors.rs:12:21 | LL | const fn reify2() { main as unsafe fn(); } | ^^^^^^^^^^^^^^^^^^^ @@ -43,6 +34,6 @@ LL | const fn reify2() { main as unsafe fn(); } = note: see issue #57563 for more information = help: add `#![feature(const_fn)]` to the crate attributes to enable -error: aborting due to 5 previous errors +error: aborting due to 4 previous errors For more information about this error, try `rustc --explain E0723`. From a065096ff40f7910fd58aa36a76be6cb1c5f1d4d Mon Sep 17 00:00:00 2001 From: Dodo Date: Tue, 30 Jun 2020 10:53:11 +0200 Subject: [PATCH 03/35] stabilize const mem::forget --- src/libcore/mem/mod.rs | 2 +- src/libcore/tests/lib.rs | 1 - src/test/ui/consts/const_forget.rs | 2 -- 3 files changed, 1 insertion(+), 4 deletions(-) diff --git a/src/libcore/mem/mod.rs b/src/libcore/mem/mod.rs index 46e6ea7cd1866..84f8f1f77909b 100644 --- a/src/libcore/mem/mod.rs +++ b/src/libcore/mem/mod.rs @@ -142,7 +142,7 @@ pub use crate::intrinsics::transmute; /// [ub]: ../../reference/behavior-considered-undefined.html /// [`ManuallyDrop`]: struct.ManuallyDrop.html #[inline] -#[rustc_const_unstable(feature = "const_forget", issue = "69616")] +#[rustc_const_stable(feature = "const_forget", since = "1.46.0")] #[stable(feature = "rust1", since = "1.0.0")] pub const fn forget(t: T) { ManuallyDrop::new(t); diff --git a/src/libcore/tests/lib.rs b/src/libcore/tests/lib.rs index c60ce8ec837d5..772ec079ef2dc 100644 --- a/src/libcore/tests/lib.rs +++ b/src/libcore/tests/lib.rs @@ -40,7 +40,6 @@ #![feature(const_raw_ptr_deref)] #![feature(never_type)] #![feature(unwrap_infallible)] -#![feature(const_forget)] #![feature(option_unwrap_none)] #![feature(peekable_next_if)] #![feature(partition_point)] diff --git a/src/test/ui/consts/const_forget.rs b/src/test/ui/consts/const_forget.rs index 2dcb72a5a09cb..ec7dde8c9ecdc 100644 --- a/src/test/ui/consts/const_forget.rs +++ b/src/test/ui/consts/const_forget.rs @@ -1,7 +1,5 @@ // check-pass -#![feature(const_forget)] - use std::mem::forget; const _: () = forget(0i32); From 8e256b19d529ebf9021030e17791e23a1212ff1e Mon Sep 17 00:00:00 2001 From: Vadim Petrochenkov Date: Sat, 18 Apr 2020 21:26:10 +0300 Subject: [PATCH 04/35] parser: Break float tokens into parts in tuple field positions --- src/librustc_parse/parser/expr.rs | 119 ++++--- src/test/ui/parser/float-field.rs | 62 ++++ src/test/ui/parser/float-field.stderr | 349 +++++++++++++++++++++ src/test/ui/tuple/tuple-float-index.fixed | 5 - src/test/ui/tuple/tuple-float-index.rs | 5 - src/test/ui/tuple/tuple-float-index.stderr | 11 - 6 files changed, 492 insertions(+), 59 deletions(-) create mode 100644 src/test/ui/parser/float-field.rs create mode 100644 src/test/ui/parser/float-field.stderr delete mode 100644 src/test/ui/tuple/tuple-float-index.fixed delete mode 100644 src/test/ui/tuple/tuple-float-index.rs delete mode 100644 src/test/ui/tuple/tuple-float-index.stderr diff --git a/src/librustc_parse/parser/expr.rs b/src/librustc_parse/parser/expr.rs index abb444933536f..d52cea74520bd 100644 --- a/src/librustc_parse/parser/expr.rs +++ b/src/librustc_parse/parser/expr.rs @@ -770,10 +770,10 @@ impl<'a> Parser<'a> { match self.token.uninterpolate().kind { token::Ident(..) => self.parse_dot_suffix(base, lo), token::Literal(token::Lit { kind: token::Integer, symbol, suffix }) => { - Ok(self.parse_tuple_field_access_expr(lo, base, symbol, suffix)) + Ok(self.parse_tuple_field_access_expr(lo, base, symbol, suffix, None)) } - token::Literal(token::Lit { kind: token::Float, symbol, .. }) => { - self.recover_field_access_by_float_lit(lo, base, symbol) + token::Literal(token::Lit { kind: token::Float, symbol, suffix }) => { + Ok(self.parse_tuple_field_access_expr_float(lo, base, symbol, suffix)) } _ => { self.error_unexpected_after_dot(); @@ -788,45 +788,84 @@ impl<'a> Parser<'a> { self.struct_span_err(self.token.span, &format!("unexpected token: `{}`", actual)).emit(); } - fn recover_field_access_by_float_lit( + // We need and identifier or integer, but the next token is a float. + // Break the float into components to extract the identifier or integer. + // FIXME: With current `TokenCursor` it's hard to break tokens into more than 2 + // parts unless those parts are processed immediately. `TokenCursor` should either + // support pushing "future tokens" (would be also helpful to `break_and_eat`), or + // we should break everything including floats into more basic proc-macro style + // tokens in the lexer (probably preferable). + fn parse_tuple_field_access_expr_float( &mut self, lo: Span, base: P, - sym: Symbol, - ) -> PResult<'a, P> { - self.bump(); - - let fstr = sym.as_str(); - let msg = format!("unexpected token: `{}`", sym); - - let mut err = self.struct_span_err(self.prev_token.span, &msg); - err.span_label(self.prev_token.span, "unexpected token"); - - if fstr.chars().all(|x| "0123456789.".contains(x)) { - let float = match fstr.parse::() { - Ok(f) => f, - Err(_) => { - err.emit(); - return Ok(base); + float: Symbol, + suffix: Option, + ) -> P { + #[derive(Debug)] + enum FloatComponent { + IdentLike(String), + Punct(char), + } + use FloatComponent::*; + + let mut components = Vec::new(); + let mut ident_like = String::new(); + for c in float.as_str().chars() { + if c == '_' || c.is_ascii_alphanumeric() { + ident_like.push(c); + } else if matches!(c, '.' | '+' | '-') { + if !ident_like.is_empty() { + components.push(IdentLike(mem::take(&mut ident_like))); } - }; - let sugg = pprust::to_string(|s| { - s.popen(); - s.print_expr(&base); - s.s.word("."); - s.print_usize(float.trunc() as usize); - s.pclose(); - s.s.word("."); - s.s.word(fstr.splitn(2, '.').last().unwrap().to_string()) - }); - err.span_suggestion( - lo.to(self.prev_token.span), - "try parenthesizing the first index", - sugg, - Applicability::MachineApplicable, - ); + components.push(Punct(c)); + } else { + panic!("unexpected character in a float token: {:?}", c) + } + } + if !ident_like.is_empty() { + components.push(IdentLike(ident_like)); + } + + // FIXME: Make the span more precise. + let span = self.token.span; + match &*components { + // 1e2 + [IdentLike(i)] => { + self.parse_tuple_field_access_expr(lo, base, Symbol::intern(&i), suffix, None) + } + // 1. + [IdentLike(i), Punct('.')] => { + assert!(suffix.is_none()); + let symbol = Symbol::intern(&i); + self.token = Token::new(token::Ident(symbol, false), span); + let next_token = Token::new(token::Dot, span); + self.parse_tuple_field_access_expr(lo, base, symbol, None, Some(next_token)) + } + // 1.2 | 1.2e3 + [IdentLike(i1), Punct('.'), IdentLike(i2)] => { + let symbol1 = Symbol::intern(&i1); + self.token = Token::new(token::Ident(symbol1, false), span); + let next_token1 = Token::new(token::Dot, span); + let base1 = + self.parse_tuple_field_access_expr(lo, base, symbol1, None, Some(next_token1)); + let symbol2 = Symbol::intern(&i2); + let next_token2 = Token::new(token::Ident(symbol2, false), span); + self.bump_with(next_token2); // `.` + self.parse_tuple_field_access_expr(lo, base1, symbol2, suffix, None) + } + // 1e+ | 1e- (recovered) + [IdentLike(_), Punct('+' | '-')] | + // 1e+2 | 1e-2 + [IdentLike(_), Punct('+' | '-'), IdentLike(_)] | + // 1.2e+3 | 1.2e-3 + [IdentLike(_), Punct('.'), IdentLike(_), Punct('+' | '-'), IdentLike(_)] => { + // See the FIXME about `TokenCursor` above. + self.error_unexpected_after_dot(); + base + } + _ => panic!("unexpected components in a float token: {:?}", components), } - Err(err) } fn parse_tuple_field_access_expr( @@ -835,8 +874,12 @@ impl<'a> Parser<'a> { base: P, field: Symbol, suffix: Option, + next_token: Option, ) -> P { - self.bump(); + match next_token { + Some(next_token) => self.bump_with(next_token), + None => self.bump(), + } let span = self.prev_token.span; let field = ExprKind::Field(base, Ident::new(field, span)); self.expect_no_suffix(span, "a tuple index", suffix); diff --git a/src/test/ui/parser/float-field.rs b/src/test/ui/parser/float-field.rs new file mode 100644 index 0000000000000..eaa7465dc4d06 --- /dev/null +++ b/src/test/ui/parser/float-field.rs @@ -0,0 +1,62 @@ +struct S(u8, (u8, u8)); + +fn main() { + let s = S(0, (0, 0)); + + s.1e1; //~ ERROR no field `1e1` on type `S` + s.1.; //~ ERROR unexpected token: `;` + s.1.1; + s.1.1e1; //~ ERROR no field `1e1` on type `(u8, u8)` + { s.1e+; } //~ ERROR unexpected token: `1e+` + //~| ERROR expected one of `.`, `;`, `?`, `}`, or an operator, found `1e+` + //~| ERROR expected at least one digit in exponent + { s.1e-; } //~ ERROR unexpected token: `1e-` + //~| ERROR expected one of `.`, `;`, `?`, `}`, or an operator, found `1e-` + //~| ERROR expected at least one digit in exponent + { s.1e+1; } //~ ERROR unexpected token: `1e+1` + //~| ERROR expected one of `.`, `;`, `?`, `}`, or an operator, found `1e+1` + { s.1e-1; } //~ ERROR unexpected token: `1e-1` + //~| ERROR expected one of `.`, `;`, `?`, `}`, or an operator, found `1e-1` + { s.1.1e+1; } //~ ERROR unexpected token: `1.1e+1` + //~| ERROR expected one of `.`, `;`, `?`, `}`, or an operator, found `1.1e+1` + { s.1.1e-1; } //~ ERROR unexpected token: `1.1e-1` + //~| ERROR expected one of `.`, `;`, `?`, `}`, or an operator, found `1.1e-1` + s.0x1e1; //~ ERROR no field `0x1e1` on type `S` + s.0x1.; //~ ERROR no field `0x1` on type `S` + //~| ERROR hexadecimal float literal is not supported + //~| ERROR unexpected token: `;` + s.0x1.1; //~ ERROR no field `0x1` on type `S` + //~| ERROR hexadecimal float literal is not supported + s.0x1.1e1; //~ ERROR no field `0x1` on type `S` + //~| ERROR hexadecimal float literal is not supported + { s.0x1e+; } //~ ERROR expected expression, found `;` + { s.0x1e-; } //~ ERROR expected expression, found `;` + s.0x1e+1; //~ ERROR no field `0x1e` on type `S` + s.0x1e-1; //~ ERROR no field `0x1e` on type `S` + { s.0x1.1e+1; } //~ ERROR unexpected token: `0x1.1e+1` + //~| ERROR expected one of `.`, `;`, `?`, `}`, or an operator, found `0x1.1e+1` + //~| ERROR hexadecimal float literal is not supported + { s.0x1.1e-1; } //~ ERROR unexpected token: `0x1.1e-1` + //~| ERROR expected one of `.`, `;`, `?`, `}`, or an operator, found `0x1.1e-1` + //~| ERROR hexadecimal float literal is not supported + s.1e1f32; //~ ERROR no field `1e1` on type `S` + //~| ERROR suffixes on a tuple index are invalid + s.1.f32; //~ ERROR no field `f32` on type `(u8, u8)` + s.1.1f32; //~ ERROR suffixes on a tuple index are invalid + s.1.1e1f32; //~ ERROR no field `1e1` on type `(u8, u8)` + //~| ERROR suffixes on a tuple index are invalid + { s.1e+f32; } //~ ERROR unexpected token: `1e+f32` + //~| ERROR expected one of `.`, `;`, `?`, `}`, or an operator, found `1e+f32` + //~| ERROR expected at least one digit in exponent + { s.1e-f32; } //~ ERROR unexpected token: `1e-f32` + //~| ERROR expected one of `.`, `;`, `?`, `}`, or an operator, found `1e-f32` + //~| ERROR expected at least one digit in exponent + { s.1e+1f32; } //~ ERROR unexpected token: `1e+1f32` + //~| ERROR expected one of `.`, `;`, `?`, `}`, or an operator, found `1e+1f32` + { s.1e-1f32; } //~ ERROR unexpected token: `1e-1f32` + //~| ERROR expected one of `.`, `;`, `?`, `}`, or an operator, found `1e-1f32` + { s.1.1e+1f32; } //~ ERROR unexpected token: `1.1e+1f32` + //~| ERROR expected one of `.`, `;`, `?`, `}`, or an operator, found `1.1e+1f32` + { s.1.1e-1f32; } //~ ERROR unexpected token: `1.1e-1f32` + //~| ERROR expected one of `.`, `;`, `?`, `}`, or an operator, found `1.1e-1f32` +} diff --git a/src/test/ui/parser/float-field.stderr b/src/test/ui/parser/float-field.stderr new file mode 100644 index 0000000000000..62202b999648d --- /dev/null +++ b/src/test/ui/parser/float-field.stderr @@ -0,0 +1,349 @@ +error: expected at least one digit in exponent + --> $DIR/float-field.rs:10:9 + | +LL | { s.1e+; } + | ^^^ + +error: expected at least one digit in exponent + --> $DIR/float-field.rs:13:9 + | +LL | { s.1e-; } + | ^^^ + +error: hexadecimal float literal is not supported + --> $DIR/float-field.rs:25:7 + | +LL | s.0x1.; + | ^^^^ + +error: hexadecimal float literal is not supported + --> $DIR/float-field.rs:28:7 + | +LL | s.0x1.1; + | ^^^^^ + +error: hexadecimal float literal is not supported + --> $DIR/float-field.rs:30:7 + | +LL | s.0x1.1e1; + | ^^^^^^^ + +error: hexadecimal float literal is not supported + --> $DIR/float-field.rs:36:9 + | +LL | { s.0x1.1e+1; } + | ^^^^^^^^ + +error: hexadecimal float literal is not supported + --> $DIR/float-field.rs:39:9 + | +LL | { s.0x1.1e-1; } + | ^^^^^^^^ + +error: expected at least one digit in exponent + --> $DIR/float-field.rs:48:9 + | +LL | { s.1e+f32; } + | ^^^^^^ + +error: expected at least one digit in exponent + --> $DIR/float-field.rs:51:9 + | +LL | { s.1e-f32; } + | ^^^^^^ + +error: unexpected token: `;` + --> $DIR/float-field.rs:7:9 + | +LL | s.1.; + | ^ + +error: unexpected token: `1e+` + --> $DIR/float-field.rs:10:9 + | +LL | { s.1e+; } + | ^^^ + +error: expected one of `.`, `;`, `?`, `}`, or an operator, found `1e+` + --> $DIR/float-field.rs:10:9 + | +LL | { s.1e+; } + | ^^^ expected one of `.`, `;`, `?`, `}`, or an operator + +error: unexpected token: `1e-` + --> $DIR/float-field.rs:13:9 + | +LL | { s.1e-; } + | ^^^ + +error: expected one of `.`, `;`, `?`, `}`, or an operator, found `1e-` + --> $DIR/float-field.rs:13:9 + | +LL | { s.1e-; } + | ^^^ expected one of `.`, `;`, `?`, `}`, or an operator + +error: unexpected token: `1e+1` + --> $DIR/float-field.rs:16:9 + | +LL | { s.1e+1; } + | ^^^^ + +error: expected one of `.`, `;`, `?`, `}`, or an operator, found `1e+1` + --> $DIR/float-field.rs:16:9 + | +LL | { s.1e+1; } + | ^^^^ expected one of `.`, `;`, `?`, `}`, or an operator + +error: unexpected token: `1e-1` + --> $DIR/float-field.rs:18:9 + | +LL | { s.1e-1; } + | ^^^^ + +error: expected one of `.`, `;`, `?`, `}`, or an operator, found `1e-1` + --> $DIR/float-field.rs:18:9 + | +LL | { s.1e-1; } + | ^^^^ expected one of `.`, `;`, `?`, `}`, or an operator + +error: unexpected token: `1.1e+1` + --> $DIR/float-field.rs:20:9 + | +LL | { s.1.1e+1; } + | ^^^^^^ + +error: expected one of `.`, `;`, `?`, `}`, or an operator, found `1.1e+1` + --> $DIR/float-field.rs:20:9 + | +LL | { s.1.1e+1; } + | ^^^^^^ expected one of `.`, `;`, `?`, `}`, or an operator + +error: unexpected token: `1.1e-1` + --> $DIR/float-field.rs:22:9 + | +LL | { s.1.1e-1; } + | ^^^^^^ + +error: expected one of `.`, `;`, `?`, `}`, or an operator, found `1.1e-1` + --> $DIR/float-field.rs:22:9 + | +LL | { s.1.1e-1; } + | ^^^^^^ expected one of `.`, `;`, `?`, `}`, or an operator + +error: unexpected token: `;` + --> $DIR/float-field.rs:25:11 + | +LL | s.0x1.; + | ^ + +error: expected expression, found `;` + --> $DIR/float-field.rs:32:14 + | +LL | { s.0x1e+; } + | ^ expected expression + +error: expected expression, found `;` + --> $DIR/float-field.rs:33:14 + | +LL | { s.0x1e-; } + | ^ expected expression + +error: unexpected token: `0x1.1e+1` + --> $DIR/float-field.rs:36:9 + | +LL | { s.0x1.1e+1; } + | ^^^^^^^^ + +error: expected one of `.`, `;`, `?`, `}`, or an operator, found `0x1.1e+1` + --> $DIR/float-field.rs:36:9 + | +LL | { s.0x1.1e+1; } + | ^^^^^^^^ expected one of `.`, `;`, `?`, `}`, or an operator + +error: unexpected token: `0x1.1e-1` + --> $DIR/float-field.rs:39:9 + | +LL | { s.0x1.1e-1; } + | ^^^^^^^^ + +error: expected one of `.`, `;`, `?`, `}`, or an operator, found `0x1.1e-1` + --> $DIR/float-field.rs:39:9 + | +LL | { s.0x1.1e-1; } + | ^^^^^^^^ expected one of `.`, `;`, `?`, `}`, or an operator + +error: suffixes on a tuple index are invalid + --> $DIR/float-field.rs:42:7 + | +LL | s.1e1f32; + | ^^^^^^ invalid suffix `f32` + +error: suffixes on a tuple index are invalid + --> $DIR/float-field.rs:45:7 + | +LL | s.1.1f32; + | ^^^^^^ invalid suffix `f32` + +error: suffixes on a tuple index are invalid + --> $DIR/float-field.rs:46:7 + | +LL | s.1.1e1f32; + | ^^^^^^^^ invalid suffix `f32` + +error: unexpected token: `1e+f32` + --> $DIR/float-field.rs:48:9 + | +LL | { s.1e+f32; } + | ^^^^^^ + +error: expected one of `.`, `;`, `?`, `}`, or an operator, found `1e+f32` + --> $DIR/float-field.rs:48:9 + | +LL | { s.1e+f32; } + | ^^^^^^ expected one of `.`, `;`, `?`, `}`, or an operator + +error: unexpected token: `1e-f32` + --> $DIR/float-field.rs:51:9 + | +LL | { s.1e-f32; } + | ^^^^^^ + +error: expected one of `.`, `;`, `?`, `}`, or an operator, found `1e-f32` + --> $DIR/float-field.rs:51:9 + | +LL | { s.1e-f32; } + | ^^^^^^ expected one of `.`, `;`, `?`, `}`, or an operator + +error: unexpected token: `1e+1f32` + --> $DIR/float-field.rs:54:9 + | +LL | { s.1e+1f32; } + | ^^^^^^^ + +error: expected one of `.`, `;`, `?`, `}`, or an operator, found `1e+1f32` + --> $DIR/float-field.rs:54:9 + | +LL | { s.1e+1f32; } + | ^^^^^^^ expected one of `.`, `;`, `?`, `}`, or an operator + +error: unexpected token: `1e-1f32` + --> $DIR/float-field.rs:56:9 + | +LL | { s.1e-1f32; } + | ^^^^^^^ + +error: expected one of `.`, `;`, `?`, `}`, or an operator, found `1e-1f32` + --> $DIR/float-field.rs:56:9 + | +LL | { s.1e-1f32; } + | ^^^^^^^ expected one of `.`, `;`, `?`, `}`, or an operator + +error: unexpected token: `1.1e+1f32` + --> $DIR/float-field.rs:58:9 + | +LL | { s.1.1e+1f32; } + | ^^^^^^^^^ + +error: expected one of `.`, `;`, `?`, `}`, or an operator, found `1.1e+1f32` + --> $DIR/float-field.rs:58:9 + | +LL | { s.1.1e+1f32; } + | ^^^^^^^^^ expected one of `.`, `;`, `?`, `}`, or an operator + +error: unexpected token: `1.1e-1f32` + --> $DIR/float-field.rs:60:9 + | +LL | { s.1.1e-1f32; } + | ^^^^^^^^^ + +error: expected one of `.`, `;`, `?`, `}`, or an operator, found `1.1e-1f32` + --> $DIR/float-field.rs:60:9 + | +LL | { s.1.1e-1f32; } + | ^^^^^^^^^ expected one of `.`, `;`, `?`, `}`, or an operator + +error[E0609]: no field `1e1` on type `S` + --> $DIR/float-field.rs:6:7 + | +LL | s.1e1; + | ^^^ unknown field + | + = note: available fields are: `0`, `1` + +error[E0609]: no field `1e1` on type `(u8, u8)` + --> $DIR/float-field.rs:9:7 + | +LL | s.1.1e1; + | ^^^^^ + +error[E0609]: no field `0x1e1` on type `S` + --> $DIR/float-field.rs:24:7 + | +LL | s.0x1e1; + | ^^^^^ unknown field + | + = note: available fields are: `0`, `1` + +error[E0609]: no field `0x1` on type `S` + --> $DIR/float-field.rs:25:7 + | +LL | s.0x1.; + | ^^^^ unknown field + | + = note: available fields are: `0`, `1` + +error[E0609]: no field `0x1` on type `S` + --> $DIR/float-field.rs:28:7 + | +LL | s.0x1.1; + | ^^^^^ unknown field + | + = note: available fields are: `0`, `1` + +error[E0609]: no field `0x1` on type `S` + --> $DIR/float-field.rs:30:7 + | +LL | s.0x1.1e1; + | ^^^^^^^ unknown field + | + = note: available fields are: `0`, `1` + +error[E0609]: no field `0x1e` on type `S` + --> $DIR/float-field.rs:34:7 + | +LL | s.0x1e+1; + | ^^^^ unknown field + | + = note: available fields are: `0`, `1` + +error[E0609]: no field `0x1e` on type `S` + --> $DIR/float-field.rs:35:7 + | +LL | s.0x1e-1; + | ^^^^ unknown field + | + = note: available fields are: `0`, `1` + +error[E0609]: no field `1e1` on type `S` + --> $DIR/float-field.rs:42:7 + | +LL | s.1e1f32; + | ^^^^^^ unknown field + | + = note: available fields are: `0`, `1` + +error[E0609]: no field `f32` on type `(u8, u8)` + --> $DIR/float-field.rs:44:9 + | +LL | s.1.f32; + | ^^^ + +error[E0609]: no field `1e1` on type `(u8, u8)` + --> $DIR/float-field.rs:46:7 + | +LL | s.1.1e1f32; + | ^^^^^^^^ + +error: aborting due to 55 previous errors + +For more information about this error, try `rustc --explain E0609`. diff --git a/src/test/ui/tuple/tuple-float-index.fixed b/src/test/ui/tuple/tuple-float-index.fixed deleted file mode 100644 index cd1a85a9d2442..0000000000000 --- a/src/test/ui/tuple/tuple-float-index.fixed +++ /dev/null @@ -1,5 +0,0 @@ -// run-rustfix - -fn main () { - ((1, (2, 3)).1).1; //~ ERROR unexpected token: `1.1` -} diff --git a/src/test/ui/tuple/tuple-float-index.rs b/src/test/ui/tuple/tuple-float-index.rs deleted file mode 100644 index 1faabac2bcdac..0000000000000 --- a/src/test/ui/tuple/tuple-float-index.rs +++ /dev/null @@ -1,5 +0,0 @@ -// run-rustfix - -fn main () { - (1, (2, 3)).1.1; //~ ERROR unexpected token: `1.1` -} diff --git a/src/test/ui/tuple/tuple-float-index.stderr b/src/test/ui/tuple/tuple-float-index.stderr deleted file mode 100644 index a0ea0e0a30a72..0000000000000 --- a/src/test/ui/tuple/tuple-float-index.stderr +++ /dev/null @@ -1,11 +0,0 @@ -error: unexpected token: `1.1` - --> $DIR/tuple-float-index.rs:4:17 - | -LL | (1, (2, 3)).1.1; - | ------------^^^ - | | | - | | unexpected token - | help: try parenthesizing the first index: `((1, (2, 3)).1).1` - -error: aborting due to previous error - From 40a21707b4c0e7e5a8cb5a03ddebecdd59ab705c Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Thu, 26 Mar 2020 00:17:41 -0700 Subject: [PATCH 05/35] Add test of tuple nested indexing --- src/test/ui/tuple/nested-index.rs | 6 ++++++ 1 file changed, 6 insertions(+) create mode 100644 src/test/ui/tuple/nested-index.rs diff --git a/src/test/ui/tuple/nested-index.rs b/src/test/ui/tuple/nested-index.rs new file mode 100644 index 0000000000000..e498db8cb88ca --- /dev/null +++ b/src/test/ui/tuple/nested-index.rs @@ -0,0 +1,6 @@ +// run-pass + +fn main () { + let n = (1, (2, 3)).1.1; + assert_eq!(n, 3); +} From 0432f63acf5b08c23ad206a87e3ad4a2a171cf7f Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Thu, 26 Mar 2020 00:57:39 -0700 Subject: [PATCH 06/35] Test even deeper nested indexing --- src/test/ui/tuple/nested-index.rs | 3 +++ 1 file changed, 3 insertions(+) diff --git a/src/test/ui/tuple/nested-index.rs b/src/test/ui/tuple/nested-index.rs index e498db8cb88ca..b88f876d858eb 100644 --- a/src/test/ui/tuple/nested-index.rs +++ b/src/test/ui/tuple/nested-index.rs @@ -3,4 +3,7 @@ fn main () { let n = (1, (2, 3)).1.1; assert_eq!(n, 3); + + let n = (1, (2, (3, 4))).1.1.1; + assert_eq!(n, 4); } From 776deb6b9f326f5ba5984e4d55cb5010a17ce559 Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Thu, 26 Mar 2020 00:59:47 -0700 Subject: [PATCH 07/35] Test a range, which is not nested indexing --- src/test/ui/tuple/nested-index.rs | 3 +++ 1 file changed, 3 insertions(+) diff --git a/src/test/ui/tuple/nested-index.rs b/src/test/ui/tuple/nested-index.rs index b88f876d858eb..a3232d6fc361e 100644 --- a/src/test/ui/tuple/nested-index.rs +++ b/src/test/ui/tuple/nested-index.rs @@ -6,4 +6,7 @@ fn main () { let n = (1, (2, (3, 4))).1.1.1; assert_eq!(n, 4); + + // This is a range expression, not nested indexing. + let _ = 0.0..1.1; } From 6dfa549fb5719034b829955384e1e198f4d66c04 Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Thu, 26 Mar 2020 09:36:05 -0700 Subject: [PATCH 08/35] Add tests in which the token really is a float --- src/test/ui/tuple/index-float.rs | 7 +++++++ src/test/ui/tuple/index-float.stderr | 14 ++++++++++++++ 2 files changed, 21 insertions(+) create mode 100644 src/test/ui/tuple/index-float.rs create mode 100644 src/test/ui/tuple/index-float.stderr diff --git a/src/test/ui/tuple/index-float.rs b/src/test/ui/tuple/index-float.rs new file mode 100644 index 0000000000000..673d32e4d4351 --- /dev/null +++ b/src/test/ui/tuple/index-float.rs @@ -0,0 +1,7 @@ +fn main() { + let tuple = (((),),); + + let _ = tuple. 0.0; //~ ERROR unexpected token: `0.0` + + let _ = tuple./*special cases*/0.0; //~ ERROR unexpected token: `0.0` +} diff --git a/src/test/ui/tuple/index-float.stderr b/src/test/ui/tuple/index-float.stderr new file mode 100644 index 0000000000000..505b91e5bbba5 --- /dev/null +++ b/src/test/ui/tuple/index-float.stderr @@ -0,0 +1,14 @@ +error: unexpected token: `0.0` + --> $DIR/index-float.rs:4:20 + | +LL | let _ = tuple. 0.0; + | ^^^ + +error: unexpected token: `0.0` + --> $DIR/index-float.rs:6:36 + | +LL | let _ = tuple./*special cases*/0.0; + | ^^^ + +error: aborting due to 2 previous errors + From 3814eec087c6e5695c92956b7a738f4c2ffd7649 Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Thu, 26 Mar 2020 09:40:05 -0700 Subject: [PATCH 09/35] Add test for tuple indexed with float in macro input --- src/test/ui/tuple/indexing-in-macro.rs | 9 +++++++++ src/test/ui/tuple/indexing-in-macro.stderr | 11 +++++++++++ 2 files changed, 20 insertions(+) create mode 100644 src/test/ui/tuple/indexing-in-macro.rs create mode 100644 src/test/ui/tuple/indexing-in-macro.stderr diff --git a/src/test/ui/tuple/indexing-in-macro.rs b/src/test/ui/tuple/indexing-in-macro.rs new file mode 100644 index 0000000000000..89696cd7fcf44 --- /dev/null +++ b/src/test/ui/tuple/indexing-in-macro.rs @@ -0,0 +1,9 @@ +// Broken by https://github.com/rust-lang/rust/pull/70420. + +macro_rules! m { + (.$l:literal) => {}; +} + +m!(.0.0); //~ ERROR no rules expected the token `.` + +fn main() {} diff --git a/src/test/ui/tuple/indexing-in-macro.stderr b/src/test/ui/tuple/indexing-in-macro.stderr new file mode 100644 index 0000000000000..78879262b0177 --- /dev/null +++ b/src/test/ui/tuple/indexing-in-macro.stderr @@ -0,0 +1,11 @@ +error: no rules expected the token `.` + --> $DIR/indexing-in-macro.rs:7:6 + | +LL | macro_rules! m { + | -------------- when calling this macro +... +LL | m!(.0.0); + | ^ no rules expected this token in macro call + +error: aborting due to previous error + From 63f95a4858bbe8cef9a6e1b0e7e5273255d60926 Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Thu, 26 Mar 2020 09:46:47 -0700 Subject: [PATCH 10/35] Add test for errors triggered on parts of decomposed index --- src/test/ui/tuple/index-invalid.rs | 7 +++++++ src/test/ui/tuple/index-invalid.stderr | 21 +++++++++++++++++++++ 2 files changed, 28 insertions(+) create mode 100644 src/test/ui/tuple/index-invalid.rs create mode 100644 src/test/ui/tuple/index-invalid.stderr diff --git a/src/test/ui/tuple/index-invalid.rs b/src/test/ui/tuple/index-invalid.rs new file mode 100644 index 0000000000000..d36f6cfe3df7f --- /dev/null +++ b/src/test/ui/tuple/index-invalid.rs @@ -0,0 +1,7 @@ +fn main() { + let _ = (((),),).1.0; //~ ERROR no field `1` on type `(((),),)` + + let _ = (((),),).0.1; //~ ERROR no field `1` on type `((),)` + + let _ = (((),),).000.000; //~ ERROR no field `000` on type `(((),),)` +} diff --git a/src/test/ui/tuple/index-invalid.stderr b/src/test/ui/tuple/index-invalid.stderr new file mode 100644 index 0000000000000..8d22f458a6c6e --- /dev/null +++ b/src/test/ui/tuple/index-invalid.stderr @@ -0,0 +1,21 @@ +error[E0609]: no field `1` on type `(((),),)` + --> $DIR/index-invalid.rs:2:22 + | +LL | let _ = (((),),).1.0; + | ^ + +error[E0609]: no field `1` on type `((),)` + --> $DIR/index-invalid.rs:4:24 + | +LL | let _ = (((),),).0.1; + | ^ + +error[E0609]: no field `000` on type `(((),),)` + --> $DIR/index-invalid.rs:6:22 + | +LL | let _ = (((),),).000.000; + | ^^^ + +error: aborting due to 3 previous errors + +For more information about this error, try `rustc --explain E0609`. From 64a88db762bc13b37508d44e09731a3b8349110a Mon Sep 17 00:00:00 2001 From: Vadim Petrochenkov Date: Sun, 19 Apr 2020 15:30:34 +0300 Subject: [PATCH 11/35] Update dtolnay's tests that now work --- src/test/ui/tuple/index-float.rs | 6 ++++-- src/test/ui/tuple/index-float.stderr | 14 -------------- src/test/ui/tuple/index-invalid.stderr | 8 ++++---- src/test/ui/tuple/indexing-in-macro.rs | 4 ++-- src/test/ui/tuple/indexing-in-macro.stderr | 11 ----------- 5 files changed, 10 insertions(+), 33 deletions(-) delete mode 100644 src/test/ui/tuple/index-float.stderr delete mode 100644 src/test/ui/tuple/indexing-in-macro.stderr diff --git a/src/test/ui/tuple/index-float.rs b/src/test/ui/tuple/index-float.rs index 673d32e4d4351..85b088d664da1 100644 --- a/src/test/ui/tuple/index-float.rs +++ b/src/test/ui/tuple/index-float.rs @@ -1,7 +1,9 @@ +// check-pass + fn main() { let tuple = (((),),); - let _ = tuple. 0.0; //~ ERROR unexpected token: `0.0` + let _ = tuple. 0.0; // OK, whitespace - let _ = tuple./*special cases*/0.0; //~ ERROR unexpected token: `0.0` + let _ = tuple./*special cases*/0.0; // OK, comment } diff --git a/src/test/ui/tuple/index-float.stderr b/src/test/ui/tuple/index-float.stderr deleted file mode 100644 index 505b91e5bbba5..0000000000000 --- a/src/test/ui/tuple/index-float.stderr +++ /dev/null @@ -1,14 +0,0 @@ -error: unexpected token: `0.0` - --> $DIR/index-float.rs:4:20 - | -LL | let _ = tuple. 0.0; - | ^^^ - -error: unexpected token: `0.0` - --> $DIR/index-float.rs:6:36 - | -LL | let _ = tuple./*special cases*/0.0; - | ^^^ - -error: aborting due to 2 previous errors - diff --git a/src/test/ui/tuple/index-invalid.stderr b/src/test/ui/tuple/index-invalid.stderr index 8d22f458a6c6e..800b5a31d98ab 100644 --- a/src/test/ui/tuple/index-invalid.stderr +++ b/src/test/ui/tuple/index-invalid.stderr @@ -2,19 +2,19 @@ error[E0609]: no field `1` on type `(((),),)` --> $DIR/index-invalid.rs:2:22 | LL | let _ = (((),),).1.0; - | ^ + | ^^^ error[E0609]: no field `1` on type `((),)` - --> $DIR/index-invalid.rs:4:24 + --> $DIR/index-invalid.rs:4:22 | LL | let _ = (((),),).0.1; - | ^ + | ^^^ error[E0609]: no field `000` on type `(((),),)` --> $DIR/index-invalid.rs:6:22 | LL | let _ = (((),),).000.000; - | ^^^ + | ^^^^^^^ error: aborting due to 3 previous errors diff --git a/src/test/ui/tuple/indexing-in-macro.rs b/src/test/ui/tuple/indexing-in-macro.rs index 89696cd7fcf44..bef4a69ab23c9 100644 --- a/src/test/ui/tuple/indexing-in-macro.rs +++ b/src/test/ui/tuple/indexing-in-macro.rs @@ -1,9 +1,9 @@ -// Broken by https://github.com/rust-lang/rust/pull/70420. +// check-pass macro_rules! m { (.$l:literal) => {}; } -m!(.0.0); //~ ERROR no rules expected the token `.` +m!(.0.0); // OK, `0.0` after a dot is still a float token. fn main() {} diff --git a/src/test/ui/tuple/indexing-in-macro.stderr b/src/test/ui/tuple/indexing-in-macro.stderr deleted file mode 100644 index 78879262b0177..0000000000000 --- a/src/test/ui/tuple/indexing-in-macro.stderr +++ /dev/null @@ -1,11 +0,0 @@ -error: no rules expected the token `.` - --> $DIR/indexing-in-macro.rs:7:6 - | -LL | macro_rules! m { - | -------------- when calling this macro -... -LL | m!(.0.0); - | ^ no rules expected this token in macro call - -error: aborting due to previous error - From 52bdaaa0edb2824af1610b67664f06580335fd78 Mon Sep 17 00:00:00 2001 From: Vadim Petrochenkov Date: Wed, 1 Jul 2020 14:12:49 +0300 Subject: [PATCH 12/35] Add some requested tests --- .../ui/parser/float-field-interpolated.rs | 17 +++++++ .../ui/parser/float-field-interpolated.stderr | 46 +++++++++++++++++++ src/test/ui/tuple/index-float.rs | 1 + 3 files changed, 64 insertions(+) create mode 100644 src/test/ui/parser/float-field-interpolated.rs create mode 100644 src/test/ui/parser/float-field-interpolated.stderr diff --git a/src/test/ui/parser/float-field-interpolated.rs b/src/test/ui/parser/float-field-interpolated.rs new file mode 100644 index 0000000000000..a30532035365b --- /dev/null +++ b/src/test/ui/parser/float-field-interpolated.rs @@ -0,0 +1,17 @@ +struct S(u8, (u8, u8)); + +macro_rules! generate_field_accesses { + ($a:tt, $b:literal, $c:expr) => { + let s = S(0, (0, 0)); + + s.$a; // OK + { s.$b; } //~ ERROR unexpected token: `1.1` + //~| ERROR expected one of `.`, `;`, `?`, `}`, or an operator, found `1.1` + { s.$c; } //~ ERROR unexpected token: `1.1` + //~| ERROR expected one of `.`, `;`, `?`, `}`, or an operator, found `1.1` + }; +} + +fn main() { + generate_field_accesses!(1.1, 1.1, 1.1); +} diff --git a/src/test/ui/parser/float-field-interpolated.stderr b/src/test/ui/parser/float-field-interpolated.stderr new file mode 100644 index 0000000000000..fb974f085cbf1 --- /dev/null +++ b/src/test/ui/parser/float-field-interpolated.stderr @@ -0,0 +1,46 @@ +error: unexpected token: `1.1` + --> $DIR/float-field-interpolated.rs:8:13 + | +LL | { s.$b; } + | ^^ +... +LL | generate_field_accesses!(1.1, 1.1, 1.1); + | ---------------------------------------- in this macro invocation + | + = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info) + +error: expected one of `.`, `;`, `?`, `}`, or an operator, found `1.1` + --> $DIR/float-field-interpolated.rs:8:13 + | +LL | { s.$b; } + | ^^ expected one of `.`, `;`, `?`, `}`, or an operator +... +LL | generate_field_accesses!(1.1, 1.1, 1.1); + | ---------------------------------------- in this macro invocation + | + = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info) + +error: unexpected token: `1.1` + --> $DIR/float-field-interpolated.rs:10:13 + | +LL | { s.$c; } + | ^^ +... +LL | generate_field_accesses!(1.1, 1.1, 1.1); + | ---------------------------------------- in this macro invocation + | + = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info) + +error: expected one of `.`, `;`, `?`, `}`, or an operator, found `1.1` + --> $DIR/float-field-interpolated.rs:10:13 + | +LL | { s.$c; } + | ^^ expected one of `.`, `;`, `?`, `}`, or an operator +... +LL | generate_field_accesses!(1.1, 1.1, 1.1); + | ---------------------------------------- in this macro invocation + | + = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info) + +error: aborting due to 4 previous errors + diff --git a/src/test/ui/tuple/index-float.rs b/src/test/ui/tuple/index-float.rs index 85b088d664da1..eda2bf48581a0 100644 --- a/src/test/ui/tuple/index-float.rs +++ b/src/test/ui/tuple/index-float.rs @@ -4,6 +4,7 @@ fn main() { let tuple = (((),),); let _ = tuple. 0.0; // OK, whitespace + let _ = tuple.0. 0; // OK, whitespace let _ = tuple./*special cases*/0.0; // OK, comment } From fb9fa5ba3ee08171e7d2ff35d28ec0dd93b0287b Mon Sep 17 00:00:00 2001 From: Ralf Jung Date: Fri, 3 Jul 2020 12:12:50 +0200 Subject: [PATCH 13/35] adjust ub-enum test to be endianess-independent --- src/test/ui/consts/const-eval/ub-enum.rs | 5 +++-- src/test/ui/consts/const-eval/ub-enum.stderr | 12 ++++++------ 2 files changed, 9 insertions(+), 8 deletions(-) diff --git a/src/test/ui/consts/const-eval/ub-enum.rs b/src/test/ui/consts/const-eval/ub-enum.rs index c49997c6c33f6..136b33208c293 100644 --- a/src/test/ui/consts/const-eval/ub-enum.rs +++ b/src/test/ui/consts/const-eval/ub-enum.rs @@ -88,9 +88,10 @@ const BAD_OPTION_CHAR: Option<(char, char)> = Some(('x', unsafe { mem::transmute //~^ ERROR is undefined behavior // All variants are uninhabited but also have data. -const BAD_UNINHABITED_WITH_DATA1: Result<(i32, Never), (i32, !)> = unsafe { mem::transmute(1u64) }; +// Use `0` as constant to make behavior endianess-independent. +const BAD_UNINHABITED_WITH_DATA1: Result<(i32, Never), (i32, !)> = unsafe { mem::transmute(0u64) }; //~^ ERROR is undefined behavior -const BAD_UNINHABITED_WITH_DATA2: Result<(i32, !), (i32, Never)> = unsafe { mem::transmute(1u64) }; +const BAD_UNINHABITED_WITH_DATA2: Result<(i32, !), (i32, Never)> = unsafe { mem::transmute(0u64) }; //~^ ERROR is undefined behavior fn main() { diff --git a/src/test/ui/consts/const-eval/ub-enum.stderr b/src/test/ui/consts/const-eval/ub-enum.stderr index 1f7593c6db9b6..9c29aa1a51d1c 100644 --- a/src/test/ui/consts/const-eval/ub-enum.stderr +++ b/src/test/ui/consts/const-eval/ub-enum.stderr @@ -87,18 +87,18 @@ LL | const BAD_OPTION_CHAR: Option<(char, char)> = Some(('x', unsafe { mem::tran = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior. error[E0080]: it is undefined behavior to use this value - --> $DIR/ub-enum.rs:91:1 + --> $DIR/ub-enum.rs:92:1 | -LL | const BAD_UNINHABITED_WITH_DATA1: Result<(i32, Never), (i32, !)> = unsafe { mem::transmute(1u64) }; - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered a value of the never type `!` at ..0.1 +LL | const BAD_UNINHABITED_WITH_DATA1: Result<(i32, Never), (i32, !)> = unsafe { mem::transmute(0u64) }; + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered a value of uninhabited type Never at ..0.1 | = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior. error[E0080]: it is undefined behavior to use this value - --> $DIR/ub-enum.rs:93:1 + --> $DIR/ub-enum.rs:94:1 | -LL | const BAD_UNINHABITED_WITH_DATA2: Result<(i32, !), (i32, Never)> = unsafe { mem::transmute(1u64) }; - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered a value of uninhabited type Never at ..0.1 +LL | const BAD_UNINHABITED_WITH_DATA2: Result<(i32, !), (i32, Never)> = unsafe { mem::transmute(0u64) }; + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered a value of the never type `!` at ..0.1 | = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior. From bcef848a6971217d4b8df50c17e047174018d316 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Tomasz=20Mi=C4=85sko?= Date: Sun, 5 Jul 2020 00:00:00 +0000 Subject: [PATCH 14/35] Explain effects of debugging options from config.toml Co-authored-by: Teymour Aldridge <42674621+teymour-aldridge@users.noreply.github.com> --- config.toml.example | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/config.toml.example b/config.toml.example index 2fa613755d64c..79e4e46d85ba3 100644 --- a/config.toml.example +++ b/config.toml.example @@ -318,7 +318,9 @@ #codegen-units-std = 1 # Whether or not debug assertions are enabled for the compiler and standard -# library. +# library. Debug assertions control the maximum log level used by rustc. When +# enabled calls to `trace!` and `debug!` macros are preserved in the compiled +# binary, otherwise they are omitted. # # Defaults to rust.debug value #debug-assertions = false @@ -331,7 +333,9 @@ # Debuginfo level for most of Rust code, corresponds to the `-C debuginfo=N` option of `rustc`. # `0` - no debug info -# `1` - line tables only +# `1` - line tables only - sufficient to generate backtraces that include line +# information and inlined functions, set breakpoints at source code +# locations, and step through execution in a debugger. # `2` - full debug info with variable and type information # Can be overridden for specific subsets of Rust code (rustc, std or tools). # Debuginfo for tests run with compiletest is not controlled by this option From 7fb26938b1b88d9f3c0d3046712375e48aeb91ae Mon Sep 17 00:00:00 2001 From: Jon Gjengset Date: Mon, 6 Jul 2020 10:33:24 -0400 Subject: [PATCH 15/35] Add VecDeque::range* methods This patch adds `VecDeque::range` and `VecDeque::range_mut` to provide iterators over a sub-range of a `VecDeque`. This behavior can be emulated with `skip` and `take`, but directly providing a `Range` is more ergonomic. This also partially makes up for `VecDeque`'s lack of `SliceIndex` support. --- src/liballoc/collections/vec_deque.rs | 112 +++++++++++++++++--- src/liballoc/collections/vec_deque/tests.rs | 59 +++++++++++ 2 files changed, 158 insertions(+), 13 deletions(-) diff --git a/src/liballoc/collections/vec_deque.rs b/src/liballoc/collections/vec_deque.rs index 15f3a94ca2d6a..08ab6a69ce85c 100644 --- a/src/liballoc/collections/vec_deque.rs +++ b/src/liballoc/collections/vec_deque.rs @@ -1084,6 +1084,104 @@ impl VecDeque { self.tail == self.head } + fn range_start_end(&self, range: R) -> (usize, usize) + where + R: RangeBounds, + { + let len = self.len(); + let start = match range.start_bound() { + Included(&n) => n, + Excluded(&n) => n + 1, + Unbounded => 0, + }; + let end = match range.end_bound() { + Included(&n) => n + 1, + Excluded(&n) => n, + Unbounded => len, + }; + assert!(start <= end, "lower bound was too large"); + assert!(end <= len, "upper bound was too large"); + (start, end) + } + + /// Creates an iterator that covers the specified range in the `VecDeque`. + /// + /// # Panics + /// + /// Panics if the starting point is greater than the end point or if + /// the end point is greater than the length of the vector. + /// + /// # Examples + /// + /// ``` + /// use std::collections::VecDeque; + /// + /// let v: VecDeque<_> = vec![1, 2, 3].into_iter().collect(); + /// let range = v.iter_rage(2..).copied().collect::>(); + /// assert_eq!(range, [3]); + /// + /// // A full range covers all contents + /// let all = v.range(..); + /// assert_eq!(all.len(), 3); + /// ``` + #[inline] + #[unstable(feature = "deque_range", issue = "none")] + pub fn range(&self, range: R) -> Iter<'_, T> + where + R: RangeBounds, + { + let (start, end) = self.range_start_end(range); + let tail = self.wrap_add(self.tail, start); + let head = self.wrap_add(self.tail, end); + Iter { + tail, + head, + // The shared reference we have in &self is maintained in the '_ of Iter. + ring: unsafe { self.buffer_as_slice() }, + } + } + + /// Creates an iterator that covers the specified mutable range in the `VecDeque`. + /// + /// # Panics + /// + /// Panics if the starting point is greater than the end point or if + /// the end point is greater than the length of the vector. + /// + /// # Examples + /// + /// ``` + /// use std::collections::VecDeque; + /// + /// let mut v: VecDeque<_> = vec![1, 2, 3].into_iter().collect(); + /// for v in v.range_mut(2..) { + /// *v *= 2; + /// } + /// assert_eq!(v, vec![1, 2, 6]); + /// + /// // A full range covers all contents + /// for v in v.range_mut(..) { + /// *v *= 2; + /// } + /// assert_eq!(v, vec![2, 4, 12]); + /// ``` + #[inline] + #[unstable(feature = "deque_range", issue = "none")] + pub fn range_mut(&mut self, range: R) -> IterMut<'_, T> + where + R: RangeBounds, + { + let (start, end) = self.range_start_end(range); + let tail = self.wrap_add(self.tail, start); + let head = self.wrap_add(self.tail, end); + IterMut { + tail, + head, + // The shared reference we have in &mut self is maintained in the '_ of IterMut. + ring: unsafe { self.buffer_as_mut_slice() }, + } + } + /// Creates a draining iterator that removes the specified range in the /// `VecDeque` and yields the removed items. /// @@ -1129,19 +1227,7 @@ impl VecDeque { // When finished, the remaining data will be copied back to cover the hole, // and the head/tail values will be restored correctly. // - let len = self.len(); - let start = match range.start_bound() { - Included(&n) => n, - Excluded(&n) => n + 1, - Unbounded => 0, - }; - let end = match range.end_bound() { - Included(&n) => n + 1, - Excluded(&n) => n, - Unbounded => len, - }; - assert!(start <= end, "drain lower bound was too large"); - assert!(end <= len, "drain upper bound was too large"); + let (start, end) = self.range_start_end(range); // The deque's elements are parted into three segments: // * self.tail -> drain_tail diff --git a/src/liballoc/collections/vec_deque/tests.rs b/src/liballoc/collections/vec_deque/tests.rs index 960af4bfda053..4473ce8719e13 100644 --- a/src/liballoc/collections/vec_deque/tests.rs +++ b/src/liballoc/collections/vec_deque/tests.rs @@ -246,6 +246,65 @@ fn test_remove() { } } +#[test] +fn test_range() { + let mut tester: VecDeque = VecDeque::with_capacity(7); + + let cap = tester.capacity(); + for len in 0..=cap { + for tail in 0..=cap { + for start in 0..=len { + for end in drain_start..=len { + tester.tail = tail; + tester.head = tail; + for i in 0..len { + tester.push_back(i); + } + + // Check that we iterate over the correct values + let range: VecDeque<_> = tester.range(start..end).copied().collect(); + let expected: VecDeque<_> = (start..end).collect(); + assert_eq!(range, expected); + } + } + } + } +} + +#[test] +fn test_range_mut() { + let mut tester: VecDeque = VecDeque::with_capacity(7); + + let cap = tester.capacity(); + for len in 0..=cap { + for tail in 0..=cap { + for start in 0..=len { + for end in drain_start..=len { + tester.tail = tail; + tester.head = tail; + for i in 0..len { + tester.push_back(i); + } + + let head_was = tester.head; + let tail_was = tester.tail; + + // Check that we iterate over the correct values + let range: VecDeque<_> = tester.range_mut(start..end).copied().collect(); + let expected: VecDeque<_> = (start..end).collect(); + assert_eq!(range, expected); + + // We shouldn't have changed the capacity or made the + // head or tail out of bounds + assert_eq!(tester.capacity(), cap); + assert_eq!(tester.tail, tail_was); + assert_eq!(tester.head, head_was); + } + } + } + } +} + #[test] fn test_drain() { let mut tester: VecDeque = VecDeque::with_capacity(7); From 8872ec37600114e3e1a07c18443a119788bbb052 Mon Sep 17 00:00:00 2001 From: Jon Gjengset Date: Mon, 6 Jul 2020 11:52:20 -0400 Subject: [PATCH 16/35] fixups --- src/liballoc/collections/vec_deque.rs | 6 +++++- src/liballoc/collections/vec_deque/tests.rs | 6 +++--- src/liballoc/lib.rs | 1 + 3 files changed, 9 insertions(+), 4 deletions(-) diff --git a/src/liballoc/collections/vec_deque.rs b/src/liballoc/collections/vec_deque.rs index 08ab6a69ce85c..4efa7ef6f5e9d 100644 --- a/src/liballoc/collections/vec_deque.rs +++ b/src/liballoc/collections/vec_deque.rs @@ -1114,10 +1114,12 @@ impl VecDeque { /// # Examples /// /// ``` + /// #![feature(deque_range)] + /// /// use std::collections::VecDeque; /// /// let v: VecDeque<_> = vec![1, 2, 3].into_iter().collect(); - /// let range = v.iter_rage(2..).copied().collect::>(); + /// let range = v.range(2..).copied().collect::>(); /// assert_eq!(range, [3]); /// /// // A full range covers all contents @@ -1151,6 +1153,8 @@ impl VecDeque { /// # Examples /// /// ``` + /// #![feature(deque_range)] + /// /// use std::collections::VecDeque; /// /// let mut v: VecDeque<_> = vec![1, 2, 3].into_iter().collect(); diff --git a/src/liballoc/collections/vec_deque/tests.rs b/src/liballoc/collections/vec_deque/tests.rs index 4473ce8719e13..e5edfe02a525f 100644 --- a/src/liballoc/collections/vec_deque/tests.rs +++ b/src/liballoc/collections/vec_deque/tests.rs @@ -254,7 +254,7 @@ fn test_range() { for len in 0..=cap { for tail in 0..=cap { for start in 0..=len { - for end in drain_start..=len { + for end in start..=len { tester.tail = tail; tester.head = tail; for i in 0..len { @@ -279,7 +279,7 @@ fn test_range_mut() { for len in 0..=cap { for tail in 0..=cap { for start in 0..=len { - for end in drain_start..=len { + for end in start..=len { tester.tail = tail; tester.head = tail; for i in 0..len { @@ -290,7 +290,7 @@ fn test_range_mut() { let tail_was = tester.tail; // Check that we iterate over the correct values - let range: VecDeque<_> = tester.range_mut(start..end).copied().collect(); + let range: VecDeque<_> = tester.range_mut(start..end).map(|v| *v).collect(); let expected: VecDeque<_> = (start..end).collect(); assert_eq!(range, expected); diff --git a/src/liballoc/lib.rs b/src/liballoc/lib.rs index 79bfd57a00fa9..2ec777ac85c66 100644 --- a/src/liballoc/lib.rs +++ b/src/liballoc/lib.rs @@ -89,6 +89,7 @@ #![feature(const_in_array_repeat_expressions)] #![cfg_attr(bootstrap, feature(const_if_match))] #![feature(cow_is_borrowed)] +#![feature(deque_range)] #![feature(dispatch_from_dyn)] #![feature(core_intrinsics)] #![feature(container_error_extra)] From 5702e0289f7d19f0ea133d43da7dcd7cbfc5b557 Mon Sep 17 00:00:00 2001 From: Gary Guo Date: Mon, 6 Jul 2020 20:42:19 +0100 Subject: [PATCH 17/35] Only allow `repr(i128/u128)` on enum --- src/librustc_passes/check_attr.rs | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/librustc_passes/check_attr.rs b/src/librustc_passes/check_attr.rs index ef84f251390e6..fee63b1ee524e 100644 --- a/src/librustc_passes/check_attr.rs +++ b/src/librustc_passes/check_attr.rs @@ -292,6 +292,8 @@ impl CheckAttrVisitor<'tcx> { | sym::u32 | sym::i64 | sym::u64 + | sym::i128 + | sym::u128 | sym::isize | sym::usize => { int_reprs += 1; From 97867bbe5cd09df7754864c826f58d3029f4422e Mon Sep 17 00:00:00 2001 From: Gary Guo Date: Mon, 6 Jul 2020 21:04:54 +0100 Subject: [PATCH 18/35] Add UI test for issue 74082 --- src/test/ui/issues/issue-74082.rs | 9 +++++++++ src/test/ui/issues/issue-74082.stderr | 19 +++++++++++++++++++ 2 files changed, 28 insertions(+) create mode 100644 src/test/ui/issues/issue-74082.rs create mode 100644 src/test/ui/issues/issue-74082.stderr diff --git a/src/test/ui/issues/issue-74082.rs b/src/test/ui/issues/issue-74082.rs new file mode 100644 index 0000000000000..982f8ef02538b --- /dev/null +++ b/src/test/ui/issues/issue-74082.rs @@ -0,0 +1,9 @@ +#![allow(dead_code)] + +#[repr(i128)] //~ ERROR: attribute should be applied to enum +struct Foo; + +#[repr(u128)] //~ ERROR: attribute should be applied to enum +struct Bar; + +fn main() {} diff --git a/src/test/ui/issues/issue-74082.stderr b/src/test/ui/issues/issue-74082.stderr new file mode 100644 index 0000000000000..08fe415513d0d --- /dev/null +++ b/src/test/ui/issues/issue-74082.stderr @@ -0,0 +1,19 @@ +error[E0517]: attribute should be applied to enum + --> $DIR/issue-74082.rs:3:8 + | +LL | #[repr(i128)] + | ^^^^ +LL | struct Foo; + | ----------- not an enum + +error[E0517]: attribute should be applied to enum + --> $DIR/issue-74082.rs:6:8 + | +LL | #[repr(u128)] + | ^^^^ +LL | struct Bar; + | ----------- not an enum + +error: aborting due to 2 previous errors + +For more information about this error, try `rustc --explain E0517`. From b82df31bf30e43402619d42acba78245acca22ee Mon Sep 17 00:00:00 2001 From: Aleksey Kladov Date: Tue, 7 Jul 2020 18:37:41 +0200 Subject: [PATCH 19/35] :arrow_up: rust-analyzer --- src/tools/rust-analyzer | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/tools/rust-analyzer b/src/tools/rust-analyzer index f5a4a4b46e706..8b0983e89ad9a 160000 --- a/src/tools/rust-analyzer +++ b/src/tools/rust-analyzer @@ -1 +1 @@ -Subproject commit f5a4a4b46e706697abe4bd136503ecc09aa23b61 +Subproject commit 8b0983e89ad9a28b142eccf3755a8c9aaeb37852 From b50c13cc28b3c6c5968ec3f8cf0c1aa11e463d9f Mon Sep 17 00:00:00 2001 From: Eric Huss Date: Tue, 7 Jul 2020 13:53:46 -0700 Subject: [PATCH 20/35] Update books --- src/doc/book | 2 +- src/doc/embedded-book | 2 +- src/doc/reference | 2 +- src/doc/rust-by-example | 2 +- 4 files changed, 4 insertions(+), 4 deletions(-) diff --git a/src/doc/book b/src/doc/book index 4e7c00bece154..84a31397b34f9 160000 --- a/src/doc/book +++ b/src/doc/book @@ -1 +1 @@ -Subproject commit 4e7c00bece1544d409312ec93467beb62b5bd0cb +Subproject commit 84a31397b34f9d405df44f2899ff17a4828dba18 diff --git a/src/doc/embedded-book b/src/doc/embedded-book index 616962ad0dd80..94d9ea8460bcb 160000 --- a/src/doc/embedded-book +++ b/src/doc/embedded-book @@ -1 +1 @@ -Subproject commit 616962ad0dd80f34d8b802da038d0aed9dd691bb +Subproject commit 94d9ea8460bcbbbfef1877b47cb930260b5849a7 diff --git a/src/doc/reference b/src/doc/reference index 04d5d5d7ba624..0ea7bc494f128 160000 --- a/src/doc/reference +++ b/src/doc/reference @@ -1 +1 @@ -Subproject commit 04d5d5d7ba624b6f5016298451f3a63d557f3260 +Subproject commit 0ea7bc494f1289234d8800bb9185021e0ad946f0 diff --git a/src/doc/rust-by-example b/src/doc/rust-by-example index 6f94ccb48da6f..229c6945a26a5 160000 --- a/src/doc/rust-by-example +++ b/src/doc/rust-by-example @@ -1 +1 @@ -Subproject commit 6f94ccb48da6fa4ed0031290f21411cf789f7d5e +Subproject commit 229c6945a26a53a751ffa4f9cb418388c00029d3 From 32025fd76a2f95b339cc0cca8e779bebc06d7f70 Mon Sep 17 00:00:00 2001 From: Michael Forney Date: Sun, 24 May 2020 17:08:45 -0700 Subject: [PATCH 21/35] Update rust-installer to latest version This pulls in a fix for the install script on some tr(1) implementations, as well as an update to use `anyhow` instead of `failure` for error handling. --- Cargo.lock | 2 +- src/tools/rust-installer | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index cedf44be85bda..2096a3dfff9ea 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1366,8 +1366,8 @@ checksum = "7e81a7c05f79578dbc15793d8b619db9ba32b4577003ef3af1a91c416798c58d" name = "installer" version = "0.0.0" dependencies = [ + "anyhow", "clap", - "failure", "flate2", "lazy_static", "num_cpus", diff --git a/src/tools/rust-installer b/src/tools/rust-installer index 9f66c14c3f91a..d66f476b4d5e7 160000 --- a/src/tools/rust-installer +++ b/src/tools/rust-installer @@ -1 +1 @@ -Subproject commit 9f66c14c3f91a48a118c7817f434167b311c3515 +Subproject commit d66f476b4d5e7fdf1ec215c9ac16c923dc292324 From 653c0912628382388ceb8a3cf29e88dad35b98ac Mon Sep 17 00:00:00 2001 From: Dan Gohman Date: Fri, 3 Jul 2020 16:20:37 -0700 Subject: [PATCH 22/35] Add `read_exact_at` and `write_all_at` to WASI's `FileExt` This adds `read_exact_at` and `write_all_at` to WASI's `FileExt`, similar to the Unix versions of the same names. --- src/libstd/sys/wasi/ext/fs.rs | 94 +++++++++++++++++++++++++++++++++++ 1 file changed, 94 insertions(+) diff --git a/src/libstd/sys/wasi/ext/fs.rs b/src/libstd/sys/wasi/ext/fs.rs index 6696efa8871c2..10ea4fd34bda3 100644 --- a/src/libstd/sys/wasi/ext/fs.rs +++ b/src/libstd/sys/wasi/ext/fs.rs @@ -27,6 +27,58 @@ pub trait FileExt { /// [`File::read`]: ../../../../std/fs/struct.File.html#method.read_vectored fn read_at(&self, bufs: &mut [IoSliceMut<'_>], offset: u64) -> io::Result; + /// Reads the exact number of byte required to fill `buf` from the given offset. + /// + /// The offset is relative to the start of the file and thus independent + /// from the current cursor. + /// + /// The current file cursor is not affected by this function. + /// + /// Similar to [`Read::read_exact`] but uses [`read_at`] instead of `read`. + /// + /// [`Read::read_exact`]: ../../../../std/io/trait.Read.html#method.read_exact + /// [`read_at`]: #tymethod.read_at + /// + /// # Errors + /// + /// If this function encounters an error of the kind + /// [`ErrorKind::Interrupted`] then the error is ignored and the operation + /// will continue. + /// + /// If this function encounters an "end of file" before completely filling + /// the buffer, it returns an error of the kind [`ErrorKind::UnexpectedEof`]. + /// The contents of `buf` are unspecified in this case. + /// + /// If any other read error is encountered then this function immediately + /// returns. The contents of `buf` are unspecified in this case. + /// + /// If this function returns an error, it is unspecified how many bytes it + /// has read, but it will never read more than would be necessary to + /// completely fill the buffer. + /// + /// [`ErrorKind::Interrupted`]: ../../../../std/io/enum.ErrorKind.html#variant.Interrupted + /// [`ErrorKind::UnexpectedEof`]: ../../../../std/io/enum.ErrorKind.html#variant.UnexpectedEof + #[stable(feature = "rw_exact_all_at", since = "1.33.0")] + fn read_exact_at(&self, mut buf: &mut [u8], mut offset: u64) -> io::Result<()> { + while !buf.is_empty() { + match self.read_at(buf, offset) { + Ok(0) => break, + Ok(n) => { + let tmp = buf; + buf = &mut tmp[n..]; + offset += n as u64; + } + Err(ref e) if e.kind() == io::ErrorKind::Interrupted => {} + Err(e) => return Err(e), + } + } + if !buf.is_empty() { + Err(io::Error::new(io::ErrorKind::UnexpectedEof, "failed to fill whole buffer")) + } else { + Ok(()) + } + } + /// Writes a number of bytes starting from a given offset. /// /// Returns the number of bytes written. @@ -45,6 +97,48 @@ pub trait FileExt { /// [`File::write`]: ../../../../std/fs/struct.File.html#method.write_vectored fn write_at(&self, bufs: &[IoSlice<'_>], offset: u64) -> io::Result; + /// Attempts to write an entire buffer starting from a given offset. + /// + /// The offset is relative to the start of the file and thus independent + /// from the current cursor. + /// + /// The current file cursor is not affected by this function. + /// + /// This method will continuously call [`write_at`] until there is no more data + /// to be written or an error of non-[`ErrorKind::Interrupted`] kind is + /// returned. This method will not return until the entire buffer has been + /// successfully written or such an error occurs. The first error that is + /// not of [`ErrorKind::Interrupted`] kind generated from this method will be + /// returned. + /// + /// # Errors + /// + /// This function will return the first error of + /// non-[`ErrorKind::Interrupted`] kind that [`write_at`] returns. + /// + /// [`ErrorKind::Interrupted`]: ../../../../std/io/enum.ErrorKind.html#variant.Interrupted + /// [`write_at`]: #tymethod.write_at + #[stable(feature = "rw_exact_all_at", since = "1.33.0")] + fn write_all_at(&self, mut buf: &[u8], mut offset: u64) -> io::Result<()> { + while !buf.is_empty() { + match self.write_at(buf, offset) { + Ok(0) => { + return Err(io::Error::new( + io::ErrorKind::WriteZero, + "failed to write whole buffer", + )); + } + Ok(n) => { + buf = &buf[n..]; + offset += n as u64 + } + Err(ref e) if e.kind() == io::ErrorKind::Interrupted => {} + Err(e) => return Err(e), + } + } + Ok(()) + } + /// Returns the current position within the file. /// /// This corresponds to the `fd_tell` syscall and is similar to From 58fc61b79cd15fdafad6e15991553f5c33422ade Mon Sep 17 00:00:00 2001 From: Dan Gohman Date: Tue, 7 Jul 2020 15:56:07 -0700 Subject: [PATCH 23/35] Make WASI's FileExt's read_at/write_at consistent with other targets. Rename the existing read_at/write_at to read_vectored_at/write_vectored_at, for consistency with libstd's read_vectored/write_vectored. And, introduce new read_at/write_at functions which take a single buffer, similar to all other targets which provide these functions, so this will make it easier for applications to share code between WASI and other targets. Note that WASI's FileExt is currently unstable. --- src/libstd/sys/wasi/ext/fs.rs | 47 ++++++++++++++++++++++++++++++++--- 1 file changed, 43 insertions(+), 4 deletions(-) diff --git a/src/libstd/sys/wasi/ext/fs.rs b/src/libstd/sys/wasi/ext/fs.rs index 10ea4fd34bda3..f41c6626ccf12 100644 --- a/src/libstd/sys/wasi/ext/fs.rs +++ b/src/libstd/sys/wasi/ext/fs.rs @@ -12,6 +12,24 @@ use crate::sys_common::{AsInner, AsInnerMut, FromInner}; /// /// [`File`]: ../../../../std/fs/struct.File.html pub trait FileExt { + /// Reads a number of bytes starting from a given offset. + /// + /// Returns the number of bytes read. + /// + /// The offset is relative to the start of the file and thus independent + /// from the current cursor. + /// + /// The current file cursor is not affected by this function. + /// + /// Note that similar to [`File::read`], it is not an error to return with a + /// short read. + /// + /// [`File::read`]: ../../../../std/fs/struct.File.html#method.read + fn read_at(&self, buf: &mut [u8], offset: u64) -> io::Result { + let bufs = &mut [IoSliceMut::new(buf)]; + self.read_vectored_at(bufs, offset) + } + /// Reads a number of bytes starting from a given offset. /// /// Returns the number of bytes read. @@ -25,7 +43,7 @@ pub trait FileExt { /// return with a short read. /// /// [`File::read`]: ../../../../std/fs/struct.File.html#method.read_vectored - fn read_at(&self, bufs: &mut [IoSliceMut<'_>], offset: u64) -> io::Result; + fn read_vectored_at(&self, bufs: &mut [IoSliceMut<'_>], offset: u64) -> io::Result; /// Reads the exact number of byte required to fill `buf` from the given offset. /// @@ -79,6 +97,27 @@ pub trait FileExt { } } + /// Writes a number of bytes starting from a given offset. + /// + /// Returns the number of bytes written. + /// + /// The offset is relative to the start of the file and thus independent + /// from the current cursor. + /// + /// The current file cursor is not affected by this function. + /// + /// When writing beyond the end of the file, the file is appropriately + /// extended and the intermediate bytes are initialized with the value 0. + /// + /// Note that similar to [`File::write`], it is not an error to return a + /// short write. + /// + /// [`File::write`]: ../../../../std/fs/struct.File.html#write.v + fn write_at(&self, buf: &[u8], offset: u64) -> io::Result { + let bufs = &[IoSlice::new(buf)]; + self.write_vectored_at(bufs, offset) + } + /// Writes a number of bytes starting from a given offset. /// /// Returns the number of bytes written. @@ -95,7 +134,7 @@ pub trait FileExt { /// short write. /// /// [`File::write`]: ../../../../std/fs/struct.File.html#method.write_vectored - fn write_at(&self, bufs: &[IoSlice<'_>], offset: u64) -> io::Result; + fn write_vectored_at(&self, bufs: &[IoSlice<'_>], offset: u64) -> io::Result; /// Attempts to write an entire buffer starting from a given offset. /// @@ -199,11 +238,11 @@ pub trait FileExt { // FIXME: bind random_get maybe? - on crates.io for unix impl FileExt for fs::File { - fn read_at(&self, bufs: &mut [IoSliceMut<'_>], offset: u64) -> io::Result { + fn read_vectored_at(&self, bufs: &mut [IoSliceMut<'_>], offset: u64) -> io::Result { self.as_inner().fd().pread(bufs, offset) } - fn write_at(&self, bufs: &[IoSlice<'_>], offset: u64) -> io::Result { + fn write_vectored_at(&self, bufs: &[IoSlice<'_>], offset: u64) -> io::Result { self.as_inner().fd().pwrite(bufs, offset) } From 3c63fba03daedf014b75e12f32f4daec3598f9a3 Mon Sep 17 00:00:00 2001 From: Ayaz Hafiz Date: Tue, 7 Jul 2020 07:50:49 -0700 Subject: [PATCH 24/35] Correctly mark the ending span of a match arm Closes #74050 r? @matthewjasper --- src/librustc_parse/parser/expr.rs | 2 +- ....match_tuple.SimplifyCfg-initial.after.mir | 4 +- .../32bit/rustc.main.SimplifyArmIdentity.diff | 2 +- .../64bit/rustc.main.SimplifyArmIdentity.diff | 2 +- ...complicated_match.ElaborateDrops.after.mir | 44 +++++++++---------- ...icated_match.SimplifyCfg-initial.after.mir | 44 +++++++++---------- ...c.full_tested_match.PromoteTemps.after.mir | 12 ++--- ...full_tested_match2.PromoteTemps.before.mir | 12 ++--- .../rustc.main.PromoteTemps.before.mir | 24 +++++----- .../rustc.main.SimplifyCfg-initial.after.mir | 4 +- ...wrap.SimplifyCfg-elaborate-drops.after.mir | 2 +- ...tch_guard.CleanupNonCodegenStatements.diff | 4 +- .../32bit/rustc.main.SimplifyArmIdentity.diff | 2 +- .../64bit/rustc.main.SimplifyArmIdentity.diff | 2 +- .../rustc.id.SimplifyArmIdentity.diff | 2 +- .../rustc.id.SimplifyBranchSame.diff | 2 +- .../rustc.id_result.SimplifyArmIdentity.diff | 4 +- .../rustc.id_result.SimplifyBranchSame.diff | 4 +- ...c.{{impl}}-append.SimplifyArmIdentity.diff | 2 +- src/test/ui/match/issue-74050-end-span.rs | 13 ++++++ src/test/ui/match/issue-74050-end-span.stderr | 15 +++++++ 21 files changed, 115 insertions(+), 87 deletions(-) create mode 100644 src/test/ui/match/issue-74050-end-span.rs create mode 100644 src/test/ui/match/issue-74050-end-span.stderr diff --git a/src/librustc_parse/parser/expr.rs b/src/librustc_parse/parser/expr.rs index abb444933536f..876ce3ab2cb43 100644 --- a/src/librustc_parse/parser/expr.rs +++ b/src/librustc_parse/parser/expr.rs @@ -1790,7 +1790,7 @@ impl<'a> Parser<'a> { let require_comma = classify::expr_requires_semi_to_be_stmt(&expr) && self.token != token::CloseDelim(token::Brace); - let hi = self.token.span; + let hi = self.prev_token.span; if require_comma { let sm = self.sess.source_map(); diff --git a/src/test/mir-opt/exponential-or/rustc.match_tuple.SimplifyCfg-initial.after.mir b/src/test/mir-opt/exponential-or/rustc.match_tuple.SimplifyCfg-initial.after.mir index b84ca5df9964e..00942cd12b42c 100644 --- a/src/test/mir-opt/exponential-or/rustc.match_tuple.SimplifyCfg-initial.after.mir +++ b/src/test/mir-opt/exponential-or/rustc.match_tuple.SimplifyCfg-initial.after.mir @@ -102,8 +102,8 @@ fn match_tuple(_1: (u32, bool, std::option::Option, u32)) -> u32 { _0 = BitXor(move _9, move _10); // scope 1 at $DIR/exponential-or.rs:8:83: 8:88 StorageDead(_10); // scope 1 at $DIR/exponential-or.rs:8:87: 8:88 StorageDead(_9); // scope 1 at $DIR/exponential-or.rs:8:87: 8:88 - StorageDead(_8); // scope 0 at $DIR/exponential-or.rs:8:88: 8:89 - StorageDead(_7); // scope 0 at $DIR/exponential-or.rs:8:88: 8:89 + StorageDead(_8); // scope 0 at $DIR/exponential-or.rs:8:87: 8:88 + StorageDead(_7); // scope 0 at $DIR/exponential-or.rs:8:87: 8:88 goto -> bb10; // scope 0 at $DIR/exponential-or.rs:7:5: 10:6 } diff --git a/src/test/mir-opt/issue-73223/32bit/rustc.main.SimplifyArmIdentity.diff b/src/test/mir-opt/issue-73223/32bit/rustc.main.SimplifyArmIdentity.diff index e5b4a0328808f..1020fc965fe86 100644 --- a/src/test/mir-opt/issue-73223/32bit/rustc.main.SimplifyArmIdentity.diff +++ b/src/test/mir-opt/issue-73223/32bit/rustc.main.SimplifyArmIdentity.diff @@ -137,7 +137,7 @@ StorageLive(_4); // scope 0 at $DIR/issue-73223.rs:3:14: 3:15 _4 = ((_2 as Some).0: i32); // scope 0 at $DIR/issue-73223.rs:3:14: 3:15 _1 = _4; // scope 2 at $DIR/issue-73223.rs:3:20: 3:21 - StorageDead(_4); // scope 0 at $DIR/issue-73223.rs:3:21: 3:22 + StorageDead(_4); // scope 0 at $DIR/issue-73223.rs:3:20: 3:21 StorageDead(_2); // scope 0 at $DIR/issue-73223.rs:5:6: 5:7 StorageLive(_6); // scope 1 at $DIR/issue-73223.rs:7:9: 7:14 StorageLive(_7); // scope 1 at $DIR/issue-73223.rs:7:22: 7:27 diff --git a/src/test/mir-opt/issue-73223/64bit/rustc.main.SimplifyArmIdentity.diff b/src/test/mir-opt/issue-73223/64bit/rustc.main.SimplifyArmIdentity.diff index 0c2651dc3c68d..aa606ed22b6d0 100644 --- a/src/test/mir-opt/issue-73223/64bit/rustc.main.SimplifyArmIdentity.diff +++ b/src/test/mir-opt/issue-73223/64bit/rustc.main.SimplifyArmIdentity.diff @@ -137,7 +137,7 @@ StorageLive(_4); // scope 0 at $DIR/issue-73223.rs:3:14: 3:15 _4 = ((_2 as Some).0: i32); // scope 0 at $DIR/issue-73223.rs:3:14: 3:15 _1 = _4; // scope 2 at $DIR/issue-73223.rs:3:20: 3:21 - StorageDead(_4); // scope 0 at $DIR/issue-73223.rs:3:21: 3:22 + StorageDead(_4); // scope 0 at $DIR/issue-73223.rs:3:20: 3:21 StorageDead(_2); // scope 0 at $DIR/issue-73223.rs:5:6: 5:7 StorageLive(_6); // scope 1 at $DIR/issue-73223.rs:7:9: 7:14 StorageLive(_7); // scope 1 at $DIR/issue-73223.rs:7:22: 7:27 diff --git a/src/test/mir-opt/match-arm-scopes/rustc.complicated_match.ElaborateDrops.after.mir b/src/test/mir-opt/match-arm-scopes/rustc.complicated_match.ElaborateDrops.after.mir index c6832f21208d4..df6a247bb5ff6 100644 --- a/src/test/mir-opt/match-arm-scopes/rustc.complicated_match.ElaborateDrops.after.mir +++ b/src/test/mir-opt/match-arm-scopes/rustc.complicated_match.ElaborateDrops.after.mir @@ -61,7 +61,7 @@ fn complicated_match(_1: bool, _2: (bool, bool, std::string::String)) -> i32 { // mir::Constant // + span: $DIR/match-arm-scopes.rs:16:77: 16:78 // + literal: Const { ty: i32, val: Value(Scalar(0x00000001)) } - drop(_7) -> [return: bb19, unwind: bb10]; // scope 0 at $DIR/match-arm-scopes.rs:16:78: 16:79 + drop(_7) -> [return: bb19, unwind: bb10]; // scope 0 at $DIR/match-arm-scopes.rs:16:77: 16:78 } bb6: { @@ -90,9 +90,9 @@ fn complicated_match(_1: bool, _2: (bool, bool, std::string::String)) -> i32 { // + span: $DIR/match-arm-scopes.rs:16:59: 16:60 // + literal: Const { ty: i32, val: Value(Scalar(0x00000003)) } StorageDead(_10); // scope 0 at $DIR/match-arm-scopes.rs:16:72: 16:73 - StorageDead(_9); // scope 0 at $DIR/match-arm-scopes.rs:16:78: 16:79 - StorageDead(_8); // scope 0 at $DIR/match-arm-scopes.rs:16:78: 16:79 - StorageDead(_6); // scope 0 at $DIR/match-arm-scopes.rs:16:78: 16:79 + StorageDead(_9); // scope 0 at $DIR/match-arm-scopes.rs:16:77: 16:78 + StorageDead(_8); // scope 0 at $DIR/match-arm-scopes.rs:16:77: 16:78 + StorageDead(_6); // scope 0 at $DIR/match-arm-scopes.rs:16:77: 16:78 goto -> bb11; // scope 0 at $DIR/match-arm-scopes.rs:16:52: 16:60 } @@ -109,7 +109,7 @@ fn complicated_match(_1: bool, _2: (bool, bool, std::string::String)) -> i32 { } bb12: { - StorageDead(_9); // scope 0 at $DIR/match-arm-scopes.rs:16:78: 16:79 + StorageDead(_9); // scope 0 at $DIR/match-arm-scopes.rs:16:77: 16:78 StorageLive(_5); // scope 0 at $DIR/match-arm-scopes.rs:16:17: 16:18 _5 = (_2.1: bool); // scope 0 at $DIR/match-arm-scopes.rs:16:17: 16:18 StorageLive(_7); // scope 0 at $DIR/match-arm-scopes.rs:16:20: 16:21 @@ -118,9 +118,9 @@ fn complicated_match(_1: bool, _2: (bool, bool, std::string::String)) -> i32 { } bb13: { - StorageDead(_9); // scope 0 at $DIR/match-arm-scopes.rs:16:78: 16:79 - StorageDead(_8); // scope 0 at $DIR/match-arm-scopes.rs:16:78: 16:79 - StorageDead(_6); // scope 0 at $DIR/match-arm-scopes.rs:16:78: 16:79 + StorageDead(_9); // scope 0 at $DIR/match-arm-scopes.rs:16:77: 16:78 + StorageDead(_8); // scope 0 at $DIR/match-arm-scopes.rs:16:77: 16:78 + StorageDead(_6); // scope 0 at $DIR/match-arm-scopes.rs:16:77: 16:78 goto -> bb2; // scope 0 at $DIR/match-arm-scopes.rs:16:42: 16:73 } @@ -150,14 +150,14 @@ fn complicated_match(_1: bool, _2: (bool, bool, std::string::String)) -> i32 { // + span: $DIR/match-arm-scopes.rs:16:59: 16:60 // + literal: Const { ty: i32, val: Value(Scalar(0x00000003)) } StorageDead(_13); // scope 0 at $DIR/match-arm-scopes.rs:16:72: 16:73 - StorageDead(_12); // scope 0 at $DIR/match-arm-scopes.rs:16:78: 16:79 - StorageDead(_8); // scope 0 at $DIR/match-arm-scopes.rs:16:78: 16:79 - StorageDead(_6); // scope 0 at $DIR/match-arm-scopes.rs:16:78: 16:79 + StorageDead(_12); // scope 0 at $DIR/match-arm-scopes.rs:16:77: 16:78 + StorageDead(_8); // scope 0 at $DIR/match-arm-scopes.rs:16:77: 16:78 + StorageDead(_6); // scope 0 at $DIR/match-arm-scopes.rs:16:77: 16:78 goto -> bb11; // scope 0 at $DIR/match-arm-scopes.rs:16:52: 16:60 } bb17: { - StorageDead(_12); // scope 0 at $DIR/match-arm-scopes.rs:16:78: 16:79 + StorageDead(_12); // scope 0 at $DIR/match-arm-scopes.rs:16:77: 16:78 StorageLive(_5); // scope 0 at $DIR/match-arm-scopes.rs:16:26: 16:27 _5 = (_2.0: bool); // scope 0 at $DIR/match-arm-scopes.rs:16:26: 16:27 StorageLive(_7); // scope 0 at $DIR/match-arm-scopes.rs:16:36: 16:37 @@ -166,17 +166,17 @@ fn complicated_match(_1: bool, _2: (bool, bool, std::string::String)) -> i32 { } bb18: { - StorageDead(_12); // scope 0 at $DIR/match-arm-scopes.rs:16:78: 16:79 - StorageDead(_8); // scope 0 at $DIR/match-arm-scopes.rs:16:78: 16:79 - StorageDead(_6); // scope 0 at $DIR/match-arm-scopes.rs:16:78: 16:79 + StorageDead(_12); // scope 0 at $DIR/match-arm-scopes.rs:16:77: 16:78 + StorageDead(_8); // scope 0 at $DIR/match-arm-scopes.rs:16:77: 16:78 + StorageDead(_6); // scope 0 at $DIR/match-arm-scopes.rs:16:77: 16:78 goto -> bb3; // scope 0 at $DIR/match-arm-scopes.rs:16:42: 16:73 } bb19: { - StorageDead(_7); // scope 0 at $DIR/match-arm-scopes.rs:16:78: 16:79 - StorageDead(_5); // scope 0 at $DIR/match-arm-scopes.rs:16:78: 16:79 - StorageDead(_8); // scope 0 at $DIR/match-arm-scopes.rs:16:78: 16:79 - StorageDead(_6); // scope 0 at $DIR/match-arm-scopes.rs:16:78: 16:79 + StorageDead(_7); // scope 0 at $DIR/match-arm-scopes.rs:16:77: 16:78 + StorageDead(_5); // scope 0 at $DIR/match-arm-scopes.rs:16:77: 16:78 + StorageDead(_8); // scope 0 at $DIR/match-arm-scopes.rs:16:77: 16:78 + StorageDead(_6); // scope 0 at $DIR/match-arm-scopes.rs:16:77: 16:78 goto -> bb23; // scope 0 at $DIR/match-arm-scopes.rs:15:5: 18:6 } @@ -188,7 +188,7 @@ fn complicated_match(_1: bool, _2: (bool, bool, std::string::String)) -> i32 { // mir::Constant // + span: $DIR/match-arm-scopes.rs:17:41: 17:42 // + literal: Const { ty: i32, val: Value(Scalar(0x00000002)) } - drop(_16) -> [return: bb22, unwind: bb10]; // scope 0 at $DIR/match-arm-scopes.rs:17:42: 17:43 + drop(_16) -> [return: bb22, unwind: bb10]; // scope 0 at $DIR/match-arm-scopes.rs:17:41: 17:42 } bb21: { @@ -200,8 +200,8 @@ fn complicated_match(_1: bool, _2: (bool, bool, std::string::String)) -> i32 { } bb22: { - StorageDead(_16); // scope 0 at $DIR/match-arm-scopes.rs:17:42: 17:43 - StorageDead(_15); // scope 0 at $DIR/match-arm-scopes.rs:17:42: 17:43 + StorageDead(_16); // scope 0 at $DIR/match-arm-scopes.rs:17:41: 17:42 + StorageDead(_15); // scope 0 at $DIR/match-arm-scopes.rs:17:41: 17:42 goto -> bb23; // scope 0 at $DIR/match-arm-scopes.rs:15:5: 18:6 } diff --git a/src/test/mir-opt/match-arm-scopes/rustc.complicated_match.SimplifyCfg-initial.after.mir b/src/test/mir-opt/match-arm-scopes/rustc.complicated_match.SimplifyCfg-initial.after.mir index 45f7e91d097c0..dadbc3668cb29 100644 --- a/src/test/mir-opt/match-arm-scopes/rustc.complicated_match.SimplifyCfg-initial.after.mir +++ b/src/test/mir-opt/match-arm-scopes/rustc.complicated_match.SimplifyCfg-initial.after.mir @@ -74,7 +74,7 @@ fn complicated_match(_1: bool, _2: (bool, bool, std::string::String)) -> i32 { // mir::Constant // + span: $DIR/match-arm-scopes.rs:16:77: 16:78 // + literal: Const { ty: i32, val: Value(Scalar(0x00000001)) } - drop(_7) -> [return: bb24, unwind: bb14]; // scope 0 at $DIR/match-arm-scopes.rs:16:78: 16:79 + drop(_7) -> [return: bb24, unwind: bb14]; // scope 0 at $DIR/match-arm-scopes.rs:16:77: 16:78 } bb9: { @@ -110,9 +110,9 @@ fn complicated_match(_1: bool, _2: (bool, bool, std::string::String)) -> i32 { // + span: $DIR/match-arm-scopes.rs:16:59: 16:60 // + literal: Const { ty: i32, val: Value(Scalar(0x00000003)) } StorageDead(_10); // scope 0 at $DIR/match-arm-scopes.rs:16:72: 16:73 - StorageDead(_9); // scope 0 at $DIR/match-arm-scopes.rs:16:78: 16:79 - StorageDead(_8); // scope 0 at $DIR/match-arm-scopes.rs:16:78: 16:79 - StorageDead(_6); // scope 0 at $DIR/match-arm-scopes.rs:16:78: 16:79 + StorageDead(_9); // scope 0 at $DIR/match-arm-scopes.rs:16:77: 16:78 + StorageDead(_8); // scope 0 at $DIR/match-arm-scopes.rs:16:77: 16:78 + StorageDead(_6); // scope 0 at $DIR/match-arm-scopes.rs:16:77: 16:78 goto -> bb15; // scope 0 at $DIR/match-arm-scopes.rs:16:52: 16:60 } @@ -129,7 +129,7 @@ fn complicated_match(_1: bool, _2: (bool, bool, std::string::String)) -> i32 { } bb16: { - StorageDead(_9); // scope 0 at $DIR/match-arm-scopes.rs:16:78: 16:79 + StorageDead(_9); // scope 0 at $DIR/match-arm-scopes.rs:16:77: 16:78 FakeRead(ForMatchGuard, _3); // scope 0 at $DIR/match-arm-scopes.rs:16:72: 16:73 FakeRead(ForMatchGuard, _4); // scope 0 at $DIR/match-arm-scopes.rs:16:72: 16:73 FakeRead(ForGuardBinding, _6); // scope 0 at $DIR/match-arm-scopes.rs:16:72: 16:73 @@ -142,9 +142,9 @@ fn complicated_match(_1: bool, _2: (bool, bool, std::string::String)) -> i32 { } bb17: { - StorageDead(_9); // scope 0 at $DIR/match-arm-scopes.rs:16:78: 16:79 - StorageDead(_8); // scope 0 at $DIR/match-arm-scopes.rs:16:78: 16:79 - StorageDead(_6); // scope 0 at $DIR/match-arm-scopes.rs:16:78: 16:79 + StorageDead(_9); // scope 0 at $DIR/match-arm-scopes.rs:16:77: 16:78 + StorageDead(_8); // scope 0 at $DIR/match-arm-scopes.rs:16:77: 16:78 + StorageDead(_6); // scope 0 at $DIR/match-arm-scopes.rs:16:77: 16:78 falseEdge -> [real: bb3, imaginary: bb4]; // scope 0 at $DIR/match-arm-scopes.rs:16:42: 16:73 } @@ -181,14 +181,14 @@ fn complicated_match(_1: bool, _2: (bool, bool, std::string::String)) -> i32 { // + span: $DIR/match-arm-scopes.rs:16:59: 16:60 // + literal: Const { ty: i32, val: Value(Scalar(0x00000003)) } StorageDead(_13); // scope 0 at $DIR/match-arm-scopes.rs:16:72: 16:73 - StorageDead(_12); // scope 0 at $DIR/match-arm-scopes.rs:16:78: 16:79 - StorageDead(_8); // scope 0 at $DIR/match-arm-scopes.rs:16:78: 16:79 - StorageDead(_6); // scope 0 at $DIR/match-arm-scopes.rs:16:78: 16:79 + StorageDead(_12); // scope 0 at $DIR/match-arm-scopes.rs:16:77: 16:78 + StorageDead(_8); // scope 0 at $DIR/match-arm-scopes.rs:16:77: 16:78 + StorageDead(_6); // scope 0 at $DIR/match-arm-scopes.rs:16:77: 16:78 goto -> bb15; // scope 0 at $DIR/match-arm-scopes.rs:16:52: 16:60 } bb22: { - StorageDead(_12); // scope 0 at $DIR/match-arm-scopes.rs:16:78: 16:79 + StorageDead(_12); // scope 0 at $DIR/match-arm-scopes.rs:16:77: 16:78 FakeRead(ForMatchGuard, _3); // scope 0 at $DIR/match-arm-scopes.rs:16:72: 16:73 FakeRead(ForMatchGuard, _4); // scope 0 at $DIR/match-arm-scopes.rs:16:72: 16:73 FakeRead(ForGuardBinding, _6); // scope 0 at $DIR/match-arm-scopes.rs:16:72: 16:73 @@ -201,17 +201,17 @@ fn complicated_match(_1: bool, _2: (bool, bool, std::string::String)) -> i32 { } bb23: { - StorageDead(_12); // scope 0 at $DIR/match-arm-scopes.rs:16:78: 16:79 - StorageDead(_8); // scope 0 at $DIR/match-arm-scopes.rs:16:78: 16:79 - StorageDead(_6); // scope 0 at $DIR/match-arm-scopes.rs:16:78: 16:79 + StorageDead(_12); // scope 0 at $DIR/match-arm-scopes.rs:16:77: 16:78 + StorageDead(_8); // scope 0 at $DIR/match-arm-scopes.rs:16:77: 16:78 + StorageDead(_6); // scope 0 at $DIR/match-arm-scopes.rs:16:77: 16:78 falseEdge -> [real: bb5, imaginary: bb6]; // scope 0 at $DIR/match-arm-scopes.rs:16:42: 16:73 } bb24: { - StorageDead(_7); // scope 0 at $DIR/match-arm-scopes.rs:16:78: 16:79 - StorageDead(_5); // scope 0 at $DIR/match-arm-scopes.rs:16:78: 16:79 - StorageDead(_8); // scope 0 at $DIR/match-arm-scopes.rs:16:78: 16:79 - StorageDead(_6); // scope 0 at $DIR/match-arm-scopes.rs:16:78: 16:79 + StorageDead(_7); // scope 0 at $DIR/match-arm-scopes.rs:16:77: 16:78 + StorageDead(_5); // scope 0 at $DIR/match-arm-scopes.rs:16:77: 16:78 + StorageDead(_8); // scope 0 at $DIR/match-arm-scopes.rs:16:77: 16:78 + StorageDead(_6); // scope 0 at $DIR/match-arm-scopes.rs:16:77: 16:78 goto -> bb28; // scope 0 at $DIR/match-arm-scopes.rs:15:5: 18:6 } @@ -223,7 +223,7 @@ fn complicated_match(_1: bool, _2: (bool, bool, std::string::String)) -> i32 { // mir::Constant // + span: $DIR/match-arm-scopes.rs:17:41: 17:42 // + literal: Const { ty: i32, val: Value(Scalar(0x00000002)) } - drop(_16) -> [return: bb27, unwind: bb14]; // scope 0 at $DIR/match-arm-scopes.rs:17:42: 17:43 + drop(_16) -> [return: bb27, unwind: bb14]; // scope 0 at $DIR/match-arm-scopes.rs:17:41: 17:42 } bb26: { @@ -235,8 +235,8 @@ fn complicated_match(_1: bool, _2: (bool, bool, std::string::String)) -> i32 { } bb27: { - StorageDead(_16); // scope 0 at $DIR/match-arm-scopes.rs:17:42: 17:43 - StorageDead(_15); // scope 0 at $DIR/match-arm-scopes.rs:17:42: 17:43 + StorageDead(_16); // scope 0 at $DIR/match-arm-scopes.rs:17:41: 17:42 + StorageDead(_15); // scope 0 at $DIR/match-arm-scopes.rs:17:41: 17:42 goto -> bb28; // scope 0 at $DIR/match-arm-scopes.rs:15:5: 18:6 } diff --git a/src/test/mir-opt/match_false_edges/rustc.full_tested_match.PromoteTemps.after.mir b/src/test/mir-opt/match_false_edges/rustc.full_tested_match.PromoteTemps.after.mir index d4a2afe295781..5ff4150d2ac1a 100644 --- a/src/test/mir-opt/match_false_edges/rustc.full_tested_match.PromoteTemps.after.mir +++ b/src/test/mir-opt/match_false_edges/rustc.full_tested_match.PromoteTemps.after.mir @@ -97,7 +97,7 @@ fn full_tested_match() -> () { } bb8: { - StorageDead(_7); // scope 0 at $DIR/match_false_edges.rs:16:37: 16:38 + StorageDead(_7); // scope 0 at $DIR/match_false_edges.rs:16:36: 16:37 FakeRead(ForMatchGuard, _4); // scope 0 at $DIR/match_false_edges.rs:16:26: 16:27 FakeRead(ForGuardBinding, _6); // scope 0 at $DIR/match_false_edges.rs:16:26: 16:27 StorageLive(_5); // scope 0 at $DIR/match_false_edges.rs:16:14: 16:15 @@ -112,14 +112,14 @@ fn full_tested_match() -> () { // + span: $DIR/match_false_edges.rs:16:32: 16:33 // + literal: Const { ty: i32, val: Value(Scalar(0x00000001)) } StorageDead(_8); // scope 2 at $DIR/match_false_edges.rs:16:36: 16:37 - StorageDead(_5); // scope 0 at $DIR/match_false_edges.rs:16:37: 16:38 - StorageDead(_6); // scope 0 at $DIR/match_false_edges.rs:16:37: 16:38 + StorageDead(_5); // scope 0 at $DIR/match_false_edges.rs:16:36: 16:37 + StorageDead(_6); // scope 0 at $DIR/match_false_edges.rs:16:36: 16:37 goto -> bb11; // scope 0 at $DIR/match_false_edges.rs:15:13: 19:6 } bb9: { - StorageDead(_7); // scope 0 at $DIR/match_false_edges.rs:16:37: 16:38 - StorageDead(_6); // scope 0 at $DIR/match_false_edges.rs:16:37: 16:38 + StorageDead(_7); // scope 0 at $DIR/match_false_edges.rs:16:36: 16:37 + StorageDead(_6); // scope 0 at $DIR/match_false_edges.rs:16:36: 16:37 goto -> bb4; // scope 0 at $DIR/match_false_edges.rs:16:20: 16:27 } @@ -136,7 +136,7 @@ fn full_tested_match() -> () { // + span: $DIR/match_false_edges.rs:17:21: 17:22 // + literal: Const { ty: i32, val: Value(Scalar(0x00000002)) } StorageDead(_10); // scope 3 at $DIR/match_false_edges.rs:17:25: 17:26 - StorageDead(_9); // scope 0 at $DIR/match_false_edges.rs:17:26: 17:27 + StorageDead(_9); // scope 0 at $DIR/match_false_edges.rs:17:25: 17:26 goto -> bb11; // scope 0 at $DIR/match_false_edges.rs:15:13: 19:6 } diff --git a/src/test/mir-opt/match_false_edges/rustc.full_tested_match2.PromoteTemps.before.mir b/src/test/mir-opt/match_false_edges/rustc.full_tested_match2.PromoteTemps.before.mir index f1744a94fdc13..b79416fe31a41 100644 --- a/src/test/mir-opt/match_false_edges/rustc.full_tested_match2.PromoteTemps.before.mir +++ b/src/test/mir-opt/match_false_edges/rustc.full_tested_match2.PromoteTemps.before.mir @@ -62,7 +62,7 @@ fn full_tested_match2() -> () { // + span: $DIR/match_false_edges.rs:29:21: 29:22 // + literal: Const { ty: i32, val: Value(Scalar(0x00000002)) } StorageDead(_10); // scope 3 at $DIR/match_false_edges.rs:29:25: 29:26 - StorageDead(_9); // scope 0 at $DIR/match_false_edges.rs:29:26: 29:27 + StorageDead(_9); // scope 0 at $DIR/match_false_edges.rs:29:25: 29:26 goto -> bb11; // scope 0 at $DIR/match_false_edges.rs:26:13: 30:6 } @@ -89,7 +89,7 @@ fn full_tested_match2() -> () { } bb8: { - StorageDead(_7); // scope 0 at $DIR/match_false_edges.rs:27:37: 27:38 + StorageDead(_7); // scope 0 at $DIR/match_false_edges.rs:27:36: 27:37 FakeRead(ForMatchGuard, _4); // scope 0 at $DIR/match_false_edges.rs:27:26: 27:27 FakeRead(ForGuardBinding, _6); // scope 0 at $DIR/match_false_edges.rs:27:26: 27:27 StorageLive(_5); // scope 0 at $DIR/match_false_edges.rs:27:14: 27:15 @@ -104,14 +104,14 @@ fn full_tested_match2() -> () { // + span: $DIR/match_false_edges.rs:27:32: 27:33 // + literal: Const { ty: i32, val: Value(Scalar(0x00000001)) } StorageDead(_8); // scope 2 at $DIR/match_false_edges.rs:27:36: 27:37 - StorageDead(_5); // scope 0 at $DIR/match_false_edges.rs:27:37: 27:38 - StorageDead(_6); // scope 0 at $DIR/match_false_edges.rs:27:37: 27:38 + StorageDead(_5); // scope 0 at $DIR/match_false_edges.rs:27:36: 27:37 + StorageDead(_6); // scope 0 at $DIR/match_false_edges.rs:27:36: 27:37 goto -> bb11; // scope 0 at $DIR/match_false_edges.rs:26:13: 30:6 } bb9: { - StorageDead(_7); // scope 0 at $DIR/match_false_edges.rs:27:37: 27:38 - StorageDead(_6); // scope 0 at $DIR/match_false_edges.rs:27:37: 27:38 + StorageDead(_7); // scope 0 at $DIR/match_false_edges.rs:27:36: 27:37 + StorageDead(_6); // scope 0 at $DIR/match_false_edges.rs:27:36: 27:37 falseEdge -> [real: bb4, imaginary: bb2]; // scope 0 at $DIR/match_false_edges.rs:27:20: 27:27 } diff --git a/src/test/mir-opt/match_false_edges/rustc.main.PromoteTemps.before.mir b/src/test/mir-opt/match_false_edges/rustc.main.PromoteTemps.before.mir index 4ab4c4d341e2f..5b449da93d493 100644 --- a/src/test/mir-opt/match_false_edges/rustc.main.PromoteTemps.before.mir +++ b/src/test/mir-opt/match_false_edges/rustc.main.PromoteTemps.before.mir @@ -70,7 +70,7 @@ fn main() -> () { // mir::Constant // + span: $DIR/match_false_edges.rs:39:15: 39:16 // + literal: Const { ty: i32, val: Value(Scalar(0x00000004)) } - StorageDead(_14); // scope 0 at $DIR/match_false_edges.rs:39:16: 39:17 + StorageDead(_14); // scope 0 at $DIR/match_false_edges.rs:39:15: 39:16 goto -> bb15; // scope 0 at $DIR/match_false_edges.rs:35:13: 40:6 } @@ -97,7 +97,7 @@ fn main() -> () { } bb8: { - StorageDead(_8); // scope 0 at $DIR/match_false_edges.rs:36:33: 36:34 + StorageDead(_8); // scope 0 at $DIR/match_false_edges.rs:36:32: 36:33 FakeRead(ForMatchGuard, _5); // scope 0 at $DIR/match_false_edges.rs:36:27: 36:28 FakeRead(ForGuardBinding, _7); // scope 0 at $DIR/match_false_edges.rs:36:27: 36:28 StorageLive(_6); // scope 0 at $DIR/match_false_edges.rs:36:14: 36:16 @@ -109,14 +109,14 @@ fn main() -> () { // mir::Constant // + span: $DIR/match_false_edges.rs:36:32: 36:33 // + literal: Const { ty: i32, val: Value(Scalar(0x00000001)) } - StorageDead(_6); // scope 0 at $DIR/match_false_edges.rs:36:33: 36:34 - StorageDead(_7); // scope 0 at $DIR/match_false_edges.rs:36:33: 36:34 + StorageDead(_6); // scope 0 at $DIR/match_false_edges.rs:36:32: 36:33 + StorageDead(_7); // scope 0 at $DIR/match_false_edges.rs:36:32: 36:33 goto -> bb15; // scope 0 at $DIR/match_false_edges.rs:35:13: 40:6 } bb9: { - StorageDead(_8); // scope 0 at $DIR/match_false_edges.rs:36:33: 36:34 - StorageDead(_7); // scope 0 at $DIR/match_false_edges.rs:36:33: 36:34 + StorageDead(_8); // scope 0 at $DIR/match_false_edges.rs:36:32: 36:33 + StorageDead(_7); // scope 0 at $DIR/match_false_edges.rs:36:32: 36:33 falseEdge -> [real: bb2, imaginary: bb2]; // scope 0 at $DIR/match_false_edges.rs:36:21: 36:28 } @@ -130,7 +130,7 @@ fn main() -> () { // mir::Constant // + span: $DIR/match_false_edges.rs:37:15: 37:16 // + literal: Const { ty: i32, val: Value(Scalar(0x00000002)) } - StorageDead(_9); // scope 0 at $DIR/match_false_edges.rs:37:16: 37:17 + StorageDead(_9); // scope 0 at $DIR/match_false_edges.rs:37:15: 37:16 goto -> bb15; // scope 0 at $DIR/match_false_edges.rs:35:13: 40:6 } @@ -156,7 +156,7 @@ fn main() -> () { } bb13: { - StorageDead(_12); // scope 0 at $DIR/match_false_edges.rs:38:34: 38:35 + StorageDead(_12); // scope 0 at $DIR/match_false_edges.rs:38:33: 38:34 FakeRead(ForMatchGuard, _5); // scope 0 at $DIR/match_false_edges.rs:38:28: 38:29 FakeRead(ForGuardBinding, _11); // scope 0 at $DIR/match_false_edges.rs:38:28: 38:29 StorageLive(_10); // scope 0 at $DIR/match_false_edges.rs:38:14: 38:15 @@ -168,14 +168,14 @@ fn main() -> () { // mir::Constant // + span: $DIR/match_false_edges.rs:38:33: 38:34 // + literal: Const { ty: i32, val: Value(Scalar(0x00000003)) } - StorageDead(_10); // scope 0 at $DIR/match_false_edges.rs:38:34: 38:35 - StorageDead(_11); // scope 0 at $DIR/match_false_edges.rs:38:34: 38:35 + StorageDead(_10); // scope 0 at $DIR/match_false_edges.rs:38:33: 38:34 + StorageDead(_11); // scope 0 at $DIR/match_false_edges.rs:38:33: 38:34 goto -> bb15; // scope 0 at $DIR/match_false_edges.rs:35:13: 40:6 } bb14: { - StorageDead(_12); // scope 0 at $DIR/match_false_edges.rs:38:34: 38:35 - StorageDead(_11); // scope 0 at $DIR/match_false_edges.rs:38:34: 38:35 + StorageDead(_12); // scope 0 at $DIR/match_false_edges.rs:38:33: 38:34 + StorageDead(_11); // scope 0 at $DIR/match_false_edges.rs:38:33: 38:34 falseEdge -> [real: bb4, imaginary: bb4]; // scope 0 at $DIR/match_false_edges.rs:38:20: 38:29 } diff --git a/src/test/mir-opt/match_test/rustc.main.SimplifyCfg-initial.after.mir b/src/test/mir-opt/match_test/rustc.main.SimplifyCfg-initial.after.mir index ef6c88d8005b3..16895942cb81b 100644 --- a/src/test/mir-opt/match_test/rustc.main.SimplifyCfg-initial.after.mir +++ b/src/test/mir-opt/match_test/rustc.main.SimplifyCfg-initial.after.mir @@ -117,7 +117,7 @@ fn main() -> () { } bb10: { - StorageDead(_9); // scope 2 at $DIR/match_test.rs:13:24: 13:25 + StorageDead(_9); // scope 2 at $DIR/match_test.rs:13:23: 13:24 FakeRead(ForMatchGuard, _8); // scope 2 at $DIR/match_test.rs:13:18: 13:19 _3 = const 0_i32; // scope 2 at $DIR/match_test.rs:13:23: 13:24 // ty::Const @@ -130,7 +130,7 @@ fn main() -> () { } bb11: { - StorageDead(_9); // scope 2 at $DIR/match_test.rs:13:24: 13:25 + StorageDead(_9); // scope 2 at $DIR/match_test.rs:13:23: 13:24 falseEdge -> [real: bb3, imaginary: bb6]; // scope 2 at $DIR/match_test.rs:13:18: 13:19 } diff --git a/src/test/mir-opt/no-drop-for-inactive-variant/rustc.unwrap.SimplifyCfg-elaborate-drops.after.mir b/src/test/mir-opt/no-drop-for-inactive-variant/rustc.unwrap.SimplifyCfg-elaborate-drops.after.mir index 2e8cfaea937d7..f3f2b68e53d5c 100644 --- a/src/test/mir-opt/no-drop-for-inactive-variant/rustc.unwrap.SimplifyCfg-elaborate-drops.after.mir +++ b/src/test/mir-opt/no-drop-for-inactive-variant/rustc.unwrap.SimplifyCfg-elaborate-drops.after.mir @@ -43,7 +43,7 @@ fn unwrap(_1: std::option::Option) -> T { StorageLive(_3); // scope 0 at $DIR/no-drop-for-inactive-variant.rs:9:14: 9:15 _3 = move ((_1 as Some).0: T); // scope 0 at $DIR/no-drop-for-inactive-variant.rs:9:14: 9:15 _0 = move _3; // scope 1 at $DIR/no-drop-for-inactive-variant.rs:9:20: 9:21 - StorageDead(_3); // scope 0 at $DIR/no-drop-for-inactive-variant.rs:9:21: 9:22 + StorageDead(_3); // scope 0 at $DIR/no-drop-for-inactive-variant.rs:9:20: 9:21 _6 = discriminant(_1); // scope 0 at $DIR/no-drop-for-inactive-variant.rs:12:1: 12:2 return; // scope 0 at $DIR/no-drop-for-inactive-variant.rs:12:2: 12:2 } diff --git a/src/test/mir-opt/remove_fake_borrows/rustc.match_guard.CleanupNonCodegenStatements.diff b/src/test/mir-opt/remove_fake_borrows/rustc.match_guard.CleanupNonCodegenStatements.diff index 7fc209778703e..0822d8cc03c60 100644 --- a/src/test/mir-opt/remove_fake_borrows/rustc.match_guard.CleanupNonCodegenStatements.diff +++ b/src/test/mir-opt/remove_fake_borrows/rustc.match_guard.CleanupNonCodegenStatements.diff @@ -53,7 +53,7 @@ } bb5: { - StorageDead(_8); // scope 0 at $DIR/remove_fake_borrows.rs:8:26: 8:27 + StorageDead(_8); // scope 0 at $DIR/remove_fake_borrows.rs:8:25: 8:26 - FakeRead(ForMatchGuard, _4); // scope 0 at $DIR/remove_fake_borrows.rs:8:20: 8:21 - FakeRead(ForMatchGuard, _5); // scope 0 at $DIR/remove_fake_borrows.rs:8:20: 8:21 - FakeRead(ForMatchGuard, _6); // scope 0 at $DIR/remove_fake_borrows.rs:8:20: 8:21 @@ -73,7 +73,7 @@ } bb6: { - StorageDead(_8); // scope 0 at $DIR/remove_fake_borrows.rs:8:26: 8:27 + StorageDead(_8); // scope 0 at $DIR/remove_fake_borrows.rs:8:25: 8:26 goto -> bb1; // scope 0 at $DIR/remove_fake_borrows.rs:8:20: 8:21 } diff --git a/src/test/mir-opt/simplify-arm-identity/32bit/rustc.main.SimplifyArmIdentity.diff b/src/test/mir-opt/simplify-arm-identity/32bit/rustc.main.SimplifyArmIdentity.diff index 33a3403cada92..0de80f72a1e70 100644 --- a/src/test/mir-opt/simplify-arm-identity/32bit/rustc.main.SimplifyArmIdentity.diff +++ b/src/test/mir-opt/simplify-arm-identity/32bit/rustc.main.SimplifyArmIdentity.diff @@ -61,7 +61,7 @@ ((_2 as Foo).0: u8) = move _5; // scope 3 at $DIR/simplify-arm-identity.rs:20:24: 20:35 discriminant(_2) = 0; // scope 3 at $DIR/simplify-arm-identity.rs:20:24: 20:35 StorageDead(_5); // scope 3 at $DIR/simplify-arm-identity.rs:20:34: 20:35 - StorageDead(_4); // scope 1 at $DIR/simplify-arm-identity.rs:20:35: 20:36 + StorageDead(_4); // scope 1 at $DIR/simplify-arm-identity.rs:20:34: 20:35 goto -> bb4; // scope 1 at $DIR/simplify-arm-identity.rs:19:18: 22:6 } diff --git a/src/test/mir-opt/simplify-arm-identity/64bit/rustc.main.SimplifyArmIdentity.diff b/src/test/mir-opt/simplify-arm-identity/64bit/rustc.main.SimplifyArmIdentity.diff index 7e4fe1c2dcc4c..4fa0aff8fa0ef 100644 --- a/src/test/mir-opt/simplify-arm-identity/64bit/rustc.main.SimplifyArmIdentity.diff +++ b/src/test/mir-opt/simplify-arm-identity/64bit/rustc.main.SimplifyArmIdentity.diff @@ -61,7 +61,7 @@ ((_2 as Foo).0: u8) = move _5; // scope 3 at $DIR/simplify-arm-identity.rs:20:24: 20:35 discriminant(_2) = 0; // scope 3 at $DIR/simplify-arm-identity.rs:20:24: 20:35 StorageDead(_5); // scope 3 at $DIR/simplify-arm-identity.rs:20:34: 20:35 - StorageDead(_4); // scope 1 at $DIR/simplify-arm-identity.rs:20:35: 20:36 + StorageDead(_4); // scope 1 at $DIR/simplify-arm-identity.rs:20:34: 20:35 goto -> bb4; // scope 1 at $DIR/simplify-arm-identity.rs:19:18: 22:6 } diff --git a/src/test/mir-opt/simplify-arm/rustc.id.SimplifyArmIdentity.diff b/src/test/mir-opt/simplify-arm/rustc.id.SimplifyArmIdentity.diff index daae94e87f044..0cddcb061cfc8 100644 --- a/src/test/mir-opt/simplify-arm/rustc.id.SimplifyArmIdentity.diff +++ b/src/test/mir-opt/simplify-arm/rustc.id.SimplifyArmIdentity.diff @@ -33,7 +33,7 @@ ((_0 as Some).0: u8) = move _4; // scope 1 at $DIR/simplify-arm.rs:11:20: 11:27 discriminant(_0) = 1; // scope 1 at $DIR/simplify-arm.rs:11:20: 11:27 StorageDead(_4); // scope 1 at $DIR/simplify-arm.rs:11:26: 11:27 - StorageDead(_3); // scope 0 at $DIR/simplify-arm.rs:11:27: 11:28 + StorageDead(_3); // scope 0 at $DIR/simplify-arm.rs:11:26: 11:27 goto -> bb4; // scope 0 at $DIR/simplify-arm.rs:10:5: 13:6 } diff --git a/src/test/mir-opt/simplify-arm/rustc.id.SimplifyBranchSame.diff b/src/test/mir-opt/simplify-arm/rustc.id.SimplifyBranchSame.diff index 15bd5e7c9f0b0..cd5962c682a5a 100644 --- a/src/test/mir-opt/simplify-arm/rustc.id.SimplifyBranchSame.diff +++ b/src/test/mir-opt/simplify-arm/rustc.id.SimplifyBranchSame.diff @@ -33,7 +33,7 @@ ((_0 as Some).0: u8) = move _4; // scope 1 at $DIR/simplify-arm.rs:11:20: 11:27 discriminant(_0) = 1; // scope 1 at $DIR/simplify-arm.rs:11:20: 11:27 StorageDead(_4); // scope 1 at $DIR/simplify-arm.rs:11:26: 11:27 - StorageDead(_3); // scope 0 at $DIR/simplify-arm.rs:11:27: 11:28 + StorageDead(_3); // scope 0 at $DIR/simplify-arm.rs:11:26: 11:27 goto -> bb4; // scope 0 at $DIR/simplify-arm.rs:10:5: 13:6 } diff --git a/src/test/mir-opt/simplify-arm/rustc.id_result.SimplifyArmIdentity.diff b/src/test/mir-opt/simplify-arm/rustc.id_result.SimplifyArmIdentity.diff index 37273d1d6517b..642ccc1ab14b7 100644 --- a/src/test/mir-opt/simplify-arm/rustc.id_result.SimplifyArmIdentity.diff +++ b/src/test/mir-opt/simplify-arm/rustc.id_result.SimplifyArmIdentity.diff @@ -29,7 +29,7 @@ ((_0 as Err).0: i32) = move _6; // scope 2 at $DIR/simplify-arm.rs:19:19: 19:25 discriminant(_0) = 1; // scope 2 at $DIR/simplify-arm.rs:19:19: 19:25 StorageDead(_6); // scope 2 at $DIR/simplify-arm.rs:19:24: 19:25 - StorageDead(_5); // scope 0 at $DIR/simplify-arm.rs:19:25: 19:26 + StorageDead(_5); // scope 0 at $DIR/simplify-arm.rs:19:24: 19:25 goto -> bb4; // scope 0 at $DIR/simplify-arm.rs:17:5: 20:6 } @@ -45,7 +45,7 @@ ((_0 as Ok).0: u8) = move _4; // scope 1 at $DIR/simplify-arm.rs:18:18: 18:23 discriminant(_0) = 0; // scope 1 at $DIR/simplify-arm.rs:18:18: 18:23 StorageDead(_4); // scope 1 at $DIR/simplify-arm.rs:18:22: 18:23 - StorageDead(_3); // scope 0 at $DIR/simplify-arm.rs:18:23: 18:24 + StorageDead(_3); // scope 0 at $DIR/simplify-arm.rs:18:22: 18:23 goto -> bb4; // scope 0 at $DIR/simplify-arm.rs:17:5: 20:6 } diff --git a/src/test/mir-opt/simplify-arm/rustc.id_result.SimplifyBranchSame.diff b/src/test/mir-opt/simplify-arm/rustc.id_result.SimplifyBranchSame.diff index f138d637435f8..95ce09a39ed50 100644 --- a/src/test/mir-opt/simplify-arm/rustc.id_result.SimplifyBranchSame.diff +++ b/src/test/mir-opt/simplify-arm/rustc.id_result.SimplifyBranchSame.diff @@ -29,7 +29,7 @@ ((_0 as Err).0: i32) = move _6; // scope 2 at $DIR/simplify-arm.rs:19:19: 19:25 discriminant(_0) = 1; // scope 2 at $DIR/simplify-arm.rs:19:19: 19:25 StorageDead(_6); // scope 2 at $DIR/simplify-arm.rs:19:24: 19:25 - StorageDead(_5); // scope 0 at $DIR/simplify-arm.rs:19:25: 19:26 + StorageDead(_5); // scope 0 at $DIR/simplify-arm.rs:19:24: 19:25 goto -> bb4; // scope 0 at $DIR/simplify-arm.rs:17:5: 20:6 } @@ -45,7 +45,7 @@ ((_0 as Ok).0: u8) = move _4; // scope 1 at $DIR/simplify-arm.rs:18:18: 18:23 discriminant(_0) = 0; // scope 1 at $DIR/simplify-arm.rs:18:18: 18:23 StorageDead(_4); // scope 1 at $DIR/simplify-arm.rs:18:22: 18:23 - StorageDead(_3); // scope 0 at $DIR/simplify-arm.rs:18:23: 18:24 + StorageDead(_3); // scope 0 at $DIR/simplify-arm.rs:18:22: 18:23 goto -> bb4; // scope 0 at $DIR/simplify-arm.rs:17:5: 20:6 } diff --git a/src/test/mir-opt/simplify_try_if_let/rustc.{{impl}}-append.SimplifyArmIdentity.diff b/src/test/mir-opt/simplify_try_if_let/rustc.{{impl}}-append.SimplifyArmIdentity.diff index aa416049f6613..4471f4d206ca2 100644 --- a/src/test/mir-opt/simplify_try_if_let/rustc.{{impl}}-append.SimplifyArmIdentity.diff +++ b/src/test/mir-opt/simplify_try_if_let/rustc.{{impl}}-append.SimplifyArmIdentity.diff @@ -115,7 +115,7 @@ bb8: { StorageDead(_5); // scope 1 at $DIR/simplify_try_if_let.rs:31:13: 31:14 - StorageDead(_4); // scope 0 at $DIR/simplify_try_if_let.rs:32:9: 32:10 + StorageDead(_4); // scope 0 at $DIR/simplify_try_if_let.rs:31:13: 31:14 goto -> bb9; // scope 0 at $DIR/simplify_try_if_let.rs:21:9: 32:10 } diff --git a/src/test/ui/match/issue-74050-end-span.rs b/src/test/ui/match/issue-74050-end-span.rs new file mode 100644 index 0000000000000..cc81214e2701b --- /dev/null +++ b/src/test/ui/match/issue-74050-end-span.rs @@ -0,0 +1,13 @@ +fn main() { + let mut args = std::env::args_os(); + let _arg = match args.next() { + Some(arg) => { + match arg.to_str() { + //~^ ERROR `arg` does not live long enough + Some(s) => s, + None => return, + } + } + None => return, + }; +} diff --git a/src/test/ui/match/issue-74050-end-span.stderr b/src/test/ui/match/issue-74050-end-span.stderr new file mode 100644 index 0000000000000..d636a11a91cec --- /dev/null +++ b/src/test/ui/match/issue-74050-end-span.stderr @@ -0,0 +1,15 @@ +error[E0597]: `arg` does not live long enough + --> $DIR/issue-74050-end-span.rs:5:19 + | +LL | let _arg = match args.next() { + | ---- borrow later stored here +LL | Some(arg) => { +LL | match arg.to_str() { + | ^^^ borrowed value does not live long enough +... +LL | } + | - `arg` dropped here while still borrowed + +error: aborting due to previous error + +For more information about this error, try `rustc --explain E0597`. From 51b646e48791168c2086177a8a92764b63e3a692 Mon Sep 17 00:00:00 2001 From: Tom Eccles Date: Wed, 8 Jul 2020 19:23:51 +0100 Subject: [PATCH 25/35] ci: disabled: riscv: minimise docker overlays Suggested by @bjorn3 Every RUN command creates a new overlay on top of the image as of before the RUN command. Using fewer RUN commands prevents intermediate overlays (which in this case would have contained the entire Linux source tree). --- .../docker/host-x86_64/disabled/riscv64gc-linux/Dockerfile | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/ci/docker/host-x86_64/disabled/riscv64gc-linux/Dockerfile b/src/ci/docker/host-x86_64/disabled/riscv64gc-linux/Dockerfile index 40c02ba6510aa..a938899636a45 100644 --- a/src/ci/docker/host-x86_64/disabled/riscv64gc-linux/Dockerfile +++ b/src/ci/docker/host-x86_64/disabled/riscv64gc-linux/Dockerfile @@ -40,9 +40,9 @@ RUN curl https://cdn.kernel.org/pub/linux/kernel/v5.x/linux-5.6.16.tar.xz | tar cp linux.config linux-5.6.16/.config && \ cd /build/linux-5.6.16 && \ make olddefconfig && \ - make -j$(nproc) vmlinux -RUN cp linux-5.6.16/vmlinux /tmp -RUN rm -rf linux-5.6.16 + make -j$(nproc) vmlinux && \ + cp vmlinux /tmp && \ + rm -rf linux-5.6.16 # Compile an instance of busybox as this provides a lightweight system and init # binary which we will boot into. Only trick here is configuring busybox to From d9fec595e83423d7c35f0457a5c6a363fdaea02d Mon Sep 17 00:00:00 2001 From: Tom Eccles Date: Wed, 8 Jul 2020 21:57:57 +0100 Subject: [PATCH 26/35] ci: fix context for disabled docker images When the dockerfiles were moved into the host-x86_64 directory, paths for COPY commands were updated with the new host-x86_64/ prefix. This suggested that the intended context was src/ci/docker. However, the context for disabled docker images was src/ci/docker/host-x86_64. This broke the new paths and prevented src/ci/docker/scripts from being included in the context at all. This commit corrects this context allowing docker to find the files it needs for COPY commands. --- src/ci/docker/run.sh | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/ci/docker/run.sh b/src/ci/docker/run.sh index 9bc61b56efbb2..c2ff62e74816d 100755 --- a/src/ci/docker/run.sh +++ b/src/ci/docker/run.sh @@ -119,11 +119,11 @@ elif [ -f "$docker_dir/disabled/$image/Dockerfile" ]; then exit 1 fi # Transform changes the context of disabled Dockerfiles to match the enabled ones - tar --transform 's#^./disabled/#./#' -C $docker_dir -c . | docker \ + tar --transform 's#disabled/#./#' -C $script_dir -c . | docker \ build \ --rm \ -t rust-ci \ - -f "$image/Dockerfile" \ + -f "host-$(uname -m)/$image/Dockerfile" \ - else echo Invalid image: $image From 1f982305e4c2f3dc62de90d3039f7c43e5247c11 Mon Sep 17 00:00:00 2001 From: Bastian Kauschke Date: Wed, 8 Jul 2020 23:40:06 +0200 Subject: [PATCH 27/35] ToPredicate by value --- src/librustc_middle/ty/mod.rs | 26 +++++++++++++------------- 1 file changed, 13 insertions(+), 13 deletions(-) diff --git a/src/librustc_middle/ty/mod.rs b/src/librustc_middle/ty/mod.rs index ffb41b094dcd5..5ed39948da12b 100644 --- a/src/librustc_middle/ty/mod.rs +++ b/src/librustc_middle/ty/mod.rs @@ -1337,18 +1337,18 @@ impl<'tcx> ToPolyTraitRef<'tcx> for PolyTraitPredicate<'tcx> { } pub trait ToPredicate<'tcx> { - fn to_predicate(&self, tcx: TyCtxt<'tcx>) -> Predicate<'tcx>; + fn to_predicate(self, tcx: TyCtxt<'tcx>) -> Predicate<'tcx>; } impl ToPredicate<'tcx> for PredicateKind<'tcx> { #[inline(always)] - fn to_predicate(&self, tcx: TyCtxt<'tcx>) -> Predicate<'tcx> { - tcx.mk_predicate(*self) + fn to_predicate(self, tcx: TyCtxt<'tcx>) -> Predicate<'tcx> { + tcx.mk_predicate(self) } } impl<'tcx> ToPredicate<'tcx> for ConstnessAnd> { - fn to_predicate(&self, tcx: TyCtxt<'tcx>) -> Predicate<'tcx> { + fn to_predicate(self, tcx: TyCtxt<'tcx>) -> Predicate<'tcx> { ty::PredicateKind::Trait( ty::Binder::dummy(ty::TraitPredicate { trait_ref: self.value }), self.constness, @@ -1358,7 +1358,7 @@ impl<'tcx> ToPredicate<'tcx> for ConstnessAnd> { } impl<'tcx> ToPredicate<'tcx> for ConstnessAnd<&TraitRef<'tcx>> { - fn to_predicate(&self, tcx: TyCtxt<'tcx>) -> Predicate<'tcx> { + fn to_predicate(self, tcx: TyCtxt<'tcx>) -> Predicate<'tcx> { ty::PredicateKind::Trait( ty::Binder::dummy(ty::TraitPredicate { trait_ref: *self.value }), self.constness, @@ -1368,34 +1368,34 @@ impl<'tcx> ToPredicate<'tcx> for ConstnessAnd<&TraitRef<'tcx>> { } impl<'tcx> ToPredicate<'tcx> for ConstnessAnd> { - fn to_predicate(&self, tcx: TyCtxt<'tcx>) -> Predicate<'tcx> { + fn to_predicate(self, tcx: TyCtxt<'tcx>) -> Predicate<'tcx> { ty::PredicateKind::Trait(self.value.to_poly_trait_predicate(), self.constness) .to_predicate(tcx) } } impl<'tcx> ToPredicate<'tcx> for ConstnessAnd<&PolyTraitRef<'tcx>> { - fn to_predicate(&self, tcx: TyCtxt<'tcx>) -> Predicate<'tcx> { + fn to_predicate(self, tcx: TyCtxt<'tcx>) -> Predicate<'tcx> { ty::PredicateKind::Trait(self.value.to_poly_trait_predicate(), self.constness) .to_predicate(tcx) } } impl<'tcx> ToPredicate<'tcx> for PolyRegionOutlivesPredicate<'tcx> { - fn to_predicate(&self, tcx: TyCtxt<'tcx>) -> Predicate<'tcx> { - PredicateKind::RegionOutlives(*self).to_predicate(tcx) + fn to_predicate(self, tcx: TyCtxt<'tcx>) -> Predicate<'tcx> { + PredicateKind::RegionOutlives(self).to_predicate(tcx) } } impl<'tcx> ToPredicate<'tcx> for PolyTypeOutlivesPredicate<'tcx> { - fn to_predicate(&self, tcx: TyCtxt<'tcx>) -> Predicate<'tcx> { - PredicateKind::TypeOutlives(*self).to_predicate(tcx) + fn to_predicate(self, tcx: TyCtxt<'tcx>) -> Predicate<'tcx> { + PredicateKind::TypeOutlives(self).to_predicate(tcx) } } impl<'tcx> ToPredicate<'tcx> for PolyProjectionPredicate<'tcx> { - fn to_predicate(&self, tcx: TyCtxt<'tcx>) -> Predicate<'tcx> { - PredicateKind::Projection(*self).to_predicate(tcx) + fn to_predicate(self, tcx: TyCtxt<'tcx>) -> Predicate<'tcx> { + PredicateKind::Projection(self).to_predicate(tcx) } } From 0a7d2970e5947e7a2940a32e6975817a389b0708 Mon Sep 17 00:00:00 2001 From: Nicholas Nethercote Date: Tue, 7 Jul 2020 14:13:03 +1000 Subject: [PATCH 28/35] Eliminate `rust_input`. It has a single call site and having it as a separate (higher-order!) function makes the code harder to read. --- src/librustdoc/lib.rs | 54 ++++++++++++++++++------------------------- 1 file changed, 23 insertions(+), 31 deletions(-) diff --git a/src/librustdoc/lib.rs b/src/librustdoc/lib.rs index 8e2dd77cc1155..b02880ab4d3de 100644 --- a/src/librustdoc/lib.rs +++ b/src/librustdoc/lib.rs @@ -471,7 +471,29 @@ fn main_options(options: config::Options) -> i32 { // but we can't crates the Handler ahead of time because it's not Send let diag_opts = (options.error_format, options.edition, options.debugging_options.clone()); let show_coverage = options.show_coverage; - rust_input(options, move |out| { + + // First, parse the crate and extract all relevant information. + info!("starting to run rustc"); + + // Interpret the input file as a rust source file, passing it through the + // compiler all the way through the analysis passes. The rustdoc output is + // then generated from the cleaned AST of the crate. This runs all the + // plug/cleaning passes. + let result = rustc_driver::catch_fatal_errors(move || { + let crate_name = options.crate_name.clone(); + let crate_version = options.crate_version.clone(); + let (mut krate, renderinfo, renderopts) = core::run_core(options); + + info!("finished with rustc"); + + if let Some(name) = crate_name { + krate.name = name + } + + krate.version = crate_version; + + let out = Output { krate, renderinfo, renderopts }; + if show_coverage { // if we ran coverage, bail early, we don't need to also generate docs at this point // (also we didn't load in any of the useful passes) @@ -491,36 +513,6 @@ fn main_options(options: config::Options) -> i32 { rustc_driver::EXIT_FAILURE } } - }) -} - -/// Interprets the input file as a rust source file, passing it through the -/// compiler all the way through the analysis passes. The rustdoc output is then -/// generated from the cleaned AST of the crate. -/// -/// This form of input will run all of the plug/cleaning passes -fn rust_input(options: config::Options, f: F) -> R -where - R: 'static + Send, - F: 'static + Send + FnOnce(Output) -> R, -{ - // First, parse the crate and extract all relevant information. - info!("starting to run rustc"); - - let result = rustc_driver::catch_fatal_errors(move || { - let crate_name = options.crate_name.clone(); - let crate_version = options.crate_version.clone(); - let (mut krate, renderinfo, renderopts) = core::run_core(options); - - info!("finished with rustc"); - - if let Some(name) = crate_name { - krate.name = name - } - - krate.version = crate_version; - - f(Output { krate, renderinfo, renderopts }) }); match result { From 1e8ec2db1d3d695958a8040fbb3491a4378ef7ae Mon Sep 17 00:00:00 2001 From: Nicholas Nethercote Date: Tue, 7 Jul 2020 13:10:19 +1000 Subject: [PATCH 29/35] Add an explanatory comment to `scoped_thread`. --- src/librustc_interface/util.rs | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/librustc_interface/util.rs b/src/librustc_interface/util.rs index fe091e920627c..438b72b0b6176 100644 --- a/src/librustc_interface/util.rs +++ b/src/librustc_interface/util.rs @@ -102,6 +102,8 @@ impl Write for Sink { } } +/// Like a `thread::Builder::spawn` followed by a `join()`, but avoids the need +/// for `'static` bounds. #[cfg(not(parallel_compiler))] pub fn scoped_thread R + Send, R: Send>(cfg: thread::Builder, f: F) -> R { struct Ptr(*mut ()); From 4ad5de22d182578e846a6ccc69940e76a820381c Mon Sep 17 00:00:00 2001 From: Nicholas Nethercote Date: Tue, 7 Jul 2020 13:15:02 +1000 Subject: [PATCH 30/35] Tweak `spawn_thread_pool`. This makes the two versions (parallel and non-parallel) more similar to each other. --- src/librustc_interface/util.rs | 23 ++++++++++++----------- 1 file changed, 12 insertions(+), 11 deletions(-) diff --git a/src/librustc_interface/util.rs b/src/librustc_interface/util.rs index 438b72b0b6176..dc82219b33286 100644 --- a/src/librustc_interface/util.rs +++ b/src/librustc_interface/util.rs @@ -142,7 +142,7 @@ pub fn spawn_thread_pool R + Send, R: Send>( crate::callbacks::setup_callbacks(); - scoped_thread(cfg, || { + let main_handler = move || { rustc_ast::with_session_globals(edition, || { ty::tls::GCX_PTR.set(&Lock::new(0), || { if let Some(stderr) = stderr { @@ -151,7 +151,9 @@ pub fn spawn_thread_pool R + Send, R: Send>( f() }) }) - }) + }; + + scoped_thread(cfg, main_handler) } #[cfg(parallel_compiler)] @@ -161,12 +163,9 @@ pub fn spawn_thread_pool R + Send, R: Send>( stderr: &Option>>>, f: F, ) -> R { - use rayon::{ThreadBuilder, ThreadPool, ThreadPoolBuilder}; - - let gcx_ptr = &Lock::new(0); crate::callbacks::setup_callbacks(); - let mut config = ThreadPoolBuilder::new() + let mut config = rayon::ThreadPoolBuilder::new() .thread_name(|_| "rustc".to_string()) .acquire_thread_handler(jobserver::acquire_thread) .release_thread_handler(jobserver::release_thread) @@ -177,7 +176,7 @@ pub fn spawn_thread_pool R + Send, R: Send>( config = config.stack_size(size); } - let with_pool = move |pool: &ThreadPool| pool.install(move || f()); + let with_pool = move |pool: &rayon::ThreadPool| pool.install(move || f()); rustc_ast::with_session_globals(edition, || { rustc_ast::SESSION_GLOBALS.with(|ast_session_globals| { @@ -190,10 +189,12 @@ pub fn spawn_thread_pool R + Send, R: Send>( let main_handler = move |thread: ThreadBuilder| { rustc_ast::SESSION_GLOBALS.set(ast_session_globals, || { rustc_span::SESSION_GLOBALS.set(span_session_globals, || { - if let Some(stderr) = stderr { - io::set_panic(Some(box Sink(stderr.clone()))); - } - ty::tls::GCX_PTR.set(gcx_ptr, || thread.run()) + ty::tls::GCX_PTR.set(&Lock::new(0), || { + if let Some(stderr) = stderr { + io::set_panic(Some(box Sink(stderr.clone()))); + } + thread.run() + }) }) }) }; From bf7078615b868f7359bff58933fd5236fabe7280 Mon Sep 17 00:00:00 2001 From: Nicholas Nethercote Date: Tue, 7 Jul 2020 13:41:08 +1000 Subject: [PATCH 31/35] Change some function names. A couple of these are quite long, but they do a much better job of explaining what they do, which was non-obvious before. --- src/librustc_interface/interface.rs | 16 ++++++++-------- src/librustc_interface/util.rs | 6 +++--- src/librustdoc/core.rs | 2 +- src/librustdoc/lib.rs | 5 ++++- 4 files changed, 16 insertions(+), 13 deletions(-) diff --git a/src/librustc_interface/interface.rs b/src/librustc_interface/interface.rs index f89be02099e8c..e50622a005379 100644 --- a/src/librustc_interface/interface.rs +++ b/src/librustc_interface/interface.rs @@ -159,10 +159,7 @@ pub struct Config { pub registry: Registry, } -pub fn run_compiler_in_existing_thread_pool( - config: Config, - f: impl FnOnce(&Compiler) -> R, -) -> R { +pub fn create_compiler_and_run(config: Config, f: impl FnOnce(&Compiler) -> R) -> R { let registry = &config.registry; let (sess, codegen_backend) = util::create_session( config.opts, @@ -204,17 +201,20 @@ pub fn run_compiler_in_existing_thread_pool( pub fn run_compiler(mut config: Config, f: impl FnOnce(&Compiler) -> R + Send) -> R { log::trace!("run_compiler"); let stderr = config.stderr.take(); - util::spawn_thread_pool( + util::setup_callbacks_and_run_in_thread_pool_with_globals( config.opts.edition, config.opts.debugging_opts.threads, &stderr, - || run_compiler_in_existing_thread_pool(config, f), + || create_compiler_and_run(config, f), ) } -pub fn default_thread_pool(edition: edition::Edition, f: impl FnOnce() -> R + Send) -> R { +pub fn setup_callbacks_and_run_in_default_thread_pool_with_globals( + edition: edition::Edition, + f: impl FnOnce() -> R + Send, +) -> R { // the 1 here is duplicating code in config.opts.debugging_opts.threads // which also defaults to 1; it ultimately doesn't matter as the default // isn't threaded, and just ignores this parameter - util::spawn_thread_pool(edition, 1, &None, f) + util::setup_callbacks_and_run_in_thread_pool_with_globals(edition, 1, &None, f) } diff --git a/src/librustc_interface/util.rs b/src/librustc_interface/util.rs index dc82219b33286..fb5f3581b6dfd 100644 --- a/src/librustc_interface/util.rs +++ b/src/librustc_interface/util.rs @@ -128,7 +128,7 @@ pub fn scoped_thread R + Send, R: Send>(cfg: thread::Builder, f: } #[cfg(not(parallel_compiler))] -pub fn spawn_thread_pool R + Send, R: Send>( +pub fn setup_callbacks_and_run_in_thread_pool_with_globals R + Send, R: Send>( edition: Edition, _threads: usize, stderr: &Option>>>, @@ -157,7 +157,7 @@ pub fn spawn_thread_pool R + Send, R: Send>( } #[cfg(parallel_compiler)] -pub fn spawn_thread_pool R + Send, R: Send>( +pub fn setup_callbacks_and_run_in_thread_pool_with_globals R + Send, R: Send>( edition: Edition, threads: usize, stderr: &Option>>>, @@ -186,7 +186,7 @@ pub fn spawn_thread_pool R + Send, R: Send>( // span_session_globals are captured and set on the new // threads. ty::tls::with_thread_locals sets up thread local // callbacks from librustc_ast. - let main_handler = move |thread: ThreadBuilder| { + let main_handler = move |thread: rayon::ThreadBuilder| { rustc_ast::SESSION_GLOBALS.set(ast_session_globals, || { rustc_span::SESSION_GLOBALS.set(span_session_globals, || { ty::tls::GCX_PTR.set(&Lock::new(0), || { diff --git a/src/librustdoc/core.rs b/src/librustdoc/core.rs index db98ec5d0a72e..80cc5182bef32 100644 --- a/src/librustdoc/core.rs +++ b/src/librustdoc/core.rs @@ -376,7 +376,7 @@ pub fn run_core(options: RustdocOptions) -> (clean::Crate, RenderInfo, RenderOpt registry: rustc_driver::diagnostics_registry(), }; - interface::run_compiler_in_existing_thread_pool(config, |compiler| { + interface::create_compiler_and_run(config, |compiler| { compiler.enter(|queries| { let sess = compiler.session(); diff --git a/src/librustdoc/lib.rs b/src/librustdoc/lib.rs index b02880ab4d3de..57151e2b20002 100644 --- a/src/librustdoc/lib.rs +++ b/src/librustdoc/lib.rs @@ -437,7 +437,10 @@ fn main_args(args: &[String]) -> i32 { Ok(opts) => opts, Err(code) => return code, }; - rustc_interface::interface::default_thread_pool(options.edition, move || main_options(options)) + rustc_interface::interface::setup_callbacks_and_run_in_default_thread_pool_with_globals( + options.edition, + move || main_options(options), + ) } fn wrap_return(diag: &rustc_errors::Handler, res: Result<(), String>) -> i32 { From 481988b0832de4b28fd1f4a52f0df2801f62bda8 Mon Sep 17 00:00:00 2001 From: Lzu Tao Date: Fri, 10 Jul 2020 07:18:19 +0000 Subject: [PATCH 32/35] Use str::strip* in bootstrap This commit replaces the use of `trim_start_matches` because in `rustc -Vv` output there are no lines starting with multiple "release:". --- src/bootstrap/compile.rs | 9 +++++---- src/bootstrap/lib.rs | 11 +++++------ 2 files changed, 10 insertions(+), 10 deletions(-) diff --git a/src/bootstrap/compile.rs b/src/bootstrap/compile.rs index 84545dcedb6d9..9b4926f28d4ed 100644 --- a/src/bootstrap/compile.rs +++ b/src/bootstrap/compile.rs @@ -963,10 +963,11 @@ pub fn run_cargo( .collect::>(); for (prefix, extension, expected_len) in toplevel { let candidates = contents.iter().filter(|&&(_, ref filename, ref meta)| { - filename.starts_with(&prefix[..]) - && filename[prefix.len()..].starts_with('-') - && filename.ends_with(&extension[..]) - && meta.len() == expected_len + meta.len() == expected_len + && filename + .strip_prefix(&prefix[..]) + .map(|s| s.starts_with('-') && s.ends_with(&extension[..])) + .unwrap_or(false) }); let max = candidates .max_by_key(|&&(_, _, ref metadata)| FileTime::from_last_modification_time(metadata)); diff --git a/src/bootstrap/lib.rs b/src/bootstrap/lib.rs index b973889448651..783a64c3581f9 100644 --- a/src/bootstrap/lib.rs +++ b/src/bootstrap/lib.rs @@ -436,10 +436,9 @@ impl Build { output(Command::new(&build.initial_rustc).arg("--version").arg("--verbose")); let local_release = local_version_verbose .lines() - .filter(|x| x.starts_with("release:")) + .filter_map(|x| x.strip_prefix("release:")) .next() .unwrap() - .trim_start_matches("release:") .trim(); let my_version = channel::CFG_RELEASE_NUM; if local_release.split('.').take(2).eq(my_version.split('.').take(2)) { @@ -1089,10 +1088,10 @@ impl Build { let toml_file_name = self.src.join(&format!("src/tools/{}/Cargo.toml", package)); let toml = t!(fs::read_to_string(&toml_file_name)); for line in toml.lines() { - let prefix = "version = \""; - let suffix = "\""; - if line.starts_with(prefix) && line.ends_with(suffix) { - return line[prefix.len()..line.len() - suffix.len()].to_string(); + if let Some(stripped) = + line.strip_prefix("version = \"").and_then(|s| s.strip_suffix("\"")) + { + return stripped.to_owned(); } } From 1ca7bfe481a18909e4769a9f6aee58f8cec17b44 Mon Sep 17 00:00:00 2001 From: Andrew Paverd Date: Mon, 6 Jul 2020 16:10:42 +0100 Subject: [PATCH 33/35] Only add cfguard module flag on windows-msvc --- src/librustc_codegen_llvm/context.rs | 19 ++++++++++++------- src/librustc_codegen_ssa/back/linker.rs | 16 ++++------------ .../{cfguard_checks.rs => cfguard-checks.rs} | 1 + ...fguard_disabled.rs => cfguard-disabled.rs} | 1 + ...fguard_nochecks.rs => cfguard-nochecks.rs} | 1 + src/test/codegen/cfguard-non-msvc.rs | 11 +++++++++++ src/test/ui/cfguard-run.rs | 6 ++++++ 7 files changed, 36 insertions(+), 19 deletions(-) rename src/test/codegen/{cfguard_checks.rs => cfguard-checks.rs} (93%) rename src/test/codegen/{cfguard_disabled.rs => cfguard-disabled.rs} (93%) rename src/test/codegen/{cfguard_nochecks.rs => cfguard-nochecks.rs} (93%) create mode 100644 src/test/codegen/cfguard-non-msvc.rs create mode 100644 src/test/ui/cfguard-run.rs diff --git a/src/librustc_codegen_llvm/context.rs b/src/librustc_codegen_llvm/context.rs index d484e15eb2f6e..21ba97d15a485 100644 --- a/src/librustc_codegen_llvm/context.rs +++ b/src/librustc_codegen_llvm/context.rs @@ -188,14 +188,19 @@ pub unsafe fn create_module( llvm::LLVMRustAddModuleFlag(llmod, avoid_plt, 1); } - // Set module flags to enable Windows Control Flow Guard (/guard:cf) metadata - // only (`cfguard=1`) or metadata and checks (`cfguard=2`). - match sess.opts.debugging_opts.control_flow_guard { - CFGuard::Disabled => {} - CFGuard::NoChecks => { - llvm::LLVMRustAddModuleFlag(llmod, "cfguard\0".as_ptr() as *const _, 1) + // Control Flow Guard is currently only supported by the MSVC linker on Windows. + if sess.target.target.options.is_like_msvc { + match sess.opts.debugging_opts.control_flow_guard { + CFGuard::Disabled => {} + CFGuard::NoChecks => { + // Set `cfguard=1` module flag to emit metadata only. + llvm::LLVMRustAddModuleFlag(llmod, "cfguard\0".as_ptr() as *const _, 1) + } + CFGuard::Checks => { + // Set `cfguard=2` module flag to emit metadata and checks. + llvm::LLVMRustAddModuleFlag(llmod, "cfguard\0".as_ptr() as *const _, 2) + } } - CFGuard::Checks => llvm::LLVMRustAddModuleFlag(llmod, "cfguard\0".as_ptr() as *const _, 2), } llmod diff --git a/src/librustc_codegen_ssa/back/linker.rs b/src/librustc_codegen_ssa/back/linker.rs index 54f55c806d035..550de75c709fb 100644 --- a/src/librustc_codegen_ssa/back/linker.rs +++ b/src/librustc_codegen_ssa/back/linker.rs @@ -475,9 +475,7 @@ impl<'a> Linker for GccLinker<'a> { self.cmd.arg("__llvm_profile_runtime"); } - fn control_flow_guard(&mut self) { - self.sess.warn("Windows Control Flow Guard is not supported by this linker."); - } + fn control_flow_guard(&mut self) {} fn debuginfo(&mut self, strip: Strip) { match strip { @@ -959,9 +957,7 @@ impl<'a> Linker for EmLinker<'a> { // noop, but maybe we need something like the gnu linker? } - fn control_flow_guard(&mut self) { - self.sess.warn("Windows Control Flow Guard is not supported by this linker."); - } + fn control_flow_guard(&mut self) {} fn debuginfo(&mut self, _strip: Strip) { // Preserve names or generate source maps depending on debug info @@ -1163,9 +1159,7 @@ impl<'a> Linker for WasmLd<'a> { } } - fn control_flow_guard(&mut self) { - self.sess.warn("Windows Control Flow Guard is not supported by this linker."); - } + fn control_flow_guard(&mut self) {} fn no_crt_objects(&mut self) {} @@ -1330,9 +1324,7 @@ impl<'a> Linker for PtxLinker<'a> { fn no_default_libraries(&mut self) {} - fn control_flow_guard(&mut self) { - self.sess.warn("Windows Control Flow Guard is not supported by this linker."); - } + fn control_flow_guard(&mut self) {} fn export_symbols(&mut self, _tmpdir: &Path, _crate_type: CrateType) {} diff --git a/src/test/codegen/cfguard_checks.rs b/src/test/codegen/cfguard-checks.rs similarity index 93% rename from src/test/codegen/cfguard_checks.rs rename to src/test/codegen/cfguard-checks.rs index 96f9158f9d394..96a0a321199a3 100644 --- a/src/test/codegen/cfguard_checks.rs +++ b/src/test/codegen/cfguard-checks.rs @@ -1,4 +1,5 @@ // compile-flags: -Z control-flow-guard=checks +// only-msvc #![crate_type = "lib"] diff --git a/src/test/codegen/cfguard_disabled.rs b/src/test/codegen/cfguard-disabled.rs similarity index 93% rename from src/test/codegen/cfguard_disabled.rs rename to src/test/codegen/cfguard-disabled.rs index 1325ffc0f2595..925e4e8e2d155 100644 --- a/src/test/codegen/cfguard_disabled.rs +++ b/src/test/codegen/cfguard-disabled.rs @@ -1,4 +1,5 @@ // compile-flags: -Z control-flow-guard=no +// only-msvc #![crate_type = "lib"] diff --git a/src/test/codegen/cfguard_nochecks.rs b/src/test/codegen/cfguard-nochecks.rs similarity index 93% rename from src/test/codegen/cfguard_nochecks.rs rename to src/test/codegen/cfguard-nochecks.rs index ae1de4c4d26d5..d7dc3d7e89eea 100644 --- a/src/test/codegen/cfguard_nochecks.rs +++ b/src/test/codegen/cfguard-nochecks.rs @@ -1,4 +1,5 @@ // compile-flags: -Z control-flow-guard=nochecks +// only-msvc #![crate_type = "lib"] diff --git a/src/test/codegen/cfguard-non-msvc.rs b/src/test/codegen/cfguard-non-msvc.rs new file mode 100644 index 0000000000000..4008f0187a0b0 --- /dev/null +++ b/src/test/codegen/cfguard-non-msvc.rs @@ -0,0 +1,11 @@ +// compile-flags: -Z control-flow-guard +// ignore-msvc + +#![crate_type = "lib"] + +// A basic test function. +pub fn test() { +} + +// Ensure the cfguard module flag is not added for non-MSVC targets. +// CHECK-NOT: !"cfguard" diff --git a/src/test/ui/cfguard-run.rs b/src/test/ui/cfguard-run.rs new file mode 100644 index 0000000000000..21368fad3b058 --- /dev/null +++ b/src/test/ui/cfguard-run.rs @@ -0,0 +1,6 @@ +// run-pass +// compile-flags: -Z control-flow-guard + +pub fn main() { + println!("hello, world"); +} From 62cf767a4a39b47677d18110359d9e7152dc9d1c Mon Sep 17 00:00:00 2001 From: Tamir Duberstein Date: Tue, 7 Jul 2020 11:12:44 -0400 Subject: [PATCH 34/35] Avoid "whitelist" Other terms are more inclusive and precise. --- src/bootstrap/doc.rs | 6 +- src/etc/test-float-parse/runtests.py | 8 +- src/libcore/ffi.rs | 2 +- src/librustc_codegen_llvm/attributes.rs | 8 +- src/librustc_codegen_llvm/back/lto.rs | 57 ++++--- src/librustc_codegen_llvm/llvm_util.rs | 57 ++++--- src/librustc_codegen_ssa/back/linker.rs | 8 +- src/librustc_codegen_ssa/base.rs | 5 +- src/librustc_expand/base.rs | 2 +- src/librustc_feature/builtin_attrs.rs | 144 +++++++++--------- .../persist/dirty_clean.rs | 2 +- src/librustc_interface/util.rs | 4 +- src/librustc_lint/unused.rs | 4 +- src/librustc_metadata/rmeta/decoder.rs | 3 - src/librustc_middle/lint.rs | 5 +- src/librustc_middle/middle/lang_items.rs | 13 +- src/librustc_middle/query/mod.rs | 4 +- src/librustc_mir/const_eval/fn_queries.rs | 2 +- src/librustc_mir/interpret/validity.rs | 2 +- src/librustc_passes/weak_lang_items.rs | 4 +- src/librustc_resolve/late/lifetimes.rs | 2 +- src/librustc_target/spec/tests/tests_impl.rs | 4 +- src/librustc_target/spec/wasm32_base.rs | 16 +- .../traits/error_reporting/suggestions.rs | 2 +- src/librustc_typeck/check/demand.rs | 2 +- src/librustc_typeck/check/expr.rs | 4 +- src/librustc_typeck/collect.rs | 23 +-- src/librustdoc/core.rs | 20 +-- src/librustdoc/html/render.rs | 4 +- src/librustdoc/test.rs | 6 +- src/libstd/time.rs | 2 +- .../hotplug_codegen_backend/the_backend.rs | 2 +- .../sysroot-crates-are-unstable/test.py | 2 +- .../auxiliary/issue-40001-plugin.rs | 20 +-- src/test/ui-fulldeps/issue-40001.rs | 2 +- src/test/ui/asm/type-check-3.rs | 2 +- .../ui/rfc-2126-extern-absolute-paths/meta.rs | 4 +- .../{not-whitelisted.rs => not-allowed.rs} | 0 ...-whitelisted.stderr => not-allowed.stderr} | 2 +- src/test/ui/sse2.rs | 2 +- src/tools/clippy/clippy_lints/src/attrs.rs | 4 +- src/tools/clippy/clippy_lints/src/eq_op.rs | 2 +- .../src/needless_pass_by_value.rs | 4 +- .../clippy_lints/src/non_expressive_names.rs | 18 +-- .../clippy/clippy_lints/src/precedence.rs | 4 +- src/tools/clippy/clippy_lints/src/types.rs | 4 +- .../{whitelist => third-party}/clippy.toml | 0 .../conf_allowlisted.rs} | 0 .../clippy/tests/ui/needless_pass_by_value.rs | 2 +- .../tests/ui/neg_cmp_op_on_partial_ord.rs | 2 +- src/tools/linkchecker/main.rs | 6 +- src/tools/tidy/src/cargo.rs | 4 +- src/tools/tidy/src/deps.rs | 51 ++++--- src/tools/tidy/src/error_codes_check.rs | 4 +- src/tools/tidy/src/extdeps.rs | 8 +- 55 files changed, 296 insertions(+), 278 deletions(-) rename src/test/ui/rfc-2126-extern-absolute-paths/{not-whitelisted.rs => not-allowed.rs} (100%) rename src/test/ui/rfc-2126-extern-absolute-paths/{not-whitelisted.stderr => not-allowed.stderr} (86%) rename src/tools/clippy/tests/ui/crashes/{whitelist => third-party}/clippy.toml (100%) rename src/tools/clippy/tests/ui/crashes/{whitelist/conf_whitelisted.rs => third-party/conf_allowlisted.rs} (100%) diff --git a/src/bootstrap/doc.rs b/src/bootstrap/doc.rs index 4bec6c7791a21..582bc9da0e804 100644 --- a/src/bootstrap/doc.rs +++ b/src/bootstrap/doc.rs @@ -439,8 +439,6 @@ impl Step for Std { builder.cargo(compiler, Mode::Std, SourceType::InTree, target, "rustdoc"); compile::std_cargo(builder, target, compiler.stage, &mut cargo); - // Keep a whitelist so we do not build internal stdlib crates, these will be - // build by the rustc step later if enabled. cargo.arg("-p").arg(package); // Create all crate output directories first to make sure rustdoc uses // relative links. @@ -460,6 +458,10 @@ impl Step for Std { builder.run(&mut cargo.into()); }; + // Only build the following crates. While we could just iterate over the + // folder structure, that would also build internal crates that we do + // not want to show in documentation. These crates will later be visited + // by the rustc step, so internal documentation will show them. let krates = ["alloc", "core", "std", "proc_macro", "test"]; for krate in &krates { run_cargo_rustdoc_for(krate); diff --git a/src/etc/test-float-parse/runtests.py b/src/etc/test-float-parse/runtests.py index fe6fd45f9a5f8..7106078f897cf 100644 --- a/src/etc/test-float-parse/runtests.py +++ b/src/etc/test-float-parse/runtests.py @@ -195,9 +195,9 @@ def main(): global MAILBOX tests = [os.path.splitext(f)[0] for f in glob('*.rs') if not f.startswith('_')] - whitelist = sys.argv[1:] - if whitelist: - tests = [test for test in tests if test in whitelist] + listed = sys.argv[1:] + if listed: + tests = [test for test in tests if test in listed] if not tests: print("Error: No tests to run") sys.exit(1) @@ -210,8 +210,6 @@ def main(): mailman.daemon = True mailman.start() for test in tests: - if whitelist and test not in whitelist: - continue run(test) MAILBOX.put(None) mailman.join() diff --git a/src/libcore/ffi.rs b/src/libcore/ffi.rs index ee3192eddbd06..e9689af39d51f 100644 --- a/src/libcore/ffi.rs +++ b/src/libcore/ffi.rs @@ -280,7 +280,7 @@ impl<'a, 'f: 'a> DerefMut for VaList<'a, 'f> { // within a private module. Once RFC 2145 has been implemented look into // improving this. mod sealed_trait { - /// Trait which whitelists the allowed types to be used with [VaList::arg] + /// Trait which permits the allowed types to be used with [VaList::arg]. /// /// [VaList::arg]: ../struct.VaList.html#method.arg #[unstable( diff --git a/src/librustc_codegen_llvm/attributes.rs b/src/librustc_codegen_llvm/attributes.rs index c53a64664a639..89b548a9c5ab2 100644 --- a/src/librustc_codegen_llvm/attributes.rs +++ b/src/librustc_codegen_llvm/attributes.rs @@ -263,7 +263,7 @@ pub fn from_fn_attrs(cx: &CodegenCx<'ll, 'tcx>, llfn: &'ll Value, instance: ty:: // Windows we end up still needing the `uwtable` attribute even if the `-C // panic=abort` flag is passed. // - // You can also find more info on why Windows is whitelisted here in: + // You can also find more info on why Windows always requires uwtables here: // https://bugzilla.mozilla.org/show_bug.cgi?id=1302078 if cx.sess().must_emit_unwind_tables() { attributes::emit_uwtable(llfn, true); @@ -343,14 +343,14 @@ pub fn from_fn_attrs(cx: &CodegenCx<'ll, 'tcx>, llfn: &'ll Value, instance: ty:: } pub fn provide(providers: &mut Providers) { - providers.target_features_whitelist = |tcx, cnum| { + providers.supported_target_features = |tcx, cnum| { assert_eq!(cnum, LOCAL_CRATE); if tcx.sess.opts.actually_rustdoc { // rustdoc needs to be able to document functions that use all the features, so - // whitelist them all + // provide them all. llvm_util::all_known_features().map(|(a, b)| (a.to_string(), b)).collect() } else { - llvm_util::target_feature_whitelist(tcx.sess) + llvm_util::supported_target_features(tcx.sess) .iter() .map(|&(a, b)| (a.to_string(), b)) .collect() diff --git a/src/librustc_codegen_llvm/back/lto.rs b/src/librustc_codegen_llvm/back/lto.rs index 9764c9a102e8a..6b02b5e8120db 100644 --- a/src/librustc_codegen_llvm/back/lto.rs +++ b/src/librustc_codegen_llvm/back/lto.rs @@ -62,11 +62,11 @@ fn prepare_lto( } }; let exported_symbols = cgcx.exported_symbols.as_ref().expect("needs exported symbols for LTO"); - let mut symbol_white_list = { - let _timer = cgcx.prof.generic_activity("LLVM_lto_generate_symbol_white_list"); + let mut symbols_below_threshold = { + let _timer = cgcx.prof.generic_activity("LLVM_lto_generate_symbols_below_threshold"); exported_symbols[&LOCAL_CRATE].iter().filter_map(symbol_filter).collect::>() }; - info!("{} symbols to preserve in this crate", symbol_white_list.len()); + info!("{} symbols to preserve in this crate", symbols_below_threshold.len()); // If we're performing LTO for the entire crate graph, then for each of our // upstream dependencies, find the corresponding rlib and load the bitcode @@ -102,8 +102,10 @@ fn prepare_lto( let exported_symbols = cgcx.exported_symbols.as_ref().expect("needs exported symbols for LTO"); { - let _timer = cgcx.prof.generic_activity("LLVM_lto_generate_symbol_white_list"); - symbol_white_list.extend(exported_symbols[&cnum].iter().filter_map(symbol_filter)); + let _timer = + cgcx.prof.generic_activity("LLVM_lto_generate_symbols_below_threshold"); + symbols_below_threshold + .extend(exported_symbols[&cnum].iter().filter_map(symbol_filter)); } let archive = ArchiveRO::open(&path).expect("wanted an rlib"); @@ -124,7 +126,7 @@ fn prepare_lto( } } - Ok((symbol_white_list, upstream_modules)) + Ok((symbols_below_threshold, upstream_modules)) } fn get_bitcode_slice_from_object_data(obj: &[u8]) -> Result<&[u8], String> { @@ -155,9 +157,17 @@ pub(crate) fn run_fat( cached_modules: Vec<(SerializedModule, WorkProduct)>, ) -> Result, FatalError> { let diag_handler = cgcx.create_diag_handler(); - let (symbol_white_list, upstream_modules) = prepare_lto(cgcx, &diag_handler)?; - let symbol_white_list = symbol_white_list.iter().map(|c| c.as_ptr()).collect::>(); - fat_lto(cgcx, &diag_handler, modules, cached_modules, upstream_modules, &symbol_white_list) + let (symbols_below_threshold, upstream_modules) = prepare_lto(cgcx, &diag_handler)?; + let symbols_below_threshold = + symbols_below_threshold.iter().map(|c| c.as_ptr()).collect::>(); + fat_lto( + cgcx, + &diag_handler, + modules, + cached_modules, + upstream_modules, + &symbols_below_threshold, + ) } /// Performs thin LTO by performing necessary global analysis and returning two @@ -169,15 +179,23 @@ pub(crate) fn run_thin( cached_modules: Vec<(SerializedModule, WorkProduct)>, ) -> Result<(Vec>, Vec), FatalError> { let diag_handler = cgcx.create_diag_handler(); - let (symbol_white_list, upstream_modules) = prepare_lto(cgcx, &diag_handler)?; - let symbol_white_list = symbol_white_list.iter().map(|c| c.as_ptr()).collect::>(); + let (symbols_below_threshold, upstream_modules) = prepare_lto(cgcx, &diag_handler)?; + let symbols_below_threshold = + symbols_below_threshold.iter().map(|c| c.as_ptr()).collect::>(); if cgcx.opts.cg.linker_plugin_lto.enabled() { unreachable!( "We should never reach this case if the LTO step \ is deferred to the linker" ); } - thin_lto(cgcx, &diag_handler, modules, upstream_modules, cached_modules, &symbol_white_list) + thin_lto( + cgcx, + &diag_handler, + modules, + upstream_modules, + cached_modules, + &symbols_below_threshold, + ) } pub(crate) fn prepare_thin(module: ModuleCodegen) -> (String, ThinBuffer) { @@ -192,7 +210,7 @@ fn fat_lto( modules: Vec>, cached_modules: Vec<(SerializedModule, WorkProduct)>, mut serialized_modules: Vec<(SerializedModule, CString)>, - symbol_white_list: &[*const libc::c_char], + symbols_below_threshold: &[*const libc::c_char], ) -> Result, FatalError> { let _timer = cgcx.prof.generic_activity("LLVM_fat_lto_build_monolithic_module"); info!("going for a fat lto"); @@ -306,14 +324,13 @@ fn fat_lto( drop(linker); save_temp_bitcode(&cgcx, &module, "lto.input"); - // Internalize everything that *isn't* in our whitelist to help strip out - // more modules and such + // Internalize everything below threshold to help strip out more modules and such. unsafe { - let ptr = symbol_white_list.as_ptr(); + let ptr = symbols_below_threshold.as_ptr(); llvm::LLVMRustRunRestrictionPass( llmod, ptr as *const *const libc::c_char, - symbol_white_list.len() as libc::size_t, + symbols_below_threshold.len() as libc::size_t, ); save_temp_bitcode(&cgcx, &module, "lto.after-restriction"); } @@ -395,7 +412,7 @@ fn thin_lto( modules: Vec<(String, ThinBuffer)>, serialized_modules: Vec<(SerializedModule, CString)>, cached_modules: Vec<(SerializedModule, WorkProduct)>, - symbol_white_list: &[*const libc::c_char], + symbols_below_threshold: &[*const libc::c_char], ) -> Result<(Vec>, Vec), FatalError> { let _timer = cgcx.prof.generic_activity("LLVM_thin_lto_global_analysis"); unsafe { @@ -463,8 +480,8 @@ fn thin_lto( let data = llvm::LLVMRustCreateThinLTOData( thin_modules.as_ptr(), thin_modules.len() as u32, - symbol_white_list.as_ptr(), - symbol_white_list.len() as u32, + symbols_below_threshold.as_ptr(), + symbols_below_threshold.len() as u32, ) .ok_or_else(|| write::llvm_err(&diag_handler, "failed to prepare thin LTO context"))?; diff --git a/src/librustc_codegen_llvm/llvm_util.rs b/src/librustc_codegen_llvm/llvm_util.rs index 2e2ce1544109a..b631c10334cd1 100644 --- a/src/librustc_codegen_llvm/llvm_util.rs +++ b/src/librustc_codegen_llvm/llvm_util.rs @@ -139,7 +139,7 @@ pub fn time_trace_profiler_finish(file_name: &str) { // to LLVM or the feature detection code will walk past the end of the feature // array, leading to crashes. -const ARM_WHITELIST: &[(&str, Option)] = &[ +const ARM_ALLOWED_FEATURES: &[(&str, Option)] = &[ ("aclass", Some(sym::arm_target_feature)), ("mclass", Some(sym::arm_target_feature)), ("rclass", Some(sym::arm_target_feature)), @@ -162,7 +162,7 @@ const ARM_WHITELIST: &[(&str, Option)] = &[ ("thumb-mode", Some(sym::arm_target_feature)), ]; -const AARCH64_WHITELIST: &[(&str, Option)] = &[ +const AARCH64_ALLOWED_FEATURES: &[(&str, Option)] = &[ ("fp", Some(sym::aarch64_target_feature)), ("neon", Some(sym::aarch64_target_feature)), ("sve", Some(sym::aarch64_target_feature)), @@ -180,7 +180,7 @@ const AARCH64_WHITELIST: &[(&str, Option)] = &[ ("v8.3a", Some(sym::aarch64_target_feature)), ]; -const X86_WHITELIST: &[(&str, Option)] = &[ +const X86_ALLOWED_FEATURES: &[(&str, Option)] = &[ ("adx", Some(sym::adx_target_feature)), ("aes", None), ("avx", None), @@ -224,12 +224,12 @@ const X86_WHITELIST: &[(&str, Option)] = &[ ("xsaves", None), ]; -const HEXAGON_WHITELIST: &[(&str, Option)] = &[ +const HEXAGON_ALLOWED_FEATURES: &[(&str, Option)] = &[ ("hvx", Some(sym::hexagon_target_feature)), ("hvx-length128b", Some(sym::hexagon_target_feature)), ]; -const POWERPC_WHITELIST: &[(&str, Option)] = &[ +const POWERPC_ALLOWED_FEATURES: &[(&str, Option)] = &[ ("altivec", Some(sym::powerpc_target_feature)), ("power8-altivec", Some(sym::powerpc_target_feature)), ("power9-altivec", Some(sym::powerpc_target_feature)), @@ -238,10 +238,10 @@ const POWERPC_WHITELIST: &[(&str, Option)] = &[ ("vsx", Some(sym::powerpc_target_feature)), ]; -const MIPS_WHITELIST: &[(&str, Option)] = +const MIPS_ALLOWED_FEATURES: &[(&str, Option)] = &[("fp64", Some(sym::mips_target_feature)), ("msa", Some(sym::mips_target_feature))]; -const RISCV_WHITELIST: &[(&str, Option)] = &[ +const RISCV_ALLOWED_FEATURES: &[(&str, Option)] = &[ ("m", Some(sym::riscv_target_feature)), ("a", Some(sym::riscv_target_feature)), ("c", Some(sym::riscv_target_feature)), @@ -250,7 +250,7 @@ const RISCV_WHITELIST: &[(&str, Option)] = &[ ("e", Some(sym::riscv_target_feature)), ]; -const WASM_WHITELIST: &[(&str, Option)] = &[ +const WASM_ALLOWED_FEATURES: &[(&str, Option)] = &[ ("simd128", Some(sym::wasm_target_feature)), ("atomics", Some(sym::wasm_target_feature)), ("nontrapping-fptoint", Some(sym::wasm_target_feature)), @@ -259,19 +259,18 @@ const WASM_WHITELIST: &[(&str, Option)] = &[ /// When rustdoc is running, provide a list of all known features so that all their respective /// primitives may be documented. /// -/// IMPORTANT: If you're adding another whitelist to the above lists, make sure to add it to this -/// iterator! +/// IMPORTANT: If you're adding another feature list above, make sure to add it to this iterator! pub fn all_known_features() -> impl Iterator)> { - ARM_WHITELIST - .iter() + std::iter::empty() + .chain(ARM_ALLOWED_FEATURES.iter()) + .chain(AARCH64_ALLOWED_FEATURES.iter()) + .chain(X86_ALLOWED_FEATURES.iter()) + .chain(HEXAGON_ALLOWED_FEATURES.iter()) + .chain(POWERPC_ALLOWED_FEATURES.iter()) + .chain(MIPS_ALLOWED_FEATURES.iter()) + .chain(RISCV_ALLOWED_FEATURES.iter()) + .chain(WASM_ALLOWED_FEATURES.iter()) .cloned() - .chain(AARCH64_WHITELIST.iter().cloned()) - .chain(X86_WHITELIST.iter().cloned()) - .chain(HEXAGON_WHITELIST.iter().cloned()) - .chain(POWERPC_WHITELIST.iter().cloned()) - .chain(MIPS_WHITELIST.iter().cloned()) - .chain(RISCV_WHITELIST.iter().cloned()) - .chain(WASM_WHITELIST.iter().cloned()) } pub fn to_llvm_feature<'a>(sess: &Session, s: &'a str) -> &'a str { @@ -289,7 +288,7 @@ pub fn to_llvm_feature<'a>(sess: &Session, s: &'a str) -> &'a str { pub fn target_features(sess: &Session) -> Vec { let target_machine = create_informational_target_machine(sess); - target_feature_whitelist(sess) + supported_target_features(sess) .iter() .filter_map(|&(feature, gate)| { if UnstableFeatures::from_environment().is_nightly_build() || gate.is_none() { @@ -307,16 +306,16 @@ pub fn target_features(sess: &Session) -> Vec { .collect() } -pub fn target_feature_whitelist(sess: &Session) -> &'static [(&'static str, Option)] { +pub fn supported_target_features(sess: &Session) -> &'static [(&'static str, Option)] { match &*sess.target.target.arch { - "arm" => ARM_WHITELIST, - "aarch64" => AARCH64_WHITELIST, - "x86" | "x86_64" => X86_WHITELIST, - "hexagon" => HEXAGON_WHITELIST, - "mips" | "mips64" => MIPS_WHITELIST, - "powerpc" | "powerpc64" => POWERPC_WHITELIST, - "riscv32" | "riscv64" => RISCV_WHITELIST, - "wasm32" => WASM_WHITELIST, + "arm" => ARM_ALLOWED_FEATURES, + "aarch64" => AARCH64_ALLOWED_FEATURES, + "x86" | "x86_64" => X86_ALLOWED_FEATURES, + "hexagon" => HEXAGON_ALLOWED_FEATURES, + "mips" | "mips64" => MIPS_ALLOWED_FEATURES, + "powerpc" | "powerpc64" => POWERPC_ALLOWED_FEATURES, + "riscv32" | "riscv64" => RISCV_ALLOWED_FEATURES, + "wasm32" => WASM_ALLOWED_FEATURES, _ => &[], } } diff --git a/src/librustc_codegen_ssa/back/linker.rs b/src/librustc_codegen_ssa/back/linker.rs index 54f55c806d035..43d351342ccad 100644 --- a/src/librustc_codegen_ssa/back/linker.rs +++ b/src/librustc_codegen_ssa/back/linker.rs @@ -1176,10 +1176,10 @@ impl<'a> Linker for WasmLd<'a> { self.cmd.arg("--export").arg(&sym); } - // LLD will hide these otherwise-internal symbols since our `--export` - // list above is a whitelist of what to export. Various bits and pieces - // of tooling use this, so be sure these symbols make their way out of - // the linker as well. + // LLD will hide these otherwise-internal symbols since it only exports + // symbols explicity passed via the `--export` flags above and hides all + // others. Various bits and pieces of tooling use this, so be sure these + // symbols make their way out of the linker as well. self.cmd.arg("--export=__heap_base"); self.cmd.arg("--export=__data_end"); } diff --git a/src/librustc_codegen_ssa/base.rs b/src/librustc_codegen_ssa/base.rs index 4e257fba44ab6..b28cb071de659 100644 --- a/src/librustc_codegen_ssa/base.rs +++ b/src/librustc_codegen_ssa/base.rs @@ -842,10 +842,9 @@ impl CrateInfo { } } - // No need to look for lang items that are whitelisted and don't - // actually need to exist. + // No need to look for lang items that don't actually need to exist. let missing = - missing.iter().cloned().filter(|&l| !lang_items::whitelisted(tcx, l)).collect(); + missing.iter().cloned().filter(|&l| lang_items::required(tcx, l)).collect(); info.missing_lang_items.insert(cnum, missing); } diff --git a/src/librustc_expand/base.rs b/src/librustc_expand/base.rs index db9293bddeb7d..3e48224ef9f20 100644 --- a/src/librustc_expand/base.rs +++ b/src/librustc_expand/base.rs @@ -735,7 +735,7 @@ pub struct SyntaxExtension { pub kind: SyntaxExtensionKind, /// Span of the macro definition. pub span: Span, - /// Whitelist of unstable features that are treated as stable inside this macro. + /// List of unstable features that are treated as stable inside this macro. pub allow_internal_unstable: Option>, /// Suppresses the `unsafe_code` lint for code produced by this macro. pub allow_internal_unsafe: bool, diff --git a/src/librustc_feature/builtin_attrs.rs b/src/librustc_feature/builtin_attrs.rs index c9a34f033758b..4e2aea34fe7fb 100644 --- a/src/librustc_feature/builtin_attrs.rs +++ b/src/librustc_feature/builtin_attrs.rs @@ -47,7 +47,7 @@ pub enum AttributeType { /// Builtin attribute that may not be consumed by the compiler /// before the unused_attribute check. These attributes /// will be ignored by the unused_attribute lint - Whitelisted, + AssumedUsed, /// Builtin attribute that is only allowed at the crate level CrateLevel, @@ -202,7 +202,7 @@ pub const BUILTIN_ATTRIBUTES: &[BuiltinAttribute] = &[ ungated!(allow, Normal, template!(List: r#"lint1, lint2, ..., /*opt*/ reason = "...""#)), ungated!(forbid, Normal, template!(List: r#"lint1, lint2, ..., /*opt*/ reason = "...""#)), ungated!(deny, Normal, template!(List: r#"lint1, lint2, ..., /*opt*/ reason = "...""#)), - ungated!(must_use, Whitelisted, template!(Word, NameValueStr: "reason")), + ungated!(must_use, AssumedUsed, template!(Word, NameValueStr: "reason")), // FIXME(#14407) ungated!( deprecated, Normal, @@ -220,16 +220,16 @@ pub const BUILTIN_ATTRIBUTES: &[BuiltinAttribute] = &[ // ABI, linking, symbols, and FFI ungated!( - link, Whitelisted, + link, AssumedUsed, template!(List: r#"name = "...", /*opt*/ kind = "dylib|static|...", /*opt*/ wasm_import_module = "...""#), ), - ungated!(link_name, Whitelisted, template!(NameValueStr: "name")), + ungated!(link_name, AssumedUsed, template!(NameValueStr: "name")), ungated!(no_link, Normal, template!(Word)), ungated!(repr, Normal, template!(List: "C")), - ungated!(export_name, Whitelisted, template!(NameValueStr: "name")), - ungated!(link_section, Whitelisted, template!(NameValueStr: "name")), - ungated!(no_mangle, Whitelisted, template!(Word)), - ungated!(used, Whitelisted, template!(Word)), + ungated!(export_name, AssumedUsed, template!(NameValueStr: "name")), + ungated!(link_section, AssumedUsed, template!(NameValueStr: "name")), + ungated!(no_mangle, AssumedUsed, template!(Word)), + ungated!(used, AssumedUsed, template!(Word)), // Limits: ungated!(recursion_limit, CrateLevel, template!(NameValueStr: "N")), @@ -249,40 +249,40 @@ pub const BUILTIN_ATTRIBUTES: &[BuiltinAttribute] = &[ ungated!(path, Normal, template!(NameValueStr: "file")), ungated!(no_std, CrateLevel, template!(Word)), ungated!(no_implicit_prelude, Normal, template!(Word)), - ungated!(non_exhaustive, Whitelisted, template!(Word)), + ungated!(non_exhaustive, AssumedUsed, template!(Word)), // Runtime - ungated!(windows_subsystem, Whitelisted, template!(NameValueStr: "windows|console")), + ungated!(windows_subsystem, AssumedUsed, template!(NameValueStr: "windows|console")), ungated!(panic_handler, Normal, template!(Word)), // RFC 2070 // Code generation: - ungated!(inline, Whitelisted, template!(Word, List: "always|never")), - ungated!(cold, Whitelisted, template!(Word)), - ungated!(no_builtins, Whitelisted, template!(Word)), - ungated!(target_feature, Whitelisted, template!(List: r#"enable = "name""#)), - ungated!(track_caller, Whitelisted, template!(Word)), + ungated!(inline, AssumedUsed, template!(Word, List: "always|never")), + ungated!(cold, AssumedUsed, template!(Word)), + ungated!(no_builtins, AssumedUsed, template!(Word)), + ungated!(target_feature, AssumedUsed, template!(List: r#"enable = "name""#)), + ungated!(track_caller, AssumedUsed, template!(Word)), gated!( - no_sanitize, Whitelisted, + no_sanitize, AssumedUsed, template!(List: "address, memory, thread"), experimental!(no_sanitize) ), - // FIXME: #14408 whitelist docs since rustdoc looks at them - ungated!(doc, Whitelisted, template!(List: "hidden|inline|...", NameValueStr: "string")), + // FIXME: #14408 assume docs are used since rustdoc looks at them. + ungated!(doc, AssumedUsed, template!(List: "hidden|inline|...", NameValueStr: "string")), // ========================================================================== // Unstable attributes: // ========================================================================== // Linking: - gated!(naked, Whitelisted, template!(Word), naked_functions, experimental!(naked)), + gated!(naked, AssumedUsed, template!(Word), naked_functions, experimental!(naked)), gated!( link_args, Normal, template!(NameValueStr: "args"), "the `link_args` attribute is experimental and not portable across platforms, \ it is recommended to use `#[link(name = \"foo\")] instead", ), gated!( - link_ordinal, Whitelisted, template!(List: "ordinal"), raw_dylib, + link_ordinal, AssumedUsed, template!(List: "ordinal"), raw_dylib, experimental!(link_ordinal) ), @@ -321,19 +321,19 @@ pub const BUILTIN_ATTRIBUTES: &[BuiltinAttribute] = &[ // RFC #1268 gated!(marker, Normal, template!(Word), marker_trait_attr, experimental!(marker)), gated!( - thread_local, Whitelisted, template!(Word), + thread_local, AssumedUsed, template!(Word), "`#[thread_local]` is an experimental feature, and does not currently handle destructors", ), gated!(no_core, CrateLevel, template!(Word), experimental!(no_core)), // RFC 2412 gated!( - optimize, Whitelisted, template!(List: "size|speed"), optimize_attribute, + optimize, AssumedUsed, template!(List: "size|speed"), optimize_attribute, experimental!(optimize), ), - gated!(ffi_returns_twice, Whitelisted, template!(Word), experimental!(ffi_returns_twice)), - gated!(ffi_pure, Whitelisted, template!(Word), experimental!(ffi_pure)), - gated!(ffi_const, Whitelisted, template!(Word), experimental!(ffi_const)), + gated!(ffi_returns_twice, AssumedUsed, template!(Word), experimental!(ffi_returns_twice)), + gated!(ffi_pure, AssumedUsed, template!(Word), experimental!(ffi_pure)), + gated!(ffi_const, AssumedUsed, template!(Word), experimental!(ffi_const)), gated!( register_attr, CrateLevel, template!(List: "attr1, attr2, ..."), experimental!(register_attr), @@ -351,22 +351,22 @@ pub const BUILTIN_ATTRIBUTES: &[BuiltinAttribute] = &[ // FIXME(#14407) -- only looked at on-demand so we can't // guarantee they'll have already been checked. ungated!( - rustc_deprecated, Whitelisted, + rustc_deprecated, AssumedUsed, template!(List: r#"since = "version", reason = "...""#) ), // FIXME(#14407) - ungated!(stable, Whitelisted, template!(List: r#"feature = "name", since = "version""#)), + ungated!(stable, AssumedUsed, template!(List: r#"feature = "name", since = "version""#)), // FIXME(#14407) ungated!( - unstable, Whitelisted, + unstable, AssumedUsed, template!(List: r#"feature = "name", reason = "...", issue = "N""#), ), // FIXME(#14407) - ungated!(rustc_const_unstable, Whitelisted, template!(List: r#"feature = "name""#)), + ungated!(rustc_const_unstable, AssumedUsed, template!(List: r#"feature = "name""#)), // FIXME(#14407) - ungated!(rustc_const_stable, Whitelisted, template!(List: r#"feature = "name""#)), + ungated!(rustc_const_stable, AssumedUsed, template!(List: r#"feature = "name""#)), gated!( - allow_internal_unstable, Whitelisted, template!(Word, List: "feat1, feat2, ..."), + allow_internal_unstable, AssumedUsed, template!(Word, List: "feat1, feat2, ..."), "allow_internal_unstable side-steps feature gating and stability checks", ), gated!( @@ -378,7 +378,7 @@ pub const BUILTIN_ATTRIBUTES: &[BuiltinAttribute] = &[ // Internal attributes: Type system related: // ========================================================================== - gated!(fundamental, Whitelisted, template!(Word), experimental!(fundamental)), + gated!(fundamental, AssumedUsed, template!(Word), experimental!(fundamental)), gated!( may_dangle, Normal, template!(Word), dropck_eyepatch, "`may_dangle` has unstable semantics and may be removed in the future", @@ -388,30 +388,30 @@ pub const BUILTIN_ATTRIBUTES: &[BuiltinAttribute] = &[ // Internal attributes: Runtime related: // ========================================================================== - rustc_attr!(rustc_allocator, Whitelisted, template!(Word), IMPL_DETAIL), - rustc_attr!(rustc_allocator_nounwind, Whitelisted, template!(Word), IMPL_DETAIL), + rustc_attr!(rustc_allocator, AssumedUsed, template!(Word), IMPL_DETAIL), + rustc_attr!(rustc_allocator_nounwind, AssumedUsed, template!(Word), IMPL_DETAIL), gated!(alloc_error_handler, Normal, template!(Word), experimental!(alloc_error_handler)), gated!( - default_lib_allocator, Whitelisted, template!(Word), allocator_internals, + default_lib_allocator, AssumedUsed, template!(Word), allocator_internals, experimental!(default_lib_allocator), ), gated!( needs_allocator, Normal, template!(Word), allocator_internals, experimental!(needs_allocator), ), - gated!(panic_runtime, Whitelisted, template!(Word), experimental!(panic_runtime)), - gated!(needs_panic_runtime, Whitelisted, template!(Word), experimental!(needs_panic_runtime)), + gated!(panic_runtime, AssumedUsed, template!(Word), experimental!(panic_runtime)), + gated!(needs_panic_runtime, AssumedUsed, template!(Word), experimental!(needs_panic_runtime)), gated!( - unwind, Whitelisted, template!(List: "allowed|aborts"), unwind_attributes, + unwind, AssumedUsed, template!(List: "allowed|aborts"), unwind_attributes, experimental!(unwind), ), gated!( - compiler_builtins, Whitelisted, template!(Word), + compiler_builtins, AssumedUsed, template!(Word), "the `#[compiler_builtins]` attribute is used to identify the `compiler_builtins` crate \ which contains compiler-rt intrinsics and will never be stable", ), gated!( - profiler_runtime, Whitelisted, template!(Word), + profiler_runtime, AssumedUsed, template!(Word), "the `#[profiler_runtime]` attribute is used to identify the `profiler_builtins` crate \ which contains the profiler runtime and will never be stable", ), @@ -421,19 +421,19 @@ pub const BUILTIN_ATTRIBUTES: &[BuiltinAttribute] = &[ // ========================================================================== gated!( - linkage, Whitelisted, template!(NameValueStr: "external|internal|..."), + linkage, AssumedUsed, template!(NameValueStr: "external|internal|..."), "the `linkage` attribute is experimental and not portable across platforms", ), - rustc_attr!(rustc_std_internal_symbol, Whitelisted, template!(Word), INTERNAL_UNSTABLE), + rustc_attr!(rustc_std_internal_symbol, AssumedUsed, template!(Word), INTERNAL_UNSTABLE), // ========================================================================== // Internal attributes, Macro related: // ========================================================================== - rustc_attr!(rustc_builtin_macro, Whitelisted, template!(Word), IMPL_DETAIL), + rustc_attr!(rustc_builtin_macro, AssumedUsed, template!(Word), IMPL_DETAIL), rustc_attr!(rustc_proc_macro_decls, Normal, template!(Word), INTERNAL_UNSTABLE), rustc_attr!( - rustc_macro_transparency, Whitelisted, + rustc_macro_transparency, AssumedUsed, template!(NameValueStr: "transparent|semitransparent|opaque"), "used internally for testing macro hygiene", ), @@ -443,40 +443,40 @@ pub const BUILTIN_ATTRIBUTES: &[BuiltinAttribute] = &[ // ========================================================================== rustc_attr!( - rustc_on_unimplemented, Whitelisted, + rustc_on_unimplemented, AssumedUsed, template!( List: r#"/*opt*/ message = "...", /*opt*/ label = "...", /*opt*/ note = "...""#, NameValueStr: "message" ), INTERNAL_UNSTABLE ), - // Whitelists "identity-like" conversion methods to suggest on type mismatch. - rustc_attr!(rustc_conversion_suggestion, Whitelisted, template!(Word), INTERNAL_UNSTABLE), + // Enumerates "identity-like" conversion methods to suggest on type mismatch. + rustc_attr!(rustc_conversion_suggestion, AssumedUsed, template!(Word), INTERNAL_UNSTABLE), // ========================================================================== // Internal attributes, Const related: // ========================================================================== - rustc_attr!(rustc_promotable, Whitelisted, template!(Word), IMPL_DETAIL), - rustc_attr!(rustc_allow_const_fn_ptr, Whitelisted, template!(Word), IMPL_DETAIL), - rustc_attr!(rustc_args_required_const, Whitelisted, template!(List: "N"), INTERNAL_UNSTABLE), + rustc_attr!(rustc_promotable, AssumedUsed, template!(Word), IMPL_DETAIL), + rustc_attr!(rustc_allow_const_fn_ptr, AssumedUsed, template!(Word), IMPL_DETAIL), + rustc_attr!(rustc_args_required_const, AssumedUsed, template!(List: "N"), INTERNAL_UNSTABLE), // ========================================================================== // Internal attributes, Layout related: // ========================================================================== rustc_attr!( - rustc_layout_scalar_valid_range_start, Whitelisted, template!(List: "value"), + rustc_layout_scalar_valid_range_start, AssumedUsed, template!(List: "value"), "the `#[rustc_layout_scalar_valid_range_start]` attribute is just used to enable \ niche optimizations in libcore and will never be stable", ), rustc_attr!( - rustc_layout_scalar_valid_range_end, Whitelisted, template!(List: "value"), + rustc_layout_scalar_valid_range_end, AssumedUsed, template!(List: "value"), "the `#[rustc_layout_scalar_valid_range_end]` attribute is just used to enable \ niche optimizations in libcore and will never be stable", ), rustc_attr!( - rustc_nonnull_optimization_guaranteed, Whitelisted, template!(Word), + rustc_nonnull_optimization_guaranteed, AssumedUsed, template!(Word), "the `#[rustc_nonnull_optimization_guaranteed]` attribute is just used to enable \ niche optimizations in libcore and will never be stable", ), @@ -501,7 +501,7 @@ pub const BUILTIN_ATTRIBUTES: &[BuiltinAttribute] = &[ ), gated!( // Used in resolve: - prelude_import, Whitelisted, template!(Word), + prelude_import, AssumedUsed, template!(Word), "`#[prelude_import]` is for use by rustc only", ), gated!( @@ -509,7 +509,7 @@ pub const BUILTIN_ATTRIBUTES: &[BuiltinAttribute] = &[ "unboxed_closures are still evolving", ), rustc_attr!( - rustc_inherit_overflow_checks, Whitelisted, template!(Word), + rustc_inherit_overflow_checks, AssumedUsed, template!(Word), "the `#[rustc_inherit_overflow_checks]` attribute is just used to control \ overflow checking behavior of several libcore functions that are inlined \ across crates and will never be stable", @@ -540,42 +540,42 @@ pub const BUILTIN_ATTRIBUTES: &[BuiltinAttribute] = &[ rustc_attr!(TEST, rustc_layout, Normal, template!(List: "field1, field2, ...")), rustc_attr!(TEST, rustc_regions, Normal, template!(Word)), rustc_attr!( - TEST, rustc_error, Whitelisted, + TEST, rustc_error, AssumedUsed, template!(Word, List: "delay_span_bug_from_inside_query") ), - rustc_attr!(TEST, rustc_dump_user_substs, Whitelisted, template!(Word)), - rustc_attr!(TEST, rustc_if_this_changed, Whitelisted, template!(Word, List: "DepNode")), - rustc_attr!(TEST, rustc_then_this_would_need, Whitelisted, template!(List: "DepNode")), + rustc_attr!(TEST, rustc_dump_user_substs, AssumedUsed, template!(Word)), + rustc_attr!(TEST, rustc_if_this_changed, AssumedUsed, template!(Word, List: "DepNode")), + rustc_attr!(TEST, rustc_then_this_would_need, AssumedUsed, template!(List: "DepNode")), rustc_attr!( - TEST, rustc_dirty, Whitelisted, + TEST, rustc_dirty, AssumedUsed, template!(List: r#"cfg = "...", /*opt*/ label = "...", /*opt*/ except = "...""#), ), rustc_attr!( - TEST, rustc_clean, Whitelisted, + TEST, rustc_clean, AssumedUsed, template!(List: r#"cfg = "...", /*opt*/ label = "...", /*opt*/ except = "...""#), ), rustc_attr!( - TEST, rustc_partition_reused, Whitelisted, + TEST, rustc_partition_reused, AssumedUsed, template!(List: r#"cfg = "...", module = "...""#), ), rustc_attr!( - TEST, rustc_partition_codegened, Whitelisted, + TEST, rustc_partition_codegened, AssumedUsed, template!(List: r#"cfg = "...", module = "...""#), ), rustc_attr!( - TEST, rustc_expected_cgu_reuse, Whitelisted, + TEST, rustc_expected_cgu_reuse, AssumedUsed, template!(List: r#"cfg = "...", module = "...", kind = "...""#), ), - rustc_attr!(TEST, rustc_synthetic, Whitelisted, template!(Word)), - rustc_attr!(TEST, rustc_symbol_name, Whitelisted, template!(Word)), - rustc_attr!(TEST, rustc_def_path, Whitelisted, template!(Word)), - rustc_attr!(TEST, rustc_mir, Whitelisted, template!(List: "arg1, arg2, ...")), - rustc_attr!(TEST, rustc_dump_program_clauses, Whitelisted, template!(Word)), - rustc_attr!(TEST, rustc_dump_env_program_clauses, Whitelisted, template!(Word)), - rustc_attr!(TEST, rustc_object_lifetime_default, Whitelisted, template!(Word)), + rustc_attr!(TEST, rustc_synthetic, AssumedUsed, template!(Word)), + rustc_attr!(TEST, rustc_symbol_name, AssumedUsed, template!(Word)), + rustc_attr!(TEST, rustc_def_path, AssumedUsed, template!(Word)), + rustc_attr!(TEST, rustc_mir, AssumedUsed, template!(List: "arg1, arg2, ...")), + rustc_attr!(TEST, rustc_dump_program_clauses, AssumedUsed, template!(Word)), + rustc_attr!(TEST, rustc_dump_env_program_clauses, AssumedUsed, template!(Word)), + rustc_attr!(TEST, rustc_object_lifetime_default, AssumedUsed, template!(Word)), rustc_attr!(TEST, rustc_dummy, Normal, template!(Word /* doesn't matter*/)), gated!( - omit_gdb_pretty_printer_section, Whitelisted, template!(Word), + omit_gdb_pretty_printer_section, AssumedUsed, template!(Word), "the `#[omit_gdb_pretty_printer_section]` attribute is just used for the Rust test suite", ), ]; diff --git a/src/librustc_incremental/persist/dirty_clean.rs b/src/librustc_incremental/persist/dirty_clean.rs index 2ee95174dffe6..043aff90ce404 100644 --- a/src/librustc_incremental/persist/dirty_clean.rs +++ b/src/librustc_incremental/persist/dirty_clean.rs @@ -168,7 +168,7 @@ pub fn check_dirty_clean_annotations(tcx: TyCtxt<'_>) { // Note that we cannot use the existing "unused attribute"-infrastructure // here, since that is running before codegen. This is also the reason why - // all codegen-specific attributes are `Whitelisted` in rustc_ast::feature_gate. + // all codegen-specific attributes are `AssumedUsed` in rustc_ast::feature_gate. all_attrs.report_unchecked_attrs(&dirty_clean_visitor.checked_attrs); }) } diff --git a/src/librustc_interface/util.rs b/src/librustc_interface/util.rs index fe091e920627c..5f6f7ce04e950 100644 --- a/src/librustc_interface/util.rs +++ b/src/librustc_interface/util.rs @@ -38,8 +38,8 @@ use std::{panic, thread}; /// Adds `target_feature = "..."` cfgs for a variety of platform /// specific features (SSE, NEON etc.). /// -/// This is performed by checking whether a whitelisted set of -/// features is available on the target machine, by querying LLVM. +/// This is performed by checking whether a set of permitted features +/// is available on the target machine, by querying LLVM. pub fn add_configuration( cfg: &mut CrateConfig, sess: &mut Session, diff --git a/src/librustc_lint/unused.rs b/src/librustc_lint/unused.rs index c407f608a14c5..2431f7ba54b36 100644 --- a/src/librustc_lint/unused.rs +++ b/src/librustc_lint/unused.rs @@ -287,8 +287,8 @@ impl<'tcx> LateLintPass<'tcx> for UnusedAttributes { let attr_info = attr.ident().and_then(|ident| self.builtin_attributes.get(&ident.name)); if let Some(&&(name, ty, ..)) = attr_info { - if let AttributeType::Whitelisted = ty { - debug!("{:?} is Whitelisted", name); + if let AttributeType::AssumedUsed = ty { + debug!("{:?} is AssumedUsed", name); return; } } diff --git a/src/librustc_metadata/rmeta/decoder.rs b/src/librustc_metadata/rmeta/decoder.rs index 1ac16e0d31193..4746e53ce59a9 100644 --- a/src/librustc_metadata/rmeta/decoder.rs +++ b/src/librustc_metadata/rmeta/decoder.rs @@ -1386,9 +1386,6 @@ impl<'a, 'tcx> CrateMetadataRef<'a> { let constness = match self.kind(id) { EntryKind::AssocFn(data) => data.decode(self).fn_data.constness, EntryKind::Fn(data) => data.decode(self).constness, - // Some intrinsics can be const fn. While we could recompute this (at least until we - // stop having hardcoded whitelists and move to stability attributes), it seems cleaner - // to treat all const fns equally. EntryKind::ForeignFn(data) => data.decode(self).constness, EntryKind::Variant(..) | EntryKind::Struct(..) => hir::Constness::Const, _ => hir::Constness::NotConst, diff --git a/src/librustc_middle/lint.rs b/src/librustc_middle/lint.rs index bb62c1bb82428..3f0939239e85c 100644 --- a/src/librustc_middle/lint.rs +++ b/src/librustc_middle/lint.rs @@ -230,8 +230,9 @@ pub fn struct_lint_level<'s, 'd>( err.allow_suggestions(false); // If this is a future incompatible lint it'll become a hard error, so - // we have to emit *something*. Also allow lints to whitelist themselves - // on a case-by-case basis for emission in a foreign macro. + // we have to emit *something*. Also, if this lint occurs in the + // expansion of a macro from an external crate, allow individual lints + // to opt-out from being reported. if future_incompatible.is_none() && !lint.report_in_external_macro { err.cancel(); // Don't continue further, since we don't want to have diff --git a/src/librustc_middle/middle/lang_items.rs b/src/librustc_middle/middle/lang_items.rs index 0f98c338c16b1..70c90198276c1 100644 --- a/src/librustc_middle/middle/lang_items.rs +++ b/src/librustc_middle/middle/lang_items.rs @@ -42,19 +42,18 @@ impl<'tcx> TyCtxt<'tcx> { } } -/// Returns `true` if the specified `lang_item` doesn't actually need to be -/// present for this compilation. +/// Returns `true` if the specified `lang_item` must be present for this +/// compilation. /// /// Not all lang items are always required for each compilation, particularly in /// the case of panic=abort. In these situations some lang items are injected by /// crates and don't actually need to be defined in libstd. -pub fn whitelisted(tcx: TyCtxt<'_>, lang_item: LangItem) -> bool { +pub fn required(tcx: TyCtxt<'_>, lang_item: LangItem) -> bool { // If we're not compiling with unwinding, we won't actually need these // symbols. Other panic runtimes ensure that the relevant symbols are // available to link things together, but they're never exercised. - if tcx.sess.panic_strategy() != PanicStrategy::Unwind { - return lang_item == LangItem::EhPersonalityLangItem; + match tcx.sess.panic_strategy() { + PanicStrategy::Abort => lang_item != LangItem::EhPersonalityLangItem, + PanicStrategy::Unwind => true, } - - false } diff --git a/src/librustc_middle/query/mod.rs b/src/librustc_middle/query/mod.rs index 3285be555d30f..0faf389aa385c 100644 --- a/src/librustc_middle/query/mod.rs +++ b/src/librustc_middle/query/mod.rs @@ -1413,10 +1413,10 @@ rustc_queries! { } Other { - query target_features_whitelist(_: CrateNum) -> FxHashMap> { + query supported_target_features(_: CrateNum) -> FxHashMap> { storage(ArenaCacheSelector<'tcx>) eval_always - desc { "looking up the whitelist of target features" } + desc { "looking up supported target features" } } // Get an estimate of the size of an InstanceDef based on its MIR for CGU partitioning. diff --git a/src/librustc_mir/const_eval/fn_queries.rs b/src/librustc_mir/const_eval/fn_queries.rs index daa458f70f9a7..70ddd79ee40b0 100644 --- a/src/librustc_mir/const_eval/fn_queries.rs +++ b/src/librustc_mir/const_eval/fn_queries.rs @@ -88,7 +88,7 @@ pub fn is_parent_const_impl_raw(tcx: TyCtxt<'_>, hir_id: hir::HirId) -> bool { } /// Checks whether the function has a `const` modifier or, in case it is an intrinsic, whether -/// said intrinsic is on the whitelist for being const callable. +/// said intrinsic has a `rustc_const_{un,}stable` attribute. fn is_const_fn_raw(tcx: TyCtxt<'_>, def_id: DefId) -> bool { let hir_id = tcx.hir().as_local_hir_id(def_id.expect_local()); diff --git a/src/librustc_mir/interpret/validity.rs b/src/librustc_mir/interpret/validity.rs index ab836595a7acc..f95ac309424d0 100644 --- a/src/librustc_mir/interpret/validity.rs +++ b/src/librustc_mir/interpret/validity.rs @@ -45,7 +45,7 @@ macro_rules! throw_validation_failure { /// If $e throws an error matching the pattern, throw a validation failure. /// Other errors are passed back to the caller, unchanged -- and if they reach the root of /// the visitor, we make sure only validation errors and `InvalidProgram` errors are left. -/// This lets you use the patterns as a kind of validation whitelist, asserting which errors +/// This lets you use the patterns as a kind of validation list, asserting which errors /// can possibly happen: /// /// ``` diff --git a/src/librustc_passes/weak_lang_items.rs b/src/librustc_passes/weak_lang_items.rs index f2f07b5d4fb26..12925af8170f0 100644 --- a/src/librustc_passes/weak_lang_items.rs +++ b/src/librustc_passes/weak_lang_items.rs @@ -7,7 +7,7 @@ use rustc_hir::intravisit::{self, NestedVisitorMap, Visitor}; use rustc_hir::lang_items; use rustc_hir::lang_items::ITEM_REFS; use rustc_hir::weak_lang_items::WEAK_ITEMS_REFS; -use rustc_middle::middle::lang_items::whitelisted; +use rustc_middle::middle::lang_items::required; use rustc_middle::ty::TyCtxt; use rustc_session::config::CrateType; use rustc_span::symbol::sym; @@ -59,7 +59,7 @@ fn verify<'tcx>(tcx: TyCtxt<'tcx>, items: &lang_items::LanguageItems) { } for (name, &item) in WEAK_ITEMS_REFS.iter() { - if missing.contains(&item) && !whitelisted(tcx, item) && items.require(item).is_err() { + if missing.contains(&item) && required(tcx, item) && items.require(item).is_err() { if item == lang_items::PanicImplLangItem { tcx.sess.err("`#[panic_handler]` function required, but not found"); } else if item == lang_items::OomLangItem { diff --git a/src/librustc_resolve/late/lifetimes.rs b/src/librustc_resolve/late/lifetimes.rs index e9b917168d67b..1467bf537eb49 100644 --- a/src/librustc_resolve/late/lifetimes.rs +++ b/src/librustc_resolve/late/lifetimes.rs @@ -2122,7 +2122,7 @@ impl<'a, 'tcx> LifetimeContext<'a, 'tcx> { self.impl_self { match path.res { - // Whitelist the types that unambiguously always + // Permit the types that unambiguously always // result in the same type constructor being used // (it can't differ between `Self` and `self`). Res::Def(DefKind::Struct | DefKind::Union | DefKind::Enum, _) diff --git a/src/librustc_target/spec/tests/tests_impl.rs b/src/librustc_target/spec/tests/tests_impl.rs index b2ad62e1b260b..b2c2b8254d8f0 100644 --- a/src/librustc_target/spec/tests/tests_impl.rs +++ b/src/librustc_target/spec/tests/tests_impl.rs @@ -16,8 +16,8 @@ pub(super) fn test_target(target: TargetResult) { impl Target { fn check_consistency(&self) { // Check that LLD with the given flavor is treated identically to the linker it emulates. - // If you target really needs to deviate from the rules below, whitelist it - // and document the reasons. + // If your target really needs to deviate from the rules below, except it and document the + // reasons. assert_eq!( self.linker_flavor == LinkerFlavor::Msvc || self.linker_flavor == LinkerFlavor::Lld(LldFlavor::Link), diff --git a/src/librustc_target/spec/wasm32_base.rs b/src/librustc_target/spec/wasm32_base.rs index d4a65aa1a2574..8423573b52d51 100644 --- a/src/librustc_target/spec/wasm32_base.rs +++ b/src/librustc_target/spec/wasm32_base.rs @@ -40,14 +40,14 @@ pub fn options() -> TargetOptions { // corrupting static data. arg("--stack-first"); - // FIXME we probably shouldn't pass this but instead pass an explicit - // whitelist of symbols we'll allow to be undefined. We don't currently have - // a mechanism of knowing, however, which symbols are intended to be - // imported from the environment and which are intended to be imported from - // other objects linked elsewhere. This is a coarse approximation but is - // sure to hide some bugs and frustrate someone at some point, so we should - // ideally work towards a world where we can explicitly list symbols that - // are supposed to be imported and have all other symbols generate errors if + // FIXME we probably shouldn't pass this but instead pass an explicit list + // of symbols we'll allow to be undefined. We don't currently have a + // mechanism of knowing, however, which symbols are intended to be imported + // from the environment and which are intended to be imported from other + // objects linked elsewhere. This is a coarse approximation but is sure to + // hide some bugs and frustrate someone at some point, so we should ideally + // work towards a world where we can explicitly list symbols that are + // supposed to be imported and have all other symbols generate errors if // they remain undefined. arg("--allow-undefined"); diff --git a/src/librustc_trait_selection/traits/error_reporting/suggestions.rs b/src/librustc_trait_selection/traits/error_reporting/suggestions.rs index cdfe5f9f92db0..d677d84b2ba13 100644 --- a/src/librustc_trait_selection/traits/error_reporting/suggestions.rs +++ b/src/librustc_trait_selection/traits/error_reporting/suggestions.rs @@ -2139,7 +2139,7 @@ pub trait NextTypeParamName { impl NextTypeParamName for &[hir::GenericParam<'_>] { fn next_type_param_name(&self, name: Option<&str>) -> String { - // This is the whitelist of possible parameter names that we might suggest. + // This is the list of possible parameter names that we might suggest. let name = name.and_then(|n| n.chars().next()).map(|c| c.to_string().to_uppercase()); let name = name.as_deref(); let possible_names = [name.unwrap_or("T"), "T", "U", "V", "X", "Y", "Z", "A", "B", "C"]; diff --git a/src/librustc_typeck/check/demand.rs b/src/librustc_typeck/check/demand.rs index 85c073ca30034..9a9630f095886 100644 --- a/src/librustc_typeck/check/demand.rs +++ b/src/librustc_typeck/check/demand.rs @@ -236,7 +236,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { .tcx .get_attrs(m.def_id) .iter() - // This special internal attribute is used to whitelist + // This special internal attribute is used to permit // "identity-like" conversion methods to be suggested here. // // FIXME (#46459 and #46460): ideally diff --git a/src/librustc_typeck/check/expr.rs b/src/librustc_typeck/check/expr.rs index 1eaa5a6c31e20..e6b51f4c2cd2a 100644 --- a/src/librustc_typeck/check/expr.rs +++ b/src/librustc_typeck/check/expr.rs @@ -913,7 +913,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { if let ty::Adt(..) = rcvr_t.kind { // Try alternative arbitrary self types that could fulfill this call. // FIXME: probe for all types that *could* be arbitrary self-types, not - // just this whitelist. + // just this list. try_alt_rcvr(&mut err, self.tcx.mk_lang_item(rcvr_t, lang_items::OwnedBoxLangItem)); try_alt_rcvr(&mut err, self.tcx.mk_lang_item(rcvr_t, lang_items::PinTypeLangItem)); try_alt_rcvr(&mut err, self.tcx.mk_diagnostic_item(rcvr_t, sym::Arc)); @@ -1806,7 +1806,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { // If this is an input value, we require its type to be fully resolved // at this point. This allows us to provide helpful coercions which help - // pass the type whitelist in a later pass. + // pass the type candidate list in a later pass. // // We don't require output types to be resolved at this point, which // allows them to be inferred based on how they are used later in the diff --git a/src/librustc_typeck/collect.rs b/src/librustc_typeck/collect.rs index 4f88836118d52..15481660a5218 100644 --- a/src/librustc_typeck/collect.rs +++ b/src/librustc_typeck/collect.rs @@ -2150,7 +2150,7 @@ fn from_target_feature( tcx: TyCtxt<'_>, id: DefId, attr: &ast::Attribute, - whitelist: &FxHashMap>, + supported_target_features: &FxHashMap>, target_features: &mut Vec, ) { let list = match attr.meta_item_list() { @@ -2184,8 +2184,7 @@ fn from_target_feature( // We allow comma separation to enable multiple features. target_features.extend(value.as_str().split(',').filter_map(|feature| { - // Only allow whitelisted features per platform. - let feature_gate = match whitelist.get(feature) { + let feature_gate = match supported_target_features.get(feature) { Some(g) => g, None => { let msg = @@ -2196,7 +2195,7 @@ fn from_target_feature( format!("`{}` is not valid for this target", feature), ); if feature.starts_with('+') { - let valid = whitelist.contains_key(&feature[1..]); + let valid = supported_target_features.contains_key(&feature[1..]); if valid { err.help("consider removing the leading `+` in the feature name"); } @@ -2246,9 +2245,9 @@ fn linkage_by_name(tcx: TyCtxt<'_>, def_id: DefId, name: &str) -> Linkage { // Use the names from src/llvm/docs/LangRef.rst here. Most types are only // applicable to variable declarations and may not really make sense for - // Rust code in the first place but whitelist them anyway and trust that - // the user knows what s/he's doing. Who knows, unanticipated use cases - // may pop up in the future. + // Rust code in the first place but allow them anyway and trust that the + // user knows what s/he's doing. Who knows, unanticipated use cases may pop + // up in the future. // // ghost, dllimport, dllexport and linkonce_odr_autohide are not supported // and don't have to be, LLVM treats them as no-ops. @@ -2283,7 +2282,7 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, id: DefId) -> CodegenFnAttrs { codegen_fn_attrs.flags |= CodegenFnAttrFlags::TRACK_CALLER; } - let whitelist = tcx.target_features_whitelist(LOCAL_CRATE); + let supported_target_features = tcx.supported_target_features(LOCAL_CRATE); let mut inline_span = None; let mut link_ordinal_span = None; @@ -2386,7 +2385,13 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, id: DefId) -> CodegenFnAttrs { check_target_feature_trait_unsafe(tcx, local_id, attr.span); } } - from_target_feature(tcx, id, attr, &whitelist, &mut codegen_fn_attrs.target_features); + from_target_feature( + tcx, + id, + attr, + &supported_target_features, + &mut codegen_fn_attrs.target_features, + ); } else if attr.check_name(sym::linkage) { if let Some(val) = attr.value_str() { codegen_fn_attrs.linkage = Some(linkage_by_name(tcx, id, &val.as_str())); diff --git a/src/librustdoc/core.rs b/src/librustdoc/core.rs index db98ec5d0a72e..6dcb3b00070ca 100644 --- a/src/librustdoc/core.rs +++ b/src/librustdoc/core.rs @@ -225,7 +225,7 @@ pub fn new_handler( /// * Vector of tuples of lints' name and their associated "max" level /// * HashMap of lint id with their associated "max" level pub fn init_lints( - mut whitelisted_lints: Vec, + mut allowed_lints: Vec, lint_opts: Vec<(String, lint::Level)>, filter_call: F, ) -> (Vec<(String, lint::Level)>, FxHashMap) @@ -234,8 +234,8 @@ where { let warnings_lint_name = lint::builtin::WARNINGS.name; - whitelisted_lints.push(warnings_lint_name.to_owned()); - whitelisted_lints.extend(lint_opts.iter().map(|(lint, _)| lint).cloned()); + allowed_lints.push(warnings_lint_name.to_owned()); + allowed_lints.extend(lint_opts.iter().map(|(lint, _)| lint).cloned()); let lints = || { lint::builtin::HardwiredLints::get_lints() @@ -245,7 +245,7 @@ where let lint_opts = lints() .filter_map(|lint| { - // Whitelist feature-gated lints to avoid feature errors when trying to + // Permit feature-gated lints to avoid feature errors when trying to // allow all lints. if lint.name == warnings_lint_name || lint.feature_gate.is_some() { None @@ -258,9 +258,9 @@ where let lint_caps = lints() .filter_map(|lint| { - // We don't want to whitelist *all* lints so let's - // ignore those ones. - if whitelisted_lints.iter().any(|l| lint.name == l) { + // We don't want to allow *all* lints so let's ignore + // those ones. + if allowed_lints.iter().any(|l| lint.name == l) { None } else { Some((lint::LintId::of(lint), lint::Allow)) @@ -317,9 +317,9 @@ pub fn run_core(options: RustdocOptions) -> (clean::Crate, RenderInfo, RenderOpt let no_crate_level_docs = rustc_lint::builtin::MISSING_CRATE_LEVEL_DOCS.name; let invalid_codeblock_attribute_name = rustc_lint::builtin::INVALID_CODEBLOCK_ATTRIBUTES.name; - // In addition to those specific lints, we also need to whitelist those given through + // In addition to those specific lints, we also need to allow those given through // command line, otherwise they'll get ignored and we don't want that. - let whitelisted_lints = vec![ + let allowed_lints = vec![ intra_link_resolution_failure_name.to_owned(), missing_docs.to_owned(), missing_doc_example.to_owned(), @@ -328,7 +328,7 @@ pub fn run_core(options: RustdocOptions) -> (clean::Crate, RenderInfo, RenderOpt invalid_codeblock_attribute_name.to_owned(), ]; - let (lint_opts, lint_caps) = init_lints(whitelisted_lints, lint_opts, |lint| { + let (lint_opts, lint_caps) = init_lints(allowed_lints, lint_opts, |lint| { if lint.name == intra_link_resolution_failure_name || lint.name == invalid_codeblock_attribute_name { diff --git a/src/librustdoc/html/render.rs b/src/librustdoc/html/render.rs index f769a0920d16b..8bba21a2e7ace 100644 --- a/src/librustdoc/html/render.rs +++ b/src/librustdoc/html/render.rs @@ -3151,7 +3151,7 @@ fn item_enum(w: &mut Buffer, cx: &Context, it: &clean::Item, e: &clean::Enum) { render_assoc_items(w, cx, it, it.def_id, AssocItemRender::All) } -const ATTRIBUTE_WHITELIST: &[Symbol] = &[ +const ALLOWED_ATTRIBUTES: &[Symbol] = &[ sym::export_name, sym::lang, sym::link_section, @@ -3173,7 +3173,7 @@ fn render_attributes(w: &mut Buffer, it: &clean::Item, top: bool) { let mut attrs = String::new(); for attr in &it.attrs.other_attrs { - if !ATTRIBUTE_WHITELIST.contains(&attr.name_or_empty()) { + if !ALLOWED_ATTRIBUTES.contains(&attr.name_or_empty()) { continue; } diff --git a/src/librustdoc/test.rs b/src/librustdoc/test.rs index b40a5ef595009..c2d644bdd05f1 100644 --- a/src/librustdoc/test.rs +++ b/src/librustdoc/test.rs @@ -47,11 +47,11 @@ pub fn run(options: Options) -> Result<(), String> { let invalid_codeblock_attribute_name = rustc_lint::builtin::INVALID_CODEBLOCK_ATTRIBUTES.name; - // In addition to those specific lints, we also need to whitelist those given through + // In addition to those specific lints, we also need to allow those given through // command line, otherwise they'll get ignored and we don't want that. - let whitelisted_lints = vec![invalid_codeblock_attribute_name.to_owned()]; + let allowed_lints = vec![invalid_codeblock_attribute_name.to_owned()]; - let (lint_opts, lint_caps) = init_lints(whitelisted_lints, options.lint_opts.clone(), |lint| { + let (lint_opts, lint_caps) = init_lints(allowed_lints, options.lint_opts.clone(), |lint| { if lint.name == invalid_codeblock_attribute_name { None } else { diff --git a/src/libstd/time.rs b/src/libstd/time.rs index 84fa35e01bb09..9f4fa89cd5506 100644 --- a/src/libstd/time.rs +++ b/src/libstd/time.rs @@ -241,7 +241,7 @@ impl Instant { // returned instead of what the OS says if the OS goes backwards. // // To hopefully mitigate the impact of this, a few platforms are - // whitelisted as "these at least haven't gone backwards yet". + // excluded as "these at least haven't gone backwards yet". if time::Instant::actually_monotonic() { return Instant(os_now); } diff --git a/src/test/run-make-fulldeps/hotplug_codegen_backend/the_backend.rs b/src/test/run-make-fulldeps/hotplug_codegen_backend/the_backend.rs index efc62361694a5..dd49ca67c6748 100644 --- a/src/test/run-make-fulldeps/hotplug_codegen_backend/the_backend.rs +++ b/src/test/run-make-fulldeps/hotplug_codegen_backend/the_backend.rs @@ -52,7 +52,7 @@ impl CodegenBackend for TheBackend { fn provide(&self, providers: &mut Providers) { rustc_symbol_mangling::provide(providers); - providers.target_features_whitelist = |tcx, _cnum| { + providers.supported_target_features = |tcx, _cnum| { Default::default() // Just a dummy }; providers.is_reachable_non_generic = |_tcx, _defid| true; diff --git a/src/test/run-make-fulldeps/sysroot-crates-are-unstable/test.py b/src/test/run-make-fulldeps/sysroot-crates-are-unstable/test.py index 927edff4c22a5..f479bdabb9c0c 100644 --- a/src/test/run-make-fulldeps/sysroot-crates-are-unstable/test.py +++ b/src/test/run-make-fulldeps/sysroot-crates-are-unstable/test.py @@ -5,7 +5,7 @@ from subprocess import PIPE, Popen -# This is a whitelist of files which are stable crates or simply are not crates, +# This is n list of files which are stable crates or simply are not crates, # we don't check for the instability of these crates as they're all stable! STABLE_CRATES = ['std', 'alloc', 'core', 'proc_macro', 'rsbegin.o', 'rsend.o', 'dllcrt2.o', 'crt2.o', 'clang_rt'] diff --git a/src/test/ui-fulldeps/auxiliary/issue-40001-plugin.rs b/src/test/ui-fulldeps/auxiliary/issue-40001-plugin.rs index 9ba2675477878..4e9d4d342734c 100644 --- a/src/test/ui-fulldeps/auxiliary/issue-40001-plugin.rs +++ b/src/test/ui-fulldeps/auxiliary/issue-40001-plugin.rs @@ -21,19 +21,19 @@ use rustc_span::source_map; #[plugin_registrar] pub fn plugin_registrar(reg: &mut Registry) { - reg.lint_store.register_lints(&[&MISSING_WHITELISTED_ATTR]); - reg.lint_store.register_late_pass(|| box MissingWhitelistedAttrPass); + reg.lint_store.register_lints(&[&MISSING_ALLOWED_ATTR]); + reg.lint_store.register_late_pass(|| box MissingAllowedAttrPass); } declare_lint! { - MISSING_WHITELISTED_ATTR, + MISSING_ALLOWED_ATTR, Deny, - "Checks for missing `whitelisted_attr` attribute" + "Checks for missing `allowed_attr` attribute" } -declare_lint_pass!(MissingWhitelistedAttrPass => [MISSING_WHITELISTED_ATTR]); +declare_lint_pass!(MissingAllowedAttrPass => [MISSING_ALLOWED_ATTR]); -impl<'tcx> LateLintPass<'tcx> for MissingWhitelistedAttrPass { +impl<'tcx> LateLintPass<'tcx> for MissingAllowedAttrPass { fn check_fn( &mut self, cx: &LateContext<'tcx>, @@ -48,10 +48,10 @@ impl<'tcx> LateLintPass<'tcx> for MissingWhitelistedAttrPass { _ => cx.tcx.hir().expect_item(cx.tcx.hir().get_parent_item(id)), }; - let whitelisted = |attr| pprust::attribute_to_string(attr).contains("whitelisted_attr"); - if !item.attrs.iter().any(whitelisted) { - cx.lint(MISSING_WHITELISTED_ATTR, |lint| { - lint.build("Missing 'whitelisted_attr' attribute").set_span(span).emit() + let allowed = |attr| pprust::attribute_to_string(attr).contains("allowed_attr"); + if !item.attrs.iter().any(allowed) { + cx.lint(MISSING_ALLOWED_ATTR, |lint| { + lint.build("Missing 'allowed_attr' attribute").set_span(span).emit() }); } } diff --git a/src/test/ui-fulldeps/issue-40001.rs b/src/test/ui-fulldeps/issue-40001.rs index c3f98197250d1..e14338fdbbf35 100644 --- a/src/test/ui-fulldeps/issue-40001.rs +++ b/src/test/ui-fulldeps/issue-40001.rs @@ -6,5 +6,5 @@ #![plugin(issue_40001_plugin)] //~ WARNING compiler plugins are deprecated #![register_tool(plugin)] -#[plugin::whitelisted_attr] +#[plugin::allowed_attr] fn main() {} diff --git a/src/test/ui/asm/type-check-3.rs b/src/test/ui/asm/type-check-3.rs index 5de15fe49067a..0f803eff17b8a 100644 --- a/src/test/ui/asm/type-check-3.rs +++ b/src/test/ui/asm/type-check-3.rs @@ -7,7 +7,7 @@ use std::arch::x86_64::{_mm256_setzero_ps, _mm_setzero_ps}; fn main() { unsafe { - // Types must be in the whitelist for the register class + // Types must be listed in the register class. asm!("{}", in(reg) 0i128); //~^ ERROR type `i128` cannot be used with this register class diff --git a/src/test/ui/rfc-2126-extern-absolute-paths/meta.rs b/src/test/ui/rfc-2126-extern-absolute-paths/meta.rs index b3b9aeb8028e1..1fb5878ca2ace 100644 --- a/src/test/ui/rfc-2126-extern-absolute-paths/meta.rs +++ b/src/test/ui/rfc-2126-extern-absolute-paths/meta.rs @@ -1,7 +1,7 @@ // edition:2018 -// Tests that `meta` is whitelisted, even if the crate doesn't exist -// yet (i.e., it causes a different error than `not-whitelisted.rs`). +// Tests that `meta` is allowed, even if the crate doesn't exist +// yet (i.e., it causes a different error than `not-allowed.rs`). use meta; //~ ERROR can't find crate for `meta` fn main() {} diff --git a/src/test/ui/rfc-2126-extern-absolute-paths/not-whitelisted.rs b/src/test/ui/rfc-2126-extern-absolute-paths/not-allowed.rs similarity index 100% rename from src/test/ui/rfc-2126-extern-absolute-paths/not-whitelisted.rs rename to src/test/ui/rfc-2126-extern-absolute-paths/not-allowed.rs diff --git a/src/test/ui/rfc-2126-extern-absolute-paths/not-whitelisted.stderr b/src/test/ui/rfc-2126-extern-absolute-paths/not-allowed.stderr similarity index 86% rename from src/test/ui/rfc-2126-extern-absolute-paths/not-whitelisted.stderr rename to src/test/ui/rfc-2126-extern-absolute-paths/not-allowed.stderr index f324378d4ca68..6d2b4508a0592 100644 --- a/src/test/ui/rfc-2126-extern-absolute-paths/not-whitelisted.stderr +++ b/src/test/ui/rfc-2126-extern-absolute-paths/not-allowed.stderr @@ -1,5 +1,5 @@ error[E0432]: unresolved import `alloc` - --> $DIR/not-whitelisted.rs:5:5 + --> $DIR/not-allowed.rs:5:5 | LL | use alloc; | ^^^^^ no `alloc` external crate diff --git a/src/test/ui/sse2.rs b/src/test/ui/sse2.rs index 74f112464c75d..7726972b95b64 100644 --- a/src/test/ui/sse2.rs +++ b/src/test/ui/sse2.rs @@ -20,7 +20,7 @@ fn main() { assert!(cfg!(target_feature = "sse2"), "SSE2 was not detected as available on an x86 platform"); } - // check a negative case too -- whitelisted on x86, but not enabled by default + // check a negative case too -- allowed on x86, but not enabled by default assert!(cfg!(not(target_feature = "avx2")), "AVX2 shouldn't be detected as available by default on any platform"); } diff --git a/src/tools/clippy/clippy_lints/src/attrs.rs b/src/tools/clippy/clippy_lints/src/attrs.rs index 2505ff32fe523..3f7d6ba646770 100644 --- a/src/tools/clippy/clippy_lints/src/attrs.rs +++ b/src/tools/clippy/clippy_lints/src/attrs.rs @@ -72,7 +72,7 @@ declare_clippy_lint! { /// **What it does:** Checks for `extern crate` and `use` items annotated with /// lint attributes. /// - /// This lint whitelists `#[allow(unused_imports)]`, `#[allow(deprecated)]` and + /// This lint permits `#[allow(unused_imports)]`, `#[allow(deprecated)]` and /// `#[allow(unreachable_pub)]` on `use` items and `#[allow(unused_imports)]` on /// `extern crate` items with a `#[macro_use]` attribute. /// @@ -294,7 +294,7 @@ impl<'tcx> LateLintPass<'tcx> for Attributes { if let Some(ident) = attr.ident() { match &*ident.as_str() { "allow" | "warn" | "deny" | "forbid" => { - // whitelist `unused_imports`, `deprecated` and `unreachable_pub` for `use` items + // permit `unused_imports`, `deprecated` and `unreachable_pub` for `use` items // and `unused_imports` for `extern crate` items with `macro_use` for lint in lint_list { match item.kind { diff --git a/src/tools/clippy/clippy_lints/src/eq_op.rs b/src/tools/clippy/clippy_lints/src/eq_op.rs index ca921dcfdfe92..cbc93d772dd91 100644 --- a/src/tools/clippy/clippy_lints/src/eq_op.rs +++ b/src/tools/clippy/clippy_lints/src/eq_op.rs @@ -16,7 +16,7 @@ declare_clippy_lint! { /// **Known problems:** False negatives: We had some false positives regarding /// calls (notably [racer](https://github.com/phildawes/racer) had one instance /// of `x.pop() && x.pop()`), so we removed matching any function or method - /// calls. We may introduce a whitelist of known pure functions in the future. + /// calls. We may introduce a list of known pure functions in the future. /// /// **Example:** /// ```rust diff --git a/src/tools/clippy/clippy_lints/src/needless_pass_by_value.rs b/src/tools/clippy/clippy_lints/src/needless_pass_by_value.rs index 5d47f9425e3ef..29e5d4d166498 100644 --- a/src/tools/clippy/clippy_lints/src/needless_pass_by_value.rs +++ b/src/tools/clippy/clippy_lints/src/needless_pass_by_value.rs @@ -100,7 +100,7 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessPassByValue { // Allow `Borrow` or functions to be taken by value let borrow_trait = need!(get_trait_def_id(cx, &paths::BORROW_TRAIT)); - let whitelisted_traits = [ + let allowed_traits = [ need!(cx.tcx.lang_items().fn_trait()), need!(cx.tcx.lang_items().fn_once_trait()), need!(cx.tcx.lang_items().fn_mut_trait()), @@ -184,7 +184,7 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessPassByValue { if !is_self(arg); if !ty.is_mutable_ptr(); if !is_copy(cx, ty); - if !whitelisted_traits.iter().any(|&t| implements_trait(cx, ty, t, &[])); + if !allowed_traits.iter().any(|&t| implements_trait(cx, ty, t, &[])); if !implements_borrow_trait; if !all_borrowable_trait; diff --git a/src/tools/clippy/clippy_lints/src/non_expressive_names.rs b/src/tools/clippy/clippy_lints/src/non_expressive_names.rs index 5f14fe97afefa..7128fee9bcf51 100644 --- a/src/tools/clippy/clippy_lints/src/non_expressive_names.rs +++ b/src/tools/clippy/clippy_lints/src/non_expressive_names.rs @@ -78,7 +78,7 @@ struct ExistingName { interned: SymbolStr, span: Span, len: usize, - whitelist: &'static [&'static str], + exemptions: &'static [&'static str], } struct SimilarNamesLocalVisitor<'a, 'tcx> { @@ -117,7 +117,7 @@ impl<'a, 'tcx> SimilarNamesLocalVisitor<'a, 'tcx> { // this list contains lists of names that are allowed to be similar // the assumption is that no name is ever contained in multiple lists. #[rustfmt::skip] -const WHITELIST: &[&[&str]] = &[ +const ALLOWED_TO_BE_SIMILAR: &[&[&str]] = &[ &["parsed", "parser"], &["lhs", "rhs"], &["tx", "rx"], @@ -156,17 +156,17 @@ impl<'a, 'tcx, 'b> Visitor<'tcx> for SimilarNamesNameVisitor<'a, 'tcx, 'b> { } #[must_use] -fn get_whitelist(interned_name: &str) -> Option<&'static [&'static str]> { - for &allow in WHITELIST { - if whitelisted(interned_name, allow) { - return Some(allow); +fn get_exemptions(interned_name: &str) -> Option<&'static [&'static str]> { + for &list in ALLOWED_TO_BE_SIMILAR { + if allowed_to_be_similar(interned_name, list) { + return Some(list); } } None } #[must_use] -fn whitelisted(interned_name: &str, list: &[&str]) -> bool { +fn allowed_to_be_similar(interned_name: &str, list: &[&str]) -> bool { list.iter() .any(|&name| interned_name.starts_with(name) || interned_name.ends_with(name)) } @@ -212,7 +212,7 @@ impl<'a, 'tcx, 'b> SimilarNamesNameVisitor<'a, 'tcx, 'b> { return; } for existing_name in &self.0.names { - if whitelisted(&interned_name, existing_name.whitelist) { + if allowed_to_be_similar(&interned_name, existing_name.exemptions) { continue; } let mut split_at = None; @@ -301,7 +301,7 @@ impl<'a, 'tcx, 'b> SimilarNamesNameVisitor<'a, 'tcx, 'b> { return; } self.0.names.push(ExistingName { - whitelist: get_whitelist(&interned_name).unwrap_or(&[]), + exemptions: get_exemptions(&interned_name).unwrap_or(&[]), interned: interned_name, span: ident.span, len: count, diff --git a/src/tools/clippy/clippy_lints/src/precedence.rs b/src/tools/clippy/clippy_lints/src/precedence.rs index 7dce23dd22306..23793678fa0e2 100644 --- a/src/tools/clippy/clippy_lints/src/precedence.rs +++ b/src/tools/clippy/clippy_lints/src/precedence.rs @@ -5,7 +5,7 @@ use rustc_lint::{EarlyContext, EarlyLintPass}; use rustc_session::{declare_lint_pass, declare_tool_lint}; use rustc_span::source_map::Spanned; -const ODD_FUNCTIONS_WHITELIST: [&str; 14] = [ +const ALLOWED_ODD_FUNCTIONS: [&str; 14] = [ "asin", "asinh", "atan", @@ -109,7 +109,7 @@ impl EarlyLintPass for Precedence { if let ExprKind::Lit(ref lit) = slf.kind { match lit.kind { LitKind::Int(..) | LitKind::Float(..) => { - if ODD_FUNCTIONS_WHITELIST + if ALLOWED_ODD_FUNCTIONS .iter() .any(|odd_function| **odd_function == *path_segment_str) { diff --git a/src/tools/clippy/clippy_lints/src/types.rs b/src/tools/clippy/clippy_lints/src/types.rs index b1345f0de5e4b..68f51f0afdccd 100644 --- a/src/tools/clippy/clippy_lints/src/types.rs +++ b/src/tools/clippy/clippy_lints/src/types.rs @@ -1256,7 +1256,7 @@ fn check_loss_of_sign(cx: &LateContext<'_>, expr: &Expr<'_>, op: &Expr<'_>, cast // don't lint for the result of methods that always return non-negative values if let ExprKind::MethodCall(ref path, _, _, _) = op.kind { let mut method_name = path.ident.name.as_str(); - let whitelisted_methods = ["abs", "checked_abs", "rem_euclid", "checked_rem_euclid"]; + let allowed_methods = ["abs", "checked_abs", "rem_euclid", "checked_rem_euclid"]; if_chain! { if method_name == "unwrap"; @@ -1267,7 +1267,7 @@ fn check_loss_of_sign(cx: &LateContext<'_>, expr: &Expr<'_>, op: &Expr<'_>, cast } } - if whitelisted_methods.iter().any(|&name| method_name == name) { + if allowed_methods.iter().any(|&name| method_name == name) { return; } } diff --git a/src/tools/clippy/tests/ui/crashes/whitelist/clippy.toml b/src/tools/clippy/tests/ui/crashes/third-party/clippy.toml similarity index 100% rename from src/tools/clippy/tests/ui/crashes/whitelist/clippy.toml rename to src/tools/clippy/tests/ui/crashes/third-party/clippy.toml diff --git a/src/tools/clippy/tests/ui/crashes/whitelist/conf_whitelisted.rs b/src/tools/clippy/tests/ui/crashes/third-party/conf_allowlisted.rs similarity index 100% rename from src/tools/clippy/tests/ui/crashes/whitelist/conf_whitelisted.rs rename to src/tools/clippy/tests/ui/crashes/third-party/conf_allowlisted.rs diff --git a/src/tools/clippy/tests/ui/needless_pass_by_value.rs b/src/tools/clippy/tests/ui/needless_pass_by_value.rs index e93a7fe2985b3..7a9ba55590dce 100644 --- a/src/tools/clippy/tests/ui/needless_pass_by_value.rs +++ b/src/tools/clippy/tests/ui/needless_pass_by_value.rs @@ -116,7 +116,7 @@ extern "C" fn ext(x: MaybeUninit) -> usize { unsafe { x.assume_init() } } -// whitelist RangeArgument +// exempt RangeArgument fn range>(range: T) { let _ = range.start_bound(); } diff --git a/src/tools/clippy/tests/ui/neg_cmp_op_on_partial_ord.rs b/src/tools/clippy/tests/ui/neg_cmp_op_on_partial_ord.rs index ca70e3b7148ef..0b47119527247 100644 --- a/src/tools/clippy/tests/ui/neg_cmp_op_on_partial_ord.rs +++ b/src/tools/clippy/tests/ui/neg_cmp_op_on_partial_ord.rs @@ -57,6 +57,6 @@ fn main() { // The macro always negates the result of the given comparison in its // internal check which automatically triggered the lint. As it's an // external macro there was no chance to do anything about it which led - // to a whitelisting of all external macros. + // to an exempting of all external macros. assert!(a_value < another_value); } diff --git a/src/tools/linkchecker/main.rs b/src/tools/linkchecker/main.rs index 9e4e2c433fbed..74601f9e4c679 100644 --- a/src/tools/linkchecker/main.rs +++ b/src/tools/linkchecker/main.rs @@ -11,8 +11,8 @@ //! These values are then translated to file URLs if possible and then the //! destination is asserted to exist. //! -//! A few whitelisted exceptions are allowed as there's known bugs in rustdoc, -//! but this should catch the majority of "broken link" cases. +//! A few exceptions are allowed as there's known bugs in rustdoc, but this +//! should catch the majority of "broken link" cases. use std::collections::hash_map::Entry; use std::collections::{HashMap, HashSet}; @@ -118,7 +118,7 @@ fn check(cache: &mut Cache, root: &Path, file: &Path, errors: &mut bool) -> Opti } // Unfortunately we're not 100% full of valid links today to we need a few - // whitelists to get this past `make check` today. + // exceptions to get this past `make check` today. // FIXME(#32129) if file.ends_with("std/io/struct.IoSlice.html") || file.ends_with("std/string/struct.String.html") diff --git a/src/tools/tidy/src/cargo.rs b/src/tools/tidy/src/cargo.rs index 7c45efba5ea08..7bdd78a91e7de 100644 --- a/src/tools/tidy/src/cargo.rs +++ b/src/tools/tidy/src/cargo.rs @@ -73,8 +73,8 @@ fn verify(tomlfile: &Path, libfile: &Path, bad: &mut bool) { // This is intentional -- this dependency just makes the crate available // for others later on. - let whitelisted = krate.starts_with("panic"); - if toml.contains("name = \"std\"") && whitelisted { + let allowed = krate.starts_with("panic"); + if toml.contains("name = \"std\"") && allowed { continue; } diff --git a/src/tools/tidy/src/deps.rs b/src/tools/tidy/src/deps.rs index 4622e15a1cae8..b7d3d428cd283 100644 --- a/src/tools/tidy/src/deps.rs +++ b/src/tools/tidy/src/deps.rs @@ -49,14 +49,14 @@ const EXCEPTIONS: &[(&str, &str)] = &[ /// these and all their dependencies *must not* be in the exception list. const RUNTIME_CRATES: &[&str] = &["std", "core", "alloc", "test", "panic_abort", "panic_unwind"]; -/// Which crates to check against the whitelist? -const WHITELIST_CRATES: &[&str] = &["rustc_middle", "rustc_codegen_llvm"]; +/// Crates whose dependencies must be explicitly permitted. +const RESTRICTED_DEPENDENCY_CRATES: &[&str] = &["rustc_middle", "rustc_codegen_llvm"]; -/// Whitelist of crates rustc is allowed to depend on. Avoid adding to the list if possible. +/// Crates rustc is allowed to depend on. Avoid adding to the list if possible. /// /// This list is here to provide a speed-bump to adding a new dependency to /// rustc. Please check with the compiler team before adding an entry. -const WHITELIST: &[&str] = &[ +const PERMITTED_DEPENDENCIES: &[&str] = &[ "adler32", "aho-corasick", "annotate-snippets", @@ -190,7 +190,7 @@ pub fn check(path: &Path, cargo: &Path, bad: &mut bool) { .features(cargo_metadata::CargoOpt::AllFeatures); let metadata = t!(cmd.exec()); check_exceptions(&metadata, bad); - check_whitelist(&metadata, bad); + check_dependencies(&metadata, bad); check_crate_duplicate(&metadata, bad); } @@ -272,36 +272,37 @@ fn check_exceptions(metadata: &Metadata, bad: &mut bool) { } } -/// Checks the dependency of `WHITELIST_CRATES` at the given path. Changes `bad` to `true` if a -/// check failed. +/// Checks the dependency of `RESTRICTED_DEPENDENCY_CRATES` at the given path. Changes `bad` to +/// `true` if a check failed. /// -/// Specifically, this checks that the dependencies are on the `WHITELIST`. -fn check_whitelist(metadata: &Metadata, bad: &mut bool) { - // Check that the WHITELIST does not have unused entries. - for name in WHITELIST { +/// Specifically, this checks that the dependencies are on the `PERMITTED_DEPENDENCIES`. +fn check_dependencies(metadata: &Metadata, bad: &mut bool) { + // Check that the PERMITTED_DEPENDENCIES does not have unused entries. + for name in PERMITTED_DEPENDENCIES { if !metadata.packages.iter().any(|p| p.name == *name) { println!( - "could not find whitelisted package `{}`\n\ - Remove from WHITELIST list if it is no longer used.", + "could not find allowed package `{}`\n\ + Remove from PERMITTED_DEPENDENCIES list if it is no longer used.", name ); *bad = true; } } - // Get the whitelist in a convenient form. - let whitelist: HashSet<_> = WHITELIST.iter().cloned().collect(); + // Get the list in a convenient form. + let permitted_dependencies: HashSet<_> = PERMITTED_DEPENDENCIES.iter().cloned().collect(); // Check dependencies. let mut visited = BTreeSet::new(); let mut unapproved = BTreeSet::new(); - for &krate in WHITELIST_CRATES.iter() { + for &krate in RESTRICTED_DEPENDENCY_CRATES.iter() { let pkg = pkg_from_name(metadata, krate); - let mut bad = check_crate_whitelist(&whitelist, metadata, &mut visited, pkg); + let mut bad = + check_crate_dependencies(&permitted_dependencies, metadata, &mut visited, pkg); unapproved.append(&mut bad); } if !unapproved.is_empty() { - println!("Dependencies not on the whitelist:"); + println!("Dependencies not explicitly permitted:"); for dep in unapproved { println!("* {}", dep); } @@ -310,9 +311,9 @@ fn check_whitelist(metadata: &Metadata, bad: &mut bool) { } /// Checks the dependencies of the given crate from the given cargo metadata to see if they are on -/// the whitelist. Returns a list of illegal dependencies. -fn check_crate_whitelist<'a>( - whitelist: &'a HashSet<&'static str>, +/// the list of permitted dependencies. Returns a list of disallowed dependencies. +fn check_crate_dependencies<'a>( + permitted_dependencies: &'a HashSet<&'static str>, metadata: &'a Metadata, visited: &mut BTreeSet<&'a PackageId>, krate: &'a Package, @@ -327,10 +328,10 @@ fn check_crate_whitelist<'a>( visited.insert(&krate.id); - // If this path is in-tree, we don't require it to be on the whitelist. + // If this path is in-tree, we don't require it to be explicitly permitted. if krate.source.is_some() { - // If this dependency is not on `WHITELIST`, add to bad set. - if !whitelist.contains(krate.name.as_str()) { + // If this dependency is not on `PERMITTED_DEPENDENCIES`, add to bad set. + if !permitted_dependencies.contains(krate.name.as_str()) { unapproved.insert(&krate.id); } } @@ -339,7 +340,7 @@ fn check_crate_whitelist<'a>( let to_check = deps_of(metadata, &krate.id); for dep in to_check { - let mut bad = check_crate_whitelist(whitelist, metadata, visited, dep); + let mut bad = check_crate_dependencies(permitted_dependencies, metadata, visited, dep); unapproved.append(&mut bad); } diff --git a/src/tools/tidy/src/error_codes_check.rs b/src/tools/tidy/src/error_codes_check.rs index f7fd0c670d704..3af71f69d2457 100644 --- a/src/tools/tidy/src/error_codes_check.rs +++ b/src/tools/tidy/src/error_codes_check.rs @@ -7,7 +7,7 @@ use std::fs::read_to_string; use std::path::Path; // A few of those error codes can't be tested but all the others can and *should* be tested! -const WHITELIST: &[&str] = &[ +const EXEMPTED_FROM_TEST: &[&str] = &[ "E0183", "E0227", "E0279", "E0280", "E0311", "E0313", "E0314", "E0315", "E0377", "E0456", "E0461", "E0462", "E0464", "E0465", "E0472", "E0473", "E0474", "E0475", "E0476", "E0479", "E0480", "E0481", "E0482", "E0483", "E0484", "E0485", "E0486", "E0487", "E0488", "E0489", @@ -166,7 +166,7 @@ pub fn check(path: &Path, bad: &mut bool) { println!("Found {} error codes", error_codes.len()); for (err_code, nb) in &error_codes { - if !*nb && !WHITELIST.contains(&err_code.as_str()) { + if !*nb && !EXEMPTED_FROM_TEST.contains(&err_code.as_str()) { errors.push(format!("Error code {} needs to have at least one UI test!", err_code)); } } diff --git a/src/tools/tidy/src/extdeps.rs b/src/tools/tidy/src/extdeps.rs index e3f92d4806152..4d666a502a160 100644 --- a/src/tools/tidy/src/extdeps.rs +++ b/src/tools/tidy/src/extdeps.rs @@ -3,8 +3,8 @@ use std::fs; use std::path::Path; -/// List of whitelisted sources for packages. -const WHITELISTED_SOURCES: &[&str] = &["\"registry+https://github.com/rust-lang/crates.io-index\""]; +/// List of allowed sources for packages. +const ALLOWED_SOURCES: &[&str] = &["\"registry+https://github.com/rust-lang/crates.io-index\""]; /// Checks for external package sources. pub fn check(path: &Path, bad: &mut bool) { @@ -24,8 +24,8 @@ pub fn check(path: &Path, bad: &mut bool) { // Extract source value. let source = line.splitn(2, '=').nth(1).unwrap().trim(); - // Ensure source is whitelisted. - if !WHITELISTED_SOURCES.contains(&&*source) { + // Ensure source is allowed. + if !ALLOWED_SOURCES.contains(&&*source) { println!("invalid source: {}", source); *bad = true; } From a1a19cbbe1c17dc03ca689db002181c9bd95f529 Mon Sep 17 00:00:00 2001 From: Jon Gjengset Date: Fri, 10 Jul 2020 09:23:52 -0400 Subject: [PATCH 35/35] Add tracking issue --- src/liballoc/collections/vec_deque.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/liballoc/collections/vec_deque.rs b/src/liballoc/collections/vec_deque.rs index 4efa7ef6f5e9d..2efb94e8afe57 100644 --- a/src/liballoc/collections/vec_deque.rs +++ b/src/liballoc/collections/vec_deque.rs @@ -1127,7 +1127,7 @@ impl VecDeque { /// assert_eq!(all.len(), 3); /// ``` #[inline] - #[unstable(feature = "deque_range", issue = "none")] + #[unstable(feature = "deque_range", issue = "74217")] pub fn range(&self, range: R) -> Iter<'_, T> where R: RangeBounds, @@ -1170,7 +1170,7 @@ impl VecDeque { /// assert_eq!(v, vec![2, 4, 12]); /// ``` #[inline] - #[unstable(feature = "deque_range", issue = "none")] + #[unstable(feature = "deque_range", issue = "74217")] pub fn range_mut(&mut self, range: R) -> IterMut<'_, T> where R: RangeBounds,