diff --git a/compiler/rustc_expand/src/mbe/macro_rules.rs b/compiler/rustc_expand/src/mbe/macro_rules.rs
index a255b4f83acbe..8b68c94e61a38 100644
--- a/compiler/rustc_expand/src/mbe/macro_rules.rs
+++ b/compiler/rustc_expand/src/mbe/macro_rules.rs
@@ -18,7 +18,9 @@ use rustc_data_structures::fx::FxHashMap;
use rustc_data_structures::sync::Lrc;
use rustc_errors::{Applicability, DiagnosticBuilder};
use rustc_feature::Features;
-use rustc_lint_defs::builtin::{OR_PATTERNS_BACK_COMPAT, SEMICOLON_IN_EXPRESSIONS_FROM_MACROS};
+use rustc_lint_defs::builtin::{
+ RUST_2021_INCOMPATIBLE_OR_PATTERNS, SEMICOLON_IN_EXPRESSIONS_FROM_MACROS,
+};
use rustc_lint_defs::BuiltinLintDiagnostics;
use rustc_parse::parser::Parser;
use rustc_session::parse::ParseSess;
@@ -975,7 +977,7 @@ fn check_matcher_core(
Some(NonterminalKind::PatParam { inferred: false }),
));
sess.buffer_lint_with_diagnostic(
- &OR_PATTERNS_BACK_COMPAT,
+ &RUST_2021_INCOMPATIBLE_OR_PATTERNS,
span,
ast::CRATE_NODE_ID,
"the meaning of the `pat` fragment specifier is changing in Rust 2021, which may affect this macro",
diff --git a/compiler/rustc_lint/src/lib.rs b/compiler/rustc_lint/src/lib.rs
index 89f9809d643e0..6225b71692139 100644
--- a/compiler/rustc_lint/src/lib.rs
+++ b/compiler/rustc_lint/src/lib.rs
@@ -325,6 +325,9 @@ fn register_builtins(store: &mut LintStore, no_interleave_lints: bool) {
store.register_renamed("redundant_semicolon", "redundant_semicolons");
store.register_renamed("overlapping_patterns", "overlapping_range_endpoints");
store.register_renamed("safe_packed_borrows", "unaligned_references");
+ store.register_renamed("disjoint_capture_migration", "rust_2021_incompatible_closure_captures");
+ store.register_renamed("or_patterns_back_compat", "rust_2021_incompatible_or_patterns");
+ store.register_renamed("non_fmt_panic", "non_fmt_panics");
// These were moved to tool lints, but rustc still sees them when compiling normally, before
// tool lints are registered, so `check_tool_name_for_backwards_compat` doesn't work. Use
diff --git a/compiler/rustc_lint/src/non_fmt_panic.rs b/compiler/rustc_lint/src/non_fmt_panic.rs
index 3ea5a3bcc3b98..99a88f6bf610d 100644
--- a/compiler/rustc_lint/src/non_fmt_panic.rs
+++ b/compiler/rustc_lint/src/non_fmt_panic.rs
@@ -9,7 +9,7 @@ use rustc_span::edition::Edition;
use rustc_span::{hygiene, sym, symbol::kw, symbol::SymbolStr, InnerSpan, Span, Symbol};
declare_lint! {
- /// The `non_fmt_panic` lint detects `panic!(..)` invocations where the first
+ /// The `non_fmt_panics` lint detects `panic!(..)` invocations where the first
/// argument is not a formatting string.
///
/// ### Example
@@ -29,7 +29,7 @@ declare_lint! {
/// an `i32` as message.
///
/// Rust 2021 always interprets the first argument as format string.
- NON_FMT_PANIC,
+ NON_FMT_PANICS,
Warn,
"detect single-argument panic!() invocations in which the argument is not a format string",
@future_incompatible = FutureIncompatibleInfo {
@@ -39,7 +39,7 @@ declare_lint! {
report_in_external_macro
}
-declare_lint_pass!(NonPanicFmt => [NON_FMT_PANIC]);
+declare_lint_pass!(NonPanicFmt => [NON_FMT_PANICS]);
impl<'tcx> LateLintPass<'tcx> for NonPanicFmt {
fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx hir::Expr<'tcx>) {
@@ -91,7 +91,7 @@ fn check_panic<'tcx>(cx: &LateContext<'tcx>, f: &'tcx hir::Expr<'tcx>, arg: &'tc
arg_span = expn.call_site;
}
- cx.struct_span_lint(NON_FMT_PANIC, arg_span, |lint| {
+ cx.struct_span_lint(NON_FMT_PANICS, arg_span, |lint| {
let mut l = lint.build("panic message is not a string literal");
l.note("this usage of panic!() is deprecated; it will be a hard error in Rust 2021");
l.note("for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/panic-macro-consistency.html>");
@@ -174,7 +174,7 @@ fn check_panic_str<'tcx>(
[] => vec![fmt_span],
v => v.iter().map(|span| fmt_span.from_inner(*span)).collect(),
};
- cx.struct_span_lint(NON_FMT_PANIC, arg_spans, |lint| {
+ cx.struct_span_lint(NON_FMT_PANICS, arg_spans, |lint| {
let mut l = lint.build(match n_arguments {
1 => "panic message contains an unused formatting placeholder",
_ => "panic message contains unused formatting placeholders",
@@ -208,7 +208,7 @@ fn check_panic_str<'tcx>(
Some(v) if v.len() == 1 => "panic message contains a brace",
_ => "panic message contains braces",
};
- cx.struct_span_lint(NON_FMT_PANIC, brace_spans.unwrap_or_else(|| vec![span]), |lint| {
+ cx.struct_span_lint(NON_FMT_PANICS, brace_spans.unwrap_or_else(|| vec![span]), |lint| {
let mut l = lint.build(msg);
l.note("this message is not used as a format string, but will be in Rust 2021");
if span.contains(arg.span) {
diff --git a/compiler/rustc_lint_defs/src/builtin.rs b/compiler/rustc_lint_defs/src/builtin.rs
index 9dab4053c8edb..01291de51bdab 100644
--- a/compiler/rustc_lint_defs/src/builtin.rs
+++ b/compiler/rustc_lint_defs/src/builtin.rs
@@ -2967,13 +2967,13 @@ declare_lint_pass! {
MISSING_ABI,
INVALID_DOC_ATTRIBUTES,
SEMICOLON_IN_EXPRESSIONS_FROM_MACROS,
- DISJOINT_CAPTURE_MIGRATION,
+ RUST_2021_INCOMPATIBLE_CLOSURE_CAPTURES,
LEGACY_DERIVE_HELPERS,
PROC_MACRO_BACK_COMPAT,
- OR_PATTERNS_BACK_COMPAT,
+ RUST_2021_INCOMPATIBLE_OR_PATTERNS,
LARGE_ASSIGNMENTS,
- FUTURE_PRELUDE_COLLISION,
- RESERVED_PREFIX,
+ RUST_2021_PRELUDE_COLLISIONS,
+ RUST_2021_PREFIXES_INCOMPATIBLE_SYNTAX,
UNSUPPORTED_CALLING_CONVENTIONS,
]
}
@@ -3002,7 +3002,7 @@ declare_lint! {
}
declare_lint! {
- /// The `disjoint_capture_migration` lint detects variables that aren't completely
+ /// The `rust_2021_incompatible_closure_captures` lint detects variables that aren't completely
/// captured in Rust 2021 and affect the Drop order of at least one path starting at this variable.
/// It can also detect when a variable implements a trait, but one of its field does not and
/// the field is captured by a closure and used with the assumption that said field implements
@@ -3011,7 +3011,7 @@ declare_lint! {
/// ### Example of drop reorder
///
/// ```rust,compile_fail
- /// # #![deny(disjoint_capture_migration)]
+ /// # #![deny(rust_2021_incompatible_closure_captures)]
/// # #![allow(unused)]
/// struct FancyInteger(i32);
///
@@ -3046,7 +3046,7 @@ declare_lint! {
/// ### Example of auto-trait
///
/// ```rust,compile_fail
- /// #![deny(disjoint_capture_migration)]
+ /// #![deny(rust_2021_incompatible_closure_captures)]
/// use std::thread;
///
/// struct Pointer(*mut i32);
@@ -3068,7 +3068,7 @@ declare_lint! {
/// In the above example, only `fptr.0` is captured in Rust 2021.
/// The field is of type *mut i32 which doesn't implement Send, making the code invalid as the
/// field cannot be sent between thread safely.
- pub DISJOINT_CAPTURE_MIGRATION,
+ pub RUST_2021_INCOMPATIBLE_CLOSURE_CAPTURES,
Allow,
"detects closures affected by Rust 2021 changes",
@future_incompatible = FutureIncompatibleInfo {
@@ -3183,12 +3183,12 @@ declare_lint! {
}
declare_lint! {
- /// The `or_patterns_back_compat` lint detects usage of old versions of or-patterns.
+ /// The `rust_2021_incompatible_or_patterns` lint detects usage of old versions of or-patterns.
///
/// ### Example
///
/// ```rust,compile_fail
- /// #![deny(or_patterns_back_compat)]
+ /// #![deny(rust_2021_incompatible_or_patterns)]
/// macro_rules! match_any {
/// ( $expr:expr , $( $( $pat:pat )|+ => $expr_arm:expr ),+ ) => {
/// match $expr {
@@ -3211,7 +3211,7 @@ declare_lint! {
/// ### Explanation
///
/// In Rust 2021, the pat matcher will match new patterns, which include the | character.
- pub OR_PATTERNS_BACK_COMPAT,
+ pub RUST_2021_INCOMPATIBLE_OR_PATTERNS,
Allow,
"detects usage of old versions of or-patterns",
@future_incompatible = FutureIncompatibleInfo {
@@ -3221,13 +3221,13 @@ declare_lint! {
}
declare_lint! {
- /// The `future_prelude_collision` lint detects the usage of trait methods which are ambiguous
+ /// The `rust_2021_prelude_collisions` lint detects the usage of trait methods which are ambiguous
/// with traits added to the prelude in future editions.
///
/// ### Example
///
/// ```rust,compile_fail
- /// #![deny(future_prelude_collision)]
+ /// #![deny(rust_2021_prelude_collisions)]
///
/// trait Foo {
/// fn try_into(self) -> Result<String, !>;
@@ -3259,7 +3259,7 @@ declare_lint! {
/// is called directly on a type.
///
/// [prelude changes]: https://blog.rust-lang.org/inside-rust/2021/03/04/planning-rust-2021.html#prelude-changes
- pub FUTURE_PRELUDE_COLLISION,
+ pub RUST_2021_PRELUDE_COLLISIONS,
Allow,
"detects the usage of trait methods which are ambiguous with traits added to the \
prelude in future editions",
@@ -3270,13 +3270,13 @@ declare_lint! {
}
declare_lint! {
- /// The `reserved_prefix` lint detects identifiers that will be parsed as a
+ /// The `rust_2021_prefixes_incompatible_syntax` lint detects identifiers that will be parsed as a
/// prefix instead in Rust 2021.
///
/// ### Example
///
/// ```rust,compile_fail
- /// #![deny(reserved_prefix)]
+ /// #![deny(rust_2021_prefixes_incompatible_syntax)]
///
/// macro_rules! m {
/// (z $x:expr) => ();
@@ -3295,7 +3295,7 @@ declare_lint! {
///
/// This lint suggests to add whitespace between the `z` and `"hey"` tokens
/// to keep them separated in Rust 2021.
- pub RESERVED_PREFIX,
+ pub RUST_2021_PREFIXES_INCOMPATIBLE_SYNTAX,
Allow,
"identifiers that will be parsed as a prefix in Rust 2021",
@future_incompatible = FutureIncompatibleInfo {
diff --git a/compiler/rustc_parse/src/lexer/mod.rs b/compiler/rustc_parse/src/lexer/mod.rs
index 87e60a48e4457..98befe4066bc5 100644
--- a/compiler/rustc_parse/src/lexer/mod.rs
+++ b/compiler/rustc_parse/src/lexer/mod.rs
@@ -4,7 +4,7 @@ use rustc_ast::tokenstream::{Spacing, TokenStream};
use rustc_errors::{error_code, Applicability, DiagnosticBuilder, FatalError, PResult};
use rustc_lexer::unescape::{self, Mode};
use rustc_lexer::{Base, DocStyle, RawStrError};
-use rustc_session::lint::builtin::RESERVED_PREFIX;
+use rustc_session::lint::builtin::RUST_2021_PREFIXES_INCOMPATIBLE_SYNTAX;
use rustc_session::lint::BuiltinLintDiagnostics;
use rustc_session::parse::ParseSess;
use rustc_span::symbol::{sym, Symbol};
@@ -526,7 +526,7 @@ impl<'a> StringReader<'a> {
} else {
// Before Rust 2021, only emit a lint for migration.
self.sess.buffer_lint_with_diagnostic(
- &RESERVED_PREFIX,
+ &RUST_2021_PREFIXES_INCOMPATIBLE_SYNTAX,
prefix_span,
ast::CRATE_NODE_ID,
&msg,
diff --git a/compiler/rustc_typeck/src/check/method/prelude2021.rs b/compiler/rustc_typeck/src/check/method/prelude2021.rs
index e8748dd062f53..6ca0b3ed66b39 100644
--- a/compiler/rustc_typeck/src/check/method/prelude2021.rs
+++ b/compiler/rustc_typeck/src/check/method/prelude2021.rs
@@ -5,7 +5,7 @@ use rustc_ast::Mutability;
use rustc_errors::Applicability;
use rustc_hir as hir;
use rustc_middle::ty::{Ref, Ty};
-use rustc_session::lint::builtin::FUTURE_PRELUDE_COLLISION;
+use rustc_session::lint::builtin::RUST_2021_PRELUDE_COLLISIONS;
use rustc_span::symbol::kw::Underscore;
use rustc_span::symbol::{sym, Ident};
use rustc_span::Span;
@@ -67,7 +67,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
// Inherent impls only require not relying on autoref and autoderef in order to
// ensure that the trait implementation won't be used
self.tcx.struct_span_lint_hir(
- FUTURE_PRELUDE_COLLISION,
+ RUST_2021_PRELUDE_COLLISIONS,
self_expr.hir_id,
self_expr.span,
|lint| {
@@ -128,7 +128,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
// trait implementations require full disambiguation to not clash with the new prelude
// additions (i.e. convert from dot-call to fully-qualified call)
self.tcx.struct_span_lint_hir(
- FUTURE_PRELUDE_COLLISION,
+ RUST_2021_PRELUDE_COLLISIONS,
call_expr.hir_id,
call_expr.span,
|lint| {
@@ -212,7 +212,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
return;
}
- self.tcx.struct_span_lint_hir(FUTURE_PRELUDE_COLLISION, expr_id, span, |lint| {
+ self.tcx.struct_span_lint_hir(RUST_2021_PRELUDE_COLLISIONS, expr_id, span, |lint| {
// "type" refers to either a type or, more likely, a trait from which
// the associated function or method is from.
let trait_path = self.trait_path_or_bare_name(span, expr_id, pick.item.container.id());
diff --git a/compiler/rustc_typeck/src/check/upvar.rs b/compiler/rustc_typeck/src/check/upvar.rs
index e5f18778f43e6..1dcc4c2f2b8cf 100644
--- a/compiler/rustc_typeck/src/check/upvar.rs
+++ b/compiler/rustc_typeck/src/check/upvar.rs
@@ -173,7 +173,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
let closure_hir_id = self.tcx.hir().local_def_id_to_hir_id(local_def_id);
- if should_do_disjoint_capture_migration_analysis(self.tcx, closure_hir_id) {
+ if should_do_rust_2021_incompatible_closure_captures_analysis(self.tcx, closure_hir_id) {
self.perform_2229_migration_anaysis(closure_def_id, body_id, capture_clause, span);
}
@@ -505,7 +505,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
let local_def_id = closure_def_id.expect_local();
let closure_hir_id = self.tcx.hir().local_def_id_to_hir_id(local_def_id);
self.tcx.struct_span_lint_hir(
- lint::builtin::DISJOINT_CAPTURE_MIGRATION,
+ lint::builtin::RUST_2021_INCOMPATIBLE_CLOSURE_CAPTURES,
closure_hir_id,
span,
|lint| {
@@ -1829,8 +1829,12 @@ fn var_name(tcx: TyCtxt<'_>, var_hir_id: hir::HirId) -> Symbol {
tcx.hir().name(var_hir_id)
}
-fn should_do_disjoint_capture_migration_analysis(tcx: TyCtxt<'_>, closure_id: hir::HirId) -> bool {
- let (level, _) = tcx.lint_level_at_node(lint::builtin::DISJOINT_CAPTURE_MIGRATION, closure_id);
+fn should_do_rust_2021_incompatible_closure_captures_analysis(
+ tcx: TyCtxt<'_>,
+ closure_id: hir::HirId,
+) -> bool {
+ let (level, _) =
+ tcx.lint_level_at_node(lint::builtin::RUST_2021_INCOMPATIBLE_CLOSURE_CAPTURES, closure_id);
!matches!(level, lint::Level::Allow)
}
diff --git a/library/core/src/lib.rs b/library/core/src/lib.rs
index 866cd5ec535d2..3557dbad90cc2 100644
--- a/library/core/src/lib.rs
+++ b/library/core/src/lib.rs
@@ -164,7 +164,8 @@
#![feature(no_niche)] // rust-lang/rust#68303
#![feature(no_coverage)] // rust-lang/rust#84605
#![deny(unsafe_op_in_unsafe_fn)]
-#![deny(or_patterns_back_compat)]
+#![cfg_attr(bootstrap, deny(or_patterns_back_compat))]
+#![cfg_attr(not(bootstrap), deny(rust_2021_incompatible_or_patterns))]
// allow using `core::` in intra-doc links
#[allow(unused_extern_crates)]
diff --git a/library/core/src/num/int_macros.rs b/library/core/src/num/int_macros.rs
index 2e466106fe553..a9461649d4aa1 100644
--- a/library/core/src/num/int_macros.rs
+++ b/library/core/src/num/int_macros.rs
@@ -1744,6 +1744,194 @@ macro_rules! int_impl {
}
}
+ /// Returns the logarithm of the number with respect to an arbitrary base.
+ ///
+ /// This method may not be optimized owing to implementation details;
+ /// `log2` can produce results more efficiently for base 2, and `log10`
+ /// can produce results more efficiently for base 10.
+ ///
+ /// # Panics
+ ///
+ /// When the number is zero, or if the base is not at least 2; it
+ /// panics in debug mode and the return value is wrapped to 0 in release
+ /// mode (the only situation in which the method can return 0).
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// #![feature(int_log)]
+ #[doc = concat!("assert_eq!(5", stringify!($SelfT), ".log(5), 1);")]
+ /// ```
+ #[unstable(feature = "int_log", issue = "70887")]
+ #[must_use = "this returns the result of the operation, \
+ without modifying the original"]
+ #[inline]
+ #[track_caller]
+ #[rustc_inherit_overflow_checks]
+ #[allow(arithmetic_overflow)]
+ pub const fn log(self, base: Self) -> Self {
+ match self.checked_log(base) {
+ Some(n) => n,
+ None => {
+ // In debug builds, trigger a panic on None.
+ // This should optimize completely out in release builds.
+ let _ = Self::MAX + 1;
+
+ 0
+ },
+ }
+ }
+
+ /// Returns the base 2 logarithm of the number.
+ ///
+ /// # Panics
+ ///
+ /// When the number is zero it panics in debug mode and the return value
+ /// is wrapped to 0 in release mode (the only situation in which the
+ /// method can return 0).
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// #![feature(int_log)]
+ #[doc = concat!("assert_eq!(2", stringify!($SelfT), ".log2(), 1);")]
+ /// ```
+ #[unstable(feature = "int_log", issue = "70887")]
+ #[must_use = "this returns the result of the operation, \
+ without modifying the original"]
+ #[inline]
+ #[track_caller]
+ #[rustc_inherit_overflow_checks]
+ #[allow(arithmetic_overflow)]
+ pub const fn log2(self) -> Self {
+ match self.checked_log2() {
+ Some(n) => n,
+ None => {
+ // In debug builds, trigger a panic on None.
+ // This should optimize completely out in release builds.
+ let _ = Self::MAX + 1;
+
+ 0
+ },
+ }
+ }
+
+ /// Returns the base 10 logarithm of the number.
+ ///
+ /// # Panics
+ ///
+ /// When the number is zero it panics in debug mode and the return value
+ /// is wrapped to 0 in release mode (the only situation in which the
+ /// method can return 0).
+ ///
+ /// # Example
+ ///
+ /// ```
+ /// #![feature(int_log)]
+ #[doc = concat!("assert_eq!(10", stringify!($SelfT), ".log10(), 1);")]
+ /// ```
+ #[unstable(feature = "int_log", issue = "70887")]
+ #[must_use = "this returns the result of the operation, \
+ without modifying the original"]
+ #[inline]
+ #[track_caller]
+ #[rustc_inherit_overflow_checks]
+ #[allow(arithmetic_overflow)]
+ pub const fn log10(self) -> Self {
+ match self.checked_log10() {
+ Some(n) => n,
+ None => {
+ // In debug builds, trigger a panic on None.
+ // This should optimize completely out in release builds.
+ let _ = Self::MAX + 1;
+
+ 0
+ },
+ }
+ }
+
+ /// Returns the logarithm of the number with respect to an arbitrary base.
+ ///
+ /// Returns `None` if the number is negative or zero, or if the base is not at least 2.
+ ///
+ /// This method may not be optimized owing to implementation details;
+ /// `checked_log2` can produce results more efficiently for base 2, and
+ /// `checked_log10` can produce results more efficiently for base 10.
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// #![feature(int_log)]
+ #[doc = concat!("assert_eq!(5", stringify!($SelfT), ".checked_log(5), Some(1));")]
+ /// ```
+ #[unstable(feature = "int_log", issue = "70887")]
+ #[must_use = "this returns the result of the operation, \
+ without modifying the original"]
+ #[inline]
+ pub const fn checked_log(self, base: Self) -> Option<Self> {
+ if self <= 0 || base <= 1 {
+ None
+ } else {
+ let mut n = 0;
+ let mut r = self;
+
+ // Optimization for 128 bit wide integers.
+ if Self::BITS == 128 {
+ let b = Self::log2(self) / (Self::log2(base) + 1);
+ n += b;
+ r /= base.pow(b as u32);
+ }
+
+ while r >= base {
+ r /= base;
+ n += 1;
+ }
+ Some(n)
+ }
+ }
+
+ /// Returns the base 2 logarithm of the number.
+ ///
+ /// Returns `None` if the number is negative or zero.
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// #![feature(int_log)]
+ #[doc = concat!("assert_eq!(2", stringify!($SelfT), ".checked_log2(), Some(1));")]
+ /// ```
+ #[unstable(feature = "int_log", issue = "70887")]
+ #[must_use = "this returns the result of the operation, \
+ without modifying the original"]
+ #[inline]
+ pub const fn checked_log2(self) -> Option<Self> {
+ if self <= 0 {
+ None
+ } else {
+ // SAFETY: We just checked that this number is positive
+ let log = (Self::BITS - 1) as Self - unsafe { intrinsics::ctlz_nonzero(self) };
+ Some(log)
+ }
+ }
+
+ /// Returns the base 10 logarithm of the number.
+ ///
+ /// Returns `None` if the number is negative or zero.
+ ///
+ /// # Example
+ ///
+ /// ```
+ /// #![feature(int_log)]
+ #[doc = concat!("assert_eq!(10", stringify!($SelfT), ".checked_log10(), Some(1));")]
+ /// ```
+ #[unstable(feature = "int_log", issue = "70887")]
+ #[must_use = "this returns the result of the operation, \
+ without modifying the original"]
+ #[inline]
+ pub const fn checked_log10(self) -> Option<Self> {
+ self.checked_log(10)
+ }
+
/// Computes the absolute value of `self`.
///
/// # Overflow behavior
diff --git a/library/core/src/num/uint_macros.rs b/library/core/src/num/uint_macros.rs
index e512d90ef3735..bf4d2e7433e2f 100644
--- a/library/core/src/num/uint_macros.rs
+++ b/library/core/src/num/uint_macros.rs
@@ -634,6 +634,194 @@ macro_rules! uint_impl {
}
}
+ /// Returns the logarithm of the number with respect to an arbitrary base.
+ ///
+ /// This method may not be optimized owing to implementation details;
+ /// `log2` can produce results more efficiently for base 2, and `log10`
+ /// can produce results more efficiently for base 10.
+ ///
+ /// # Panics
+ ///
+ /// When the number is negative, zero, or if the base is not at least 2;
+ /// it panics in debug mode and the return value is wrapped to 0 in
+ /// release mode (the only situation in which the method can return 0).
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// #![feature(int_log)]
+ #[doc = concat!("assert_eq!(5", stringify!($SelfT), ".log(5), 1);")]
+ /// ```
+ #[unstable(feature = "int_log", issue = "70887")]
+ #[must_use = "this returns the result of the operation, \
+ without modifying the original"]
+ #[inline]
+ #[track_caller]
+ #[rustc_inherit_overflow_checks]
+ #[allow(arithmetic_overflow)]
+ pub const fn log(self, base: Self) -> Self {
+ match self.checked_log(base) {
+ Some(n) => n,
+ None => {
+ // In debug builds, trigger a panic on None.
+ // This should optimize completely out in release builds.
+ let _ = Self::MAX + 1;
+
+ 0
+ },
+ }
+ }
+
+ /// Returns the base 2 logarithm of the number.
+ ///
+ /// # Panics
+ ///
+ /// When the number is negative or zero it panics in debug mode and
+ /// the return value is wrapped to 0 in release mode (the only situation in
+ /// which the method can return 0).
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// #![feature(int_log)]
+ #[doc = concat!("assert_eq!(2", stringify!($SelfT), ".log2(), 1);")]
+ /// ```
+ #[unstable(feature = "int_log", issue = "70887")]
+ #[must_use = "this returns the result of the operation, \
+ without modifying the original"]
+ #[inline]
+ #[track_caller]
+ #[rustc_inherit_overflow_checks]
+ #[allow(arithmetic_overflow)]
+ pub const fn log2(self) -> Self {
+ match self.checked_log2() {
+ Some(n) => n,
+ None => {
+ // In debug builds, trigger a panic on None.
+ // This should optimize completely out in release builds.
+ let _ = Self::MAX + 1;
+
+ 0
+ },
+ }
+ }
+
+ /// Returns the base 10 logarithm of the number.
+ ///
+ /// # Panics
+ ///
+ /// When the number is negative or zero it panics in debug mode and the
+ /// return value is wrapped to 0 in release mode (the only situation in
+ /// which the method can return 0).
+ ///
+ /// # Example
+ ///
+ /// ```
+ /// #![feature(int_log)]
+ #[doc = concat!("assert_eq!(10", stringify!($SelfT), ".log10(), 1);")]
+ /// ```
+ #[unstable(feature = "int_log", issue = "70887")]
+ #[must_use = "this returns the result of the operation, \
+ without modifying the original"]
+ #[inline]
+ #[track_caller]
+ #[rustc_inherit_overflow_checks]
+ #[allow(arithmetic_overflow)]
+ pub const fn log10(self) -> Self {
+ match self.checked_log10() {
+ Some(n) => n,
+ None => {
+ // In debug builds, trigger a panic on None.
+ // This should optimize completely out in release builds.
+ let _ = Self::MAX + 1;
+
+ 0
+ },
+ }
+ }
+
+ /// Returns the logarithm of the number with respect to an arbitrary base.
+ ///
+ /// Returns `None` if the number is zero, or if the base is not at least 2.
+ ///
+ /// This method may not be optimized owing to implementation details;
+ /// `checked_log2` can produce results more efficiently for base 2, and
+ /// `checked_log10` can produce results more efficiently for base 10.
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// #![feature(int_log)]
+ #[doc = concat!("assert_eq!(5", stringify!($SelfT), ".checked_log(5), Some(1));")]
+ /// ```
+ #[unstable(feature = "int_log", issue = "70887")]
+ #[must_use = "this returns the result of the operation, \
+ without modifying the original"]
+ #[inline]
+ pub const fn checked_log(self, base: Self) -> Option<Self> {
+ if self <= 0 || base <= 1 {
+ None
+ } else {
+ let mut n = 0;
+ let mut r = self;
+
+ // Optimization for 128 bit wide integers.
+ if Self::BITS == 128 {
+ let b = Self::log2(self) / (Self::log2(base) + 1);
+ n += b;
+ r /= base.pow(b as u32);
+ }
+
+ while r >= base {
+ r /= base;
+ n += 1;
+ }
+ Some(n)
+ }
+ }
+
+ /// Returns the base 2 logarithm of the number.
+ ///
+ /// Returns `None` if the number is zero.
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// #![feature(int_log)]
+ #[doc = concat!("assert_eq!(2", stringify!($SelfT), ".checked_log2(), Some(1));")]
+ /// ```
+ #[unstable(feature = "int_log", issue = "70887")]
+ #[must_use = "this returns the result of the operation, \
+ without modifying the original"]
+ #[inline]
+ pub const fn checked_log2(self) -> Option<Self> {
+ if self <= 0 {
+ None
+ } else {
+ // SAFETY: We just checked that this number is positive
+ let log = (Self::BITS - 1) as Self - unsafe { intrinsics::ctlz_nonzero(self) };
+ Some(log)
+ }
+ }
+
+ /// Returns the base 10 logarithm of the number.
+ ///
+ /// Returns `None` if the number is zero.
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// #![feature(int_log)]
+ #[doc = concat!("assert_eq!(10", stringify!($SelfT), ".checked_log10(), Some(1));")]
+ /// ```
+ #[unstable(feature = "int_log", issue = "70887")]
+ #[must_use = "this returns the result of the operation, \
+ without modifying the original"]
+ #[inline]
+ pub const fn checked_log10(self) -> Option<Self> {
+ self.checked_log(10)
+ }
+
/// Checked negation. Computes `-self`, returning `None` unless `self ==
/// 0`.
///
diff --git a/library/core/src/sync/atomic.rs b/library/core/src/sync/atomic.rs
index f1a115563fd3e..b673b36c10211 100644
--- a/library/core/src/sync/atomic.rs
+++ b/library/core/src/sync/atomic.rs
@@ -2648,7 +2648,11 @@ unsafe fn atomic_umin<T: Copy>(dst: *mut T, val: T, order: Ordering) -> T {
///
/// pub fn lock(&self) {
/// // Wait until the old value is `false`.
-/// while self.flag.compare_and_swap(false, true, Ordering::Relaxed) != false {}
+/// while self
+/// .flag
+/// .compare_exchange_weak(false, true, Ordering::Relaxed, Ordering::Relaxed)
+/// .is_err()
+/// {}
/// // This fence synchronizes-with store in `unlock`.
/// fence(Ordering::Acquire);
/// }
@@ -2710,7 +2714,7 @@ pub fn fence(order: Ordering) {
/// Without `compiler_fence`, the `assert_eq!` in following code
/// is *not* guaranteed to succeed, despite everything happening in a single thread.
/// To see why, remember that the compiler is free to swap the stores to
-/// `IMPORTANT_VARIABLE` and `IS_READ` since they are both
+/// `IMPORTANT_VARIABLE` and `IS_READY` since they are both
/// `Ordering::Relaxed`. If it does, and the signal handler is invoked right
/// after `IS_READY` is updated, then the signal handler will see
/// `IS_READY=1`, but `IMPORTANT_VARIABLE=0`.
diff --git a/library/core/tests/lib.rs b/library/core/tests/lib.rs
index f9d331063f4b1..cc4ff1be56314 100644
--- a/library/core/tests/lib.rs
+++ b/library/core/tests/lib.rs
@@ -44,6 +44,7 @@
#![feature(try_trait_v2)]
#![feature(slice_internals)]
#![feature(slice_partition_dedup)]
+#![feature(int_log)]
#![feature(iter_advance_by)]
#![feature(iter_partition_in_place)]
#![feature(iter_intersperse)]
diff --git a/library/core/tests/manually_drop.rs b/library/core/tests/manually_drop.rs
index 77a338daf7dcb..9eac279733af9 100644
--- a/library/core/tests/manually_drop.rs
+++ b/library/core/tests/manually_drop.rs
@@ -2,6 +2,7 @@ use core::mem::ManuallyDrop;
#[test]
fn smoke() {
+ #[derive(Clone)]
struct TypeWithDrop;
impl Drop for TypeWithDrop {
fn drop(&mut self) {
@@ -16,4 +17,11 @@ fn smoke() {
let x: Box<ManuallyDrop<[TypeWithDrop]>> =
Box::new(ManuallyDrop::new([TypeWithDrop, TypeWithDrop]));
drop(x);
+
+ // test clone and clone_from implementations
+ let mut x = ManuallyDrop::new(TypeWithDrop);
+ let y = x.clone();
+ x.clone_from(&y);
+ drop(x);
+ drop(y);
}
diff --git a/library/core/tests/num/int_log.rs b/library/core/tests/num/int_log.rs
new file mode 100644
index 0000000000000..99a9b17ab1183
--- /dev/null
+++ b/library/core/tests/num/int_log.rs
@@ -0,0 +1,99 @@
+//! This tests the `Integer::{log,log2,log10}` methods. These tests are in a
+//! separate file because there's both a large number of them, and not all tests
+//! can be run on Android. This is because in Android `log2` uses an imprecise
+//! approximation:https://github.com/rust-lang/rust/blob/4825e12fc9c79954aa0fe18f5521efa6c19c7539/src/libstd/sys/unix/android.rs#L27-L53
+
+#[test]
+fn checked_log() {
+ assert_eq!(999u32.checked_log(10), Some(2));
+ assert_eq!(1000u32.checked_log(10), Some(3));
+ assert_eq!(555u32.checked_log(13), Some(2));
+ assert_eq!(63u32.checked_log(4), Some(2));
+ assert_eq!(64u32.checked_log(4), Some(3));
+ assert_eq!(10460353203u64.checked_log(3), Some(21));
+ assert_eq!(10460353202u64.checked_log(3), Some(20));
+ assert_eq!(147808829414345923316083210206383297601u128.checked_log(3), Some(80));
+ assert_eq!(147808829414345923316083210206383297600u128.checked_log(3), Some(79));
+ assert_eq!(22528399544939174411840147874772641u128.checked_log(19683), Some(8));
+ assert_eq!(22528399544939174411840147874772631i128.checked_log(19683), Some(7));
+
+ assert_eq!(0u8.checked_log(4), None);
+ assert_eq!(0u16.checked_log(4), None);
+ assert_eq!(0i8.checked_log(4), None);
+ assert_eq!(0i16.checked_log(4), None);
+
+ for i in i16::MIN..=0 {
+ assert_eq!(i.checked_log(4), None);
+ }
+ for i in 1..=i16::MAX {
+ assert_eq!(i.checked_log(13), Some((i as f32).log(13.0) as i16));
+ }
+ for i in 1..=u16::MAX {
+ assert_eq!(i.checked_log(13), Some((i as f32).log(13.0) as u16));
+ }
+}
+
+#[test]
+fn checked_log2() {
+ assert_eq!(5u32.checked_log2(), Some(2));
+ assert_eq!(0u64.checked_log2(), None);
+ assert_eq!(128i32.checked_log2(), Some(7));
+ assert_eq!((-55i16).checked_log2(), None);
+
+ assert_eq!(0u8.checked_log2(), None);
+ assert_eq!(0u16.checked_log2(), None);
+ assert_eq!(0i8.checked_log2(), None);
+ assert_eq!(0i16.checked_log2(), None);
+
+ for i in 1..=u8::MAX {
+ assert_eq!(i.checked_log2(), Some((i as f32).log2() as u8));
+ }
+ for i in 1..=u16::MAX {
+ // Guard against Android's imprecise f32::log2 implementation.
+ if i != 8192 && i != 32768 {
+ assert_eq!(i.checked_log2(), Some((i as f32).log2() as u16));
+ }
+ }
+ for i in i8::MIN..=0 {
+ assert_eq!(i.checked_log2(), None);
+ }
+ for i in 1..=i8::MAX {
+ assert_eq!(i.checked_log2(), Some((i as f32).log2() as i8));
+ }
+ for i in i16::MIN..=0 {
+ assert_eq!(i.checked_log2(), None);
+ }
+ for i in 1..=i16::MAX {
+ // Guard against Android's imprecise f32::log2 implementation.
+ if i != 8192 {
+ assert_eq!(i.checked_log2(), Some((i as f32).log2() as i16));
+ }
+ }
+}
+
+// Validate cases that fail on Android's imprecise float log2 implementation.
+#[test]
+#[cfg(not(target_os = "android"))]
+fn checked_log2_not_android() {
+ assert_eq!(8192u16.checked_log2(), Some((8192f32).log2() as u16));
+ assert_eq!(32768u16.checked_log2(), Some((32768f32).log2() as u16));
+ assert_eq!(8192i16.checked_log2(), Some((8192f32).log2() as i16));
+}
+
+#[test]
+fn checked_log10() {
+ assert_eq!(0u8.checked_log10(), None);
+ assert_eq!(0u16.checked_log10(), None);
+ assert_eq!(0i8.checked_log10(), None);
+ assert_eq!(0i16.checked_log10(), None);
+
+ for i in i16::MIN..=0 {
+ assert_eq!(i.checked_log10(), None);
+ }
+ for i in 1..=i16::MAX {
+ assert_eq!(i.checked_log10(), Some((i as f32).log10() as i16));
+ }
+ for i in 1..=u16::MAX {
+ assert_eq!(i.checked_log10(), Some((i as f32).log10() as u16));
+ }
+}
diff --git a/library/core/tests/num/mod.rs b/library/core/tests/num/mod.rs
index bbb67667dfc05..76e838cf6bfbd 100644
--- a/library/core/tests/num/mod.rs
+++ b/library/core/tests/num/mod.rs
@@ -29,6 +29,7 @@ mod u8;
mod bignum;
mod dec2flt;
mod flt2dec;
+mod int_log;
mod ops;
mod wrapping;
diff --git a/library/std/src/lib.rs b/library/std/src/lib.rs
index 6f389f000af93..8c120f4af288d 100644
--- a/library/std/src/lib.rs
+++ b/library/std/src/lib.rs
@@ -278,6 +278,7 @@
#![feature(hashmap_internals)]
#![feature(int_error_internals)]
#![feature(integer_atomics)]
+#![feature(int_log)]
#![feature(into_future)]
#![feature(intra_doc_pointers)]
#![feature(iter_zip)]
diff --git a/library/std/src/thread/mod.rs b/library/std/src/thread/mod.rs
index f7e791419038d..da2d11604934f 100644
--- a/library/std/src/thread/mod.rs
+++ b/library/std/src/thread/mod.rs
@@ -651,22 +651,23 @@ pub fn current() -> Thread {
/// Cooperatively gives up a timeslice to the OS scheduler.
///
-/// This is used when the programmer knows that the thread will have nothing
-/// to do for some time, and thus avoid wasting computing time.
-///
-/// For example when polling on a resource, it is common to check that it is
-/// available, and if not to yield in order to avoid busy waiting.
-///
-/// Thus the pattern of `yield`ing after a failed poll is rather common when
-/// implementing low-level shared resources or synchronization primitives.
-///
-/// However programmers will usually prefer to use [`channel`]s, [`Condvar`]s,
-/// [`Mutex`]es or [`join`] for their synchronization routines, as they avoid
-/// thinking about thread scheduling.
-///
-/// Note that [`channel`]s for example are implemented using this primitive.
-/// Indeed when you call `send` or `recv`, which are blocking, they will yield
-/// if the channel is not available.
+/// This calls the underlying OS scheduler's yield primitive, signaling
+/// that the calling thread is willing to give up its remaining timeslice
+/// so that the OS may schedule other threads on the CPU.
+///
+/// A drawback of yielding in a loop is that if the OS does not have any
+/// other ready threads to run on the current CPU, the thread will effectively
+/// busy-wait, which wastes CPU time and energy.
+///
+/// Therefore, when waiting for events of interest, a programmer's first
+/// choice should be to use synchronization devices such as [`channel`]s,
+/// [`Condvar`]s, [`Mutex`]es or [`join`] since these primitives are
+/// implemented in a blocking manner, giving up the CPU until the event
+/// of interest has occurred which avoids repeated yielding.
+///
+/// `yield_now` should thus be used only rarely, mostly in situations where
+/// repeated polling is required because there is no other suitable way to
+/// learn when an event of interest has occurred.
///
/// # Examples
///
diff --git a/src/ci/cpu-usage-over-time.py b/src/ci/cpu-usage-over-time.py
index 78ac060368193..267c3964d0d69 100644
--- a/src/ci/cpu-usage-over-time.py
+++ b/src/ci/cpu-usage-over-time.py
@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
# ignore-tidy-linelength
# This is a small script that we use on CI to collect CPU usage statistics of
@@ -37,7 +37,10 @@
import sys
import time
-if sys.platform == 'linux2':
+# Python 3.3 changed the value of `sys.platform` on Linux from "linux2" to just
+# "linux". We check here with `.startswith` to keep compatibility with older
+# Python versions (especially Python 2.7).
+if sys.platform.startswith('linux'):
class State:
def __init__(self):
with open('/proc/stat', 'r') as file:
diff --git a/src/ci/scripts/collect-cpu-stats.sh b/src/ci/scripts/collect-cpu-stats.sh
index 08065431f9816..853b4628fab2f 100755
--- a/src/ci/scripts/collect-cpu-stats.sh
+++ b/src/ci/scripts/collect-cpu-stats.sh
@@ -6,4 +6,4 @@
set -euo pipefail
IFS=$'\n\t'
-python src/ci/cpu-usage-over-time.py &> cpu-usage.csv &
+python3 src/ci/cpu-usage-over-time.py &> cpu-usage.csv &
diff --git a/src/doc/book b/src/doc/book
index 55a26488ddefc..a90f07f1e9a7f 160000
--- a/src/doc/book
+++ b/src/doc/book
@@ -1 +1 @@
-Subproject commit 55a26488ddefc8433e73a2e8352d70f7a5c7fc2b
+Subproject commit a90f07f1e9a7fc75dc9105a6c6f16d5c13edceb0
diff --git a/src/doc/edition-guide b/src/doc/edition-guide
index c74b2a0d6bf55..5d57b3832f8d3 160000
--- a/src/doc/edition-guide
+++ b/src/doc/edition-guide
@@ -1 +1 @@
-Subproject commit c74b2a0d6bf55774cf15d69f05dfe05408b8f81a
+Subproject commit 5d57b3832f8d308a9f478ce0a69799548f27ad4d
diff --git a/src/doc/embedded-book b/src/doc/embedded-book
index cbec77fbd8eea..506840eb73b07 160000
--- a/src/doc/embedded-book
+++ b/src/doc/embedded-book
@@ -1 +1 @@
-Subproject commit cbec77fbd8eea0c13e390dd9eded1ae200e811d1
+Subproject commit 506840eb73b0749336e1d5274e16d6393892ee82
diff --git a/src/doc/nomicon b/src/doc/nomicon
index b9ca313e687c9..7a13537f96af4 160000
--- a/src/doc/nomicon
+++ b/src/doc/nomicon
@@ -1 +1 @@
-Subproject commit b9ca313e687c991223e23e5520529815dc281205
+Subproject commit 7a13537f96af4b9b8e3ea296d6e5c3c7ab72ce9f
diff --git a/src/doc/reference b/src/doc/reference
index d9699fa8f3186..ab60513a3a5a0 160000
--- a/src/doc/reference
+++ b/src/doc/reference
@@ -1 +1 @@
-Subproject commit d9699fa8f3186440fdaadd703d63d8d42322c176
+Subproject commit ab60513a3a5a0591e237fddff5d027a982648392
diff --git a/src/doc/rust-by-example b/src/doc/rust-by-example
index 805e016c5792a..028f93a61500f 160000
--- a/src/doc/rust-by-example
+++ b/src/doc/rust-by-example
@@ -1 +1 @@
-Subproject commit 805e016c5792ad2adabb66e348233067d5ea9f10
+Subproject commit 028f93a61500fe8f746ee7cc6b204ea6c9f42935
diff --git a/src/doc/rustc-dev-guide b/src/doc/rustc-dev-guide
index fe34beddb41de..60e2825591040 160000
--- a/src/doc/rustc-dev-guide
+++ b/src/doc/rustc-dev-guide
@@ -1 +1 @@
-Subproject commit fe34beddb41dea5cb891032512a8d5b842b99696
+Subproject commit 60e282559104035985331645907c3d9f842312c5
diff --git a/src/librustdoc/html/markdown.rs b/src/librustdoc/html/markdown.rs
index bafb522f36338..9fff508165a10 100644
--- a/src/librustdoc/html/markdown.rs
+++ b/src/librustdoc/html/markdown.rs
@@ -1358,7 +1358,10 @@ pub struct IdMap {
fn init_id_map() -> FxHashMap<String, usize> {
let mut map = FxHashMap::default();
- // This is the list of IDs used by rustdoc templates.
+ // This is the list of IDs used in Javascript.
+ map.insert("help".to_owned(), 1);
+ // This is the list of IDs used in HTML generated in Rust (including the ones
+ // used in tera template files).
map.insert("mainThemeStyle".to_owned(), 1);
map.insert("themeStyle".to_owned(), 1);
map.insert("theme-picker".to_owned(), 1);
@@ -1375,14 +1378,14 @@ fn init_id_map() -> FxHashMap<String, usize> {
map.insert("rustdoc-vars".to_owned(), 1);
map.insert("sidebar-vars".to_owned(), 1);
map.insert("copy-path".to_owned(), 1);
- map.insert("help".to_owned(), 1);
map.insert("TOC".to_owned(), 1);
- map.insert("render-detail".to_owned(), 1);
- // This is the list of IDs used by rustdoc sections.
+ // This is the list of IDs used by rustdoc sections (but still generated by
+ // rustdoc).
map.insert("fields".to_owned(), 1);
map.insert("variants".to_owned(), 1);
map.insert("implementors-list".to_owned(), 1);
map.insert("synthetic-implementors-list".to_owned(), 1);
+ map.insert("foreign-impls".to_owned(), 1);
map.insert("implementations".to_owned(), 1);
map.insert("trait-implementations".to_owned(), 1);
map.insert("synthetic-implementations".to_owned(), 1);
@@ -1393,6 +1396,10 @@ fn init_id_map() -> FxHashMap<String, usize> {
map.insert("provided-methods".to_owned(), 1);
map.insert("implementors".to_owned(), 1);
map.insert("synthetic-implementors".to_owned(), 1);
+ map.insert("trait-implementations-list".to_owned(), 1);
+ map.insert("synthetic-implementations-list".to_owned(), 1);
+ map.insert("blanket-implementations-list".to_owned(), 1);
+ map.insert("deref-methods".to_owned(), 1);
map
}
diff --git a/src/test/ui/closures/2229_closure_analysis/migrations/auto_traits.fixed b/src/test/ui/closures/2229_closure_analysis/migrations/auto_traits.fixed
index ee8dd4b4fc33d..134d07c400b3a 100644
--- a/src/test/ui/closures/2229_closure_analysis/migrations/auto_traits.fixed
+++ b/src/test/ui/closures/2229_closure_analysis/migrations/auto_traits.fixed
@@ -1,10 +1,10 @@
// run-rustfix
-#![deny(disjoint_capture_migration)]
+#![deny(rust_2021_incompatible_closure_captures)]
use std::thread;
/* Test Send Trait Migration */
-struct SendPointer (*mut i32);
+struct SendPointer(*mut i32);
unsafe impl Send for SendPointer {}
fn test_send_trait() {
@@ -18,8 +18,8 @@ fn test_send_trait() {
}
/* Test Sync Trait Migration */
-struct CustomInt (*mut i32);
-struct SyncPointer (CustomInt);
+struct CustomInt(*mut i32);
+struct SyncPointer(CustomInt);
unsafe impl Sync for SyncPointer {}
unsafe impl Send for CustomInt {}
@@ -38,7 +38,7 @@ fn test_sync_trait() {
struct S(String);
struct T(i32);
-struct U(S,T);
+struct U(S, T);
impl Clone for U {
fn clone(&self) -> Self {
diff --git a/src/test/ui/closures/2229_closure_analysis/migrations/auto_traits.rs b/src/test/ui/closures/2229_closure_analysis/migrations/auto_traits.rs
index 7a6dcc55bbba6..b48a724f052f0 100644
--- a/src/test/ui/closures/2229_closure_analysis/migrations/auto_traits.rs
+++ b/src/test/ui/closures/2229_closure_analysis/migrations/auto_traits.rs
@@ -1,10 +1,10 @@
// run-rustfix
-#![deny(disjoint_capture_migration)]
+#![deny(rust_2021_incompatible_closure_captures)]
use std::thread;
/* Test Send Trait Migration */
-struct SendPointer (*mut i32);
+struct SendPointer(*mut i32);
unsafe impl Send for SendPointer {}
fn test_send_trait() {
@@ -18,8 +18,8 @@ fn test_send_trait() {
}
/* Test Sync Trait Migration */
-struct CustomInt (*mut i32);
-struct SyncPointer (CustomInt);
+struct CustomInt(*mut i32);
+struct SyncPointer(CustomInt);
unsafe impl Sync for SyncPointer {}
unsafe impl Send for CustomInt {}
@@ -38,7 +38,7 @@ fn test_sync_trait() {
struct S(String);
struct T(i32);
-struct U(S,T);
+struct U(S, T);
impl Clone for U {
fn clone(&self) -> Self {
diff --git a/src/test/ui/closures/2229_closure_analysis/migrations/auto_traits.stderr b/src/test/ui/closures/2229_closure_analysis/migrations/auto_traits.stderr
index d8420f9652e32..3d3dde15412bf 100644
--- a/src/test/ui/closures/2229_closure_analysis/migrations/auto_traits.stderr
+++ b/src/test/ui/closures/2229_closure_analysis/migrations/auto_traits.stderr
@@ -12,8 +12,8 @@ LL | | });
note: the lint level is defined here
--> $DIR/auto_traits.rs:2:9
|
-LL | #![deny(disjoint_capture_migration)]
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL | #![deny(rust_2021_incompatible_closure_captures)]
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
= note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/disjoint-capture-in-closures.html>
help: add a dummy let to cause `fptr` to be fully captured
|
diff --git a/src/test/ui/closures/2229_closure_analysis/migrations/insignificant_drop.fixed b/src/test/ui/closures/2229_closure_analysis/migrations/insignificant_drop.fixed
index 4bc9b19642f61..51d9c4881af3f 100644
--- a/src/test/ui/closures/2229_closure_analysis/migrations/insignificant_drop.fixed
+++ b/src/test/ui/closures/2229_closure_analysis/migrations/insignificant_drop.fixed
@@ -1,6 +1,6 @@
// run-rustfix
-#![deny(disjoint_capture_migration)]
+#![deny(rust_2021_incompatible_closure_captures)]
//~^ NOTE: the lint level is defined here
// Test cases for types that implement a insignificant drop (stlib defined)
@@ -13,9 +13,9 @@ fn test1_all_need_migration() {
let t2 = (String::new(), String::new());
let c = || { let _ = (&t, &t1, &t2);
- //~^ ERROR: drop order
- //~| NOTE: for more information, see
- //~| HELP: add a dummy let to cause `t`, `t1`, `t2` to be fully captured
+ //~^ ERROR: drop order
+ //~| NOTE: for more information, see
+ //~| HELP: add a dummy let to cause `t`, `t1`, `t2` to be fully captured
let _t = t.0;
let _t1 = t1.0;
@@ -33,9 +33,9 @@ fn test2_only_precise_paths_need_migration() {
let t2 = (String::new(), String::new());
let c = || { let _ = (&t, &t1);
- //~^ ERROR: drop order
- //~| NOTE: for more information, see
- //~| HELP: add a dummy let to cause `t`, `t1` to be fully captured
+ //~^ ERROR: drop order
+ //~| NOTE: for more information, see
+ //~| HELP: add a dummy let to cause `t`, `t1` to be fully captured
let _t = t.0;
let _t1 = t1.0;
let _t2 = t2;
@@ -50,9 +50,9 @@ fn test3_only_by_value_need_migration() {
let t = (String::new(), String::new());
let t1 = (String::new(), String::new());
let c = || { let _ = &t;
- //~^ ERROR: drop order
- //~| NOTE: for more information, see
- //~| HELP: add a dummy let to cause `t` to be fully captured
+ //~^ ERROR: drop order
+ //~| NOTE: for more information, see
+ //~| HELP: add a dummy let to cause `t` to be fully captured
let _t = t.0;
println!("{}", t1.1);
};
@@ -69,9 +69,9 @@ fn test4_only_non_copy_types_need_migration() {
let t1 = (0i32, 0i32);
let c = || { let _ = &t;
- //~^ ERROR: drop order
- //~| NOTE: for more information, see
- //~| HELP: add a dummy let to cause `t` to be fully captured
+ //~^ ERROR: drop order
+ //~| NOTE: for more information, see
+ //~| HELP: add a dummy let to cause `t` to be fully captured
let _t = t.0;
let _t1 = t1.0;
};
@@ -88,9 +88,9 @@ fn test5_only_drop_types_need_migration() {
let s = S(0i32, 0i32);
let c = || { let _ = &t;
- //~^ ERROR: drop order
- //~| NOTE: for more information, see
- //~| HELP: add a dummy let to cause `t` to be fully captured
+ //~^ ERROR: drop order
+ //~| NOTE: for more information, see
+ //~| HELP: add a dummy let to cause `t` to be fully captured
let _t = t.0;
let _s = s.0;
};
@@ -104,9 +104,9 @@ fn test6_move_closures_non_copy_types_might_need_migration() {
let t = (String::new(), String::new());
let t1 = (String::new(), String::new());
let c = move || { let _ = (&t1, &t);
- //~^ ERROR: drop order
- //~| NOTE: for more information, see
- //~| HELP: add a dummy let to cause `t1`, `t` to be fully captured
+ //~^ ERROR: drop order
+ //~| NOTE: for more information, see
+ //~| HELP: add a dummy let to cause `t1`, `t` to be fully captured
println!("{} {}", t1.1, t.1);
};
@@ -120,9 +120,9 @@ fn test7_drop_non_drop_aggregate_need_migration() {
let t = (String::new(), String::new(), 0i32);
let c = || { let _ = &t;
- //~^ ERROR: drop order
- //~| NOTE: for more information, see
- //~| HELP: add a dummy let to cause `t` to be fully captured
+ //~^ ERROR: drop order
+ //~| NOTE: for more information, see
+ //~| HELP: add a dummy let to cause `t` to be fully captured
let _t = t.0;
};
diff --git a/src/test/ui/closures/2229_closure_analysis/migrations/insignificant_drop.rs b/src/test/ui/closures/2229_closure_analysis/migrations/insignificant_drop.rs
index 446ce43a469de..c732cbb4fa51e 100644
--- a/src/test/ui/closures/2229_closure_analysis/migrations/insignificant_drop.rs
+++ b/src/test/ui/closures/2229_closure_analysis/migrations/insignificant_drop.rs
@@ -1,6 +1,6 @@
// run-rustfix
-#![deny(disjoint_capture_migration)]
+#![deny(rust_2021_incompatible_closure_captures)]
//~^ NOTE: the lint level is defined here
// Test cases for types that implement a insignificant drop (stlib defined)
@@ -13,9 +13,9 @@ fn test1_all_need_migration() {
let t2 = (String::new(), String::new());
let c = || {
- //~^ ERROR: drop order
- //~| NOTE: for more information, see
- //~| HELP: add a dummy let to cause `t`, `t1`, `t2` to be fully captured
+ //~^ ERROR: drop order
+ //~| NOTE: for more information, see
+ //~| HELP: add a dummy let to cause `t`, `t1`, `t2` to be fully captured
let _t = t.0;
let _t1 = t1.0;
@@ -33,9 +33,9 @@ fn test2_only_precise_paths_need_migration() {
let t2 = (String::new(), String::new());
let c = || {
- //~^ ERROR: drop order
- //~| NOTE: for more information, see
- //~| HELP: add a dummy let to cause `t`, `t1` to be fully captured
+ //~^ ERROR: drop order
+ //~| NOTE: for more information, see
+ //~| HELP: add a dummy let to cause `t`, `t1` to be fully captured
let _t = t.0;
let _t1 = t1.0;
let _t2 = t2;
@@ -50,9 +50,9 @@ fn test3_only_by_value_need_migration() {
let t = (String::new(), String::new());
let t1 = (String::new(), String::new());
let c = || {
- //~^ ERROR: drop order
- //~| NOTE: for more information, see
- //~| HELP: add a dummy let to cause `t` to be fully captured
+ //~^ ERROR: drop order
+ //~| NOTE: for more information, see
+ //~| HELP: add a dummy let to cause `t` to be fully captured
let _t = t.0;
println!("{}", t1.1);
};
@@ -69,9 +69,9 @@ fn test4_only_non_copy_types_need_migration() {
let t1 = (0i32, 0i32);
let c = || {
- //~^ ERROR: drop order
- //~| NOTE: for more information, see
- //~| HELP: add a dummy let to cause `t` to be fully captured
+ //~^ ERROR: drop order
+ //~| NOTE: for more information, see
+ //~| HELP: add a dummy let to cause `t` to be fully captured
let _t = t.0;
let _t1 = t1.0;
};
@@ -88,9 +88,9 @@ fn test5_only_drop_types_need_migration() {
let s = S(0i32, 0i32);
let c = || {
- //~^ ERROR: drop order
- //~| NOTE: for more information, see
- //~| HELP: add a dummy let to cause `t` to be fully captured
+ //~^ ERROR: drop order
+ //~| NOTE: for more information, see
+ //~| HELP: add a dummy let to cause `t` to be fully captured
let _t = t.0;
let _s = s.0;
};
@@ -104,9 +104,9 @@ fn test6_move_closures_non_copy_types_might_need_migration() {
let t = (String::new(), String::new());
let t1 = (String::new(), String::new());
let c = move || {
- //~^ ERROR: drop order
- //~| NOTE: for more information, see
- //~| HELP: add a dummy let to cause `t1`, `t` to be fully captured
+ //~^ ERROR: drop order
+ //~| NOTE: for more information, see
+ //~| HELP: add a dummy let to cause `t1`, `t` to be fully captured
println!("{} {}", t1.1, t.1);
};
@@ -120,9 +120,9 @@ fn test7_drop_non_drop_aggregate_need_migration() {
let t = (String::new(), String::new(), 0i32);
let c = || {
- //~^ ERROR: drop order
- //~| NOTE: for more information, see
- //~| HELP: add a dummy let to cause `t` to be fully captured
+ //~^ ERROR: drop order
+ //~| NOTE: for more information, see
+ //~| HELP: add a dummy let to cause `t` to be fully captured
let _t = t.0;
};
diff --git a/src/test/ui/closures/2229_closure_analysis/migrations/insignificant_drop.stderr b/src/test/ui/closures/2229_closure_analysis/migrations/insignificant_drop.stderr
index 0dfbcddc2795c..89a2b0eb95366 100644
--- a/src/test/ui/closures/2229_closure_analysis/migrations/insignificant_drop.stderr
+++ b/src/test/ui/closures/2229_closure_analysis/migrations/insignificant_drop.stderr
@@ -14,8 +14,8 @@ LL | | };
note: the lint level is defined here
--> $DIR/insignificant_drop.rs:3:9
|
-LL | #![deny(disjoint_capture_migration)]
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL | #![deny(rust_2021_incompatible_closure_captures)]
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
= note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/disjoint-capture-in-closures.html>
help: add a dummy let to cause `t`, `t1`, `t2` to be fully captured
|
diff --git a/src/test/ui/closures/2229_closure_analysis/migrations/insignificant_drop_attr_migrations.fixed b/src/test/ui/closures/2229_closure_analysis/migrations/insignificant_drop_attr_migrations.fixed
index 5a781219a72e0..8c85cd990d308 100644
--- a/src/test/ui/closures/2229_closure_analysis/migrations/insignificant_drop_attr_migrations.fixed
+++ b/src/test/ui/closures/2229_closure_analysis/migrations/insignificant_drop_attr_migrations.fixed
@@ -1,8 +1,7 @@
// run-rustfix
-#![deny(disjoint_capture_migration)]
+#![deny(rust_2021_incompatible_closure_captures)]
//~^ NOTE: the lint level is defined here
-
#![feature(rustc_attrs)]
#![allow(unused)]
@@ -36,9 +35,9 @@ fn significant_drop_needs_migration() {
let t = (SigDrop {}, SigDrop {});
let c = || { let _ = &t;
- //~^ ERROR: drop order
- //~| NOTE: for more information, see
- //~| HELP: add a dummy let to cause `t` to be fully captured
+ //~^ ERROR: drop order
+ //~| NOTE: for more information, see
+ //~| HELP: add a dummy let to cause `t` to be fully captured
let _t = t.0;
};
@@ -54,9 +53,9 @@ fn generic_struct_with_significant_drop_needs_migration() {
// move is used to force i32 to be copied instead of being a ref
let c = move || { let _ = &t;
- //~^ ERROR: drop order
- //~| NOTE: for more information, see
- //~| HELP: add a dummy let to cause `t` to be fully captured
+ //~^ ERROR: drop order
+ //~| NOTE: for more information, see
+ //~| HELP: add a dummy let to cause `t` to be fully captured
let _t = t.1;
};
diff --git a/src/test/ui/closures/2229_closure_analysis/migrations/insignificant_drop_attr_migrations.rs b/src/test/ui/closures/2229_closure_analysis/migrations/insignificant_drop_attr_migrations.rs
index d57da3265565e..17cee28e31117 100644
--- a/src/test/ui/closures/2229_closure_analysis/migrations/insignificant_drop_attr_migrations.rs
+++ b/src/test/ui/closures/2229_closure_analysis/migrations/insignificant_drop_attr_migrations.rs
@@ -1,8 +1,7 @@
// run-rustfix
-#![deny(disjoint_capture_migration)]
+#![deny(rust_2021_incompatible_closure_captures)]
//~^ NOTE: the lint level is defined here
-
#![feature(rustc_attrs)]
#![allow(unused)]
@@ -36,9 +35,9 @@ fn significant_drop_needs_migration() {
let t = (SigDrop {}, SigDrop {});
let c = || {
- //~^ ERROR: drop order
- //~| NOTE: for more information, see
- //~| HELP: add a dummy let to cause `t` to be fully captured
+ //~^ ERROR: drop order
+ //~| NOTE: for more information, see
+ //~| HELP: add a dummy let to cause `t` to be fully captured
let _t = t.0;
};
@@ -54,9 +53,9 @@ fn generic_struct_with_significant_drop_needs_migration() {
// move is used to force i32 to be copied instead of being a ref
let c = move || {
- //~^ ERROR: drop order
- //~| NOTE: for more information, see
- //~| HELP: add a dummy let to cause `t` to be fully captured
+ //~^ ERROR: drop order
+ //~| NOTE: for more information, see
+ //~| HELP: add a dummy let to cause `t` to be fully captured
let _t = t.1;
};
diff --git a/src/test/ui/closures/2229_closure_analysis/migrations/insignificant_drop_attr_migrations.stderr b/src/test/ui/closures/2229_closure_analysis/migrations/insignificant_drop_attr_migrations.stderr
index d25f8f635be88..1d3bda03d0e16 100644
--- a/src/test/ui/closures/2229_closure_analysis/migrations/insignificant_drop_attr_migrations.stderr
+++ b/src/test/ui/closures/2229_closure_analysis/migrations/insignificant_drop_attr_migrations.stderr
@@ -1,5 +1,5 @@
error: drop order will change in Rust 2021
- --> $DIR/insignificant_drop_attr_migrations.rs:38:13
+ --> $DIR/insignificant_drop_attr_migrations.rs:37:13
|
LL | let c = || {
| _____________^
@@ -13,8 +13,8 @@ LL | | };
note: the lint level is defined here
--> $DIR/insignificant_drop_attr_migrations.rs:3:9
|
-LL | #![deny(disjoint_capture_migration)]
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL | #![deny(rust_2021_incompatible_closure_captures)]
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
= note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/disjoint-capture-in-closures.html>
help: add a dummy let to cause `t` to be fully captured
|
@@ -27,7 +27,7 @@ LL | };
|
error: drop order will change in Rust 2021
- --> $DIR/insignificant_drop_attr_migrations.rs:56:13
+ --> $DIR/insignificant_drop_attr_migrations.rs:55:13
|
LL | let c = move || {
| _____________^
diff --git a/src/test/ui/closures/2229_closure_analysis/migrations/insignificant_drop_attr_no_migrations.rs b/src/test/ui/closures/2229_closure_analysis/migrations/insignificant_drop_attr_no_migrations.rs
index a00377456ac8d..a527bf42e574a 100644
--- a/src/test/ui/closures/2229_closure_analysis/migrations/insignificant_drop_attr_no_migrations.rs
+++ b/src/test/ui/closures/2229_closure_analysis/migrations/insignificant_drop_attr_no_migrations.rs
@@ -1,6 +1,6 @@
// run-pass
-#![deny(disjoint_capture_migration)]
+#![deny(rust_2021_incompatible_closure_captures)]
#![feature(rustc_attrs)]
#![allow(unused)]
diff --git a/src/test/ui/closures/2229_closure_analysis/migrations/issue-78720.rs b/src/test/ui/closures/2229_closure_analysis/migrations/issue-78720.rs
index ee3138ea69ee8..ff5d284614bf1 100644
--- a/src/test/ui/closures/2229_closure_analysis/migrations/issue-78720.rs
+++ b/src/test/ui/closures/2229_closure_analysis/migrations/issue-78720.rs
@@ -1,10 +1,10 @@
// run-pass
-#![warn(disjoint_capture_migration)]
+#![warn(rust_2021_incompatible_closure_captures)]
fn main() {
if let a = "" {
- //~^ WARNING: irrefutable `if let` pattern
+ //~^ WARNING: irrefutable `if let` pattern
drop(|_: ()| drop(a));
}
}
diff --git a/src/test/ui/closures/2229_closure_analysis/migrations/migrations_rustfix.fixed b/src/test/ui/closures/2229_closure_analysis/migrations/migrations_rustfix.fixed
index 42b6ce54d3c08..c974299c1536b 100644
--- a/src/test/ui/closures/2229_closure_analysis/migrations/migrations_rustfix.fixed
+++ b/src/test/ui/closures/2229_closure_analysis/migrations/migrations_rustfix.fixed
@@ -1,5 +1,5 @@
// run-rustfix
-#![deny(disjoint_capture_migration)]
+#![deny(rust_2021_incompatible_closure_captures)]
//~^ NOTE: the lint level is defined here
// Test the two possible cases for automated migartion using rustfix
diff --git a/src/test/ui/closures/2229_closure_analysis/migrations/migrations_rustfix.rs b/src/test/ui/closures/2229_closure_analysis/migrations/migrations_rustfix.rs
index ab0ed460fbaf4..dd9556aa56784 100644
--- a/src/test/ui/closures/2229_closure_analysis/migrations/migrations_rustfix.rs
+++ b/src/test/ui/closures/2229_closure_analysis/migrations/migrations_rustfix.rs
@@ -1,5 +1,5 @@
// run-rustfix
-#![deny(disjoint_capture_migration)]
+#![deny(rust_2021_incompatible_closure_captures)]
//~^ NOTE: the lint level is defined here
// Test the two possible cases for automated migartion using rustfix
diff --git a/src/test/ui/closures/2229_closure_analysis/migrations/migrations_rustfix.stderr b/src/test/ui/closures/2229_closure_analysis/migrations/migrations_rustfix.stderr
index 7b654f480a372..2d5e5e5e55c14 100644
--- a/src/test/ui/closures/2229_closure_analysis/migrations/migrations_rustfix.stderr
+++ b/src/test/ui/closures/2229_closure_analysis/migrations/migrations_rustfix.stderr
@@ -13,8 +13,8 @@ LL | | };
note: the lint level is defined here
--> $DIR/migrations_rustfix.rs:2:9
|
-LL | #![deny(disjoint_capture_migration)]
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL | #![deny(rust_2021_incompatible_closure_captures)]
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
= note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/disjoint-capture-in-closures.html>
help: add a dummy let to cause `t` to be fully captured
|
diff --git a/src/test/ui/closures/2229_closure_analysis/migrations/mir_calls_to_shims.fixed b/src/test/ui/closures/2229_closure_analysis/migrations/mir_calls_to_shims.fixed
index abff6802e9586..7f49b460ef63a 100644
--- a/src/test/ui/closures/2229_closure_analysis/migrations/mir_calls_to_shims.fixed
+++ b/src/test/ui/closures/2229_closure_analysis/migrations/mir_calls_to_shims.fixed
@@ -1,16 +1,20 @@
// run-rustfix
-#![deny(disjoint_capture_migration)]
+#![deny(rust_2021_incompatible_closure_captures)]
// ignore-wasm32-bare compiled with panic=abort by default
-
#![feature(fn_traits)]
#![feature(never_type)]
use std::panic;
-fn foo_diverges() -> ! { panic!() }
+fn foo_diverges() -> ! {
+ panic!()
+}
-fn assert_panics<F>(f: F) where F: FnOnce() {
+fn assert_panics<F>(f: F)
+where
+ F: FnOnce(),
+{
let f = panic::AssertUnwindSafe(f);
let result = panic::catch_unwind(move || { let _ = &f;
//~^ ERROR: `UnwindSafe`, `RefUnwindSafe` trait implementation
@@ -23,7 +27,8 @@ fn assert_panics<F>(f: F) where F: FnOnce() {
}
fn test_fn_ptr_panic<T>(mut t: T)
- where T: Fn() -> !
+where
+ T: Fn() -> !,
{
let as_fn = <T as Fn<()>>::call;
assert_panics(|| as_fn(&t, ()));
diff --git a/src/test/ui/closures/2229_closure_analysis/migrations/mir_calls_to_shims.rs b/src/test/ui/closures/2229_closure_analysis/migrations/mir_calls_to_shims.rs
index baa17e85b5217..3c654bec52605 100644
--- a/src/test/ui/closures/2229_closure_analysis/migrations/mir_calls_to_shims.rs
+++ b/src/test/ui/closures/2229_closure_analysis/migrations/mir_calls_to_shims.rs
@@ -1,16 +1,20 @@
// run-rustfix
-#![deny(disjoint_capture_migration)]
+#![deny(rust_2021_incompatible_closure_captures)]
// ignore-wasm32-bare compiled with panic=abort by default
-
#![feature(fn_traits)]
#![feature(never_type)]
use std::panic;
-fn foo_diverges() -> ! { panic!() }
+fn foo_diverges() -> ! {
+ panic!()
+}
-fn assert_panics<F>(f: F) where F: FnOnce() {
+fn assert_panics<F>(f: F)
+where
+ F: FnOnce(),
+{
let f = panic::AssertUnwindSafe(f);
let result = panic::catch_unwind(move || {
//~^ ERROR: `UnwindSafe`, `RefUnwindSafe` trait implementation
@@ -23,7 +27,8 @@ fn assert_panics<F>(f: F) where F: FnOnce() {
}
fn test_fn_ptr_panic<T>(mut t: T)
- where T: Fn() -> !
+where
+ T: Fn() -> !,
{
let as_fn = <T as Fn<()>>::call;
assert_panics(|| as_fn(&t, ()));
diff --git a/src/test/ui/closures/2229_closure_analysis/migrations/mir_calls_to_shims.stderr b/src/test/ui/closures/2229_closure_analysis/migrations/mir_calls_to_shims.stderr
index 8dca06a836ca3..dca5c454b83be 100644
--- a/src/test/ui/closures/2229_closure_analysis/migrations/mir_calls_to_shims.stderr
+++ b/src/test/ui/closures/2229_closure_analysis/migrations/mir_calls_to_shims.stderr
@@ -1,5 +1,5 @@
error: `UnwindSafe`, `RefUnwindSafe` trait implementation will change in Rust 2021
- --> $DIR/mir_calls_to_shims.rs:15:38
+ --> $DIR/mir_calls_to_shims.rs:19:38
|
LL | let result = panic::catch_unwind(move || {
| ______________________________________^
@@ -12,8 +12,8 @@ LL | | });
note: the lint level is defined here
--> $DIR/mir_calls_to_shims.rs:3:9
|
-LL | #![deny(disjoint_capture_migration)]
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL | #![deny(rust_2021_incompatible_closure_captures)]
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
= note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/disjoint-capture-in-closures.html>
help: add a dummy let to cause `f` to be fully captured
|
diff --git a/src/test/ui/closures/2229_closure_analysis/migrations/no_migrations.rs b/src/test/ui/closures/2229_closure_analysis/migrations/no_migrations.rs
index 420d66fba5e30..8b75e226ab59b 100644
--- a/src/test/ui/closures/2229_closure_analysis/migrations/no_migrations.rs
+++ b/src/test/ui/closures/2229_closure_analysis/migrations/no_migrations.rs
@@ -2,8 +2,7 @@
// Set of test cases that don't need migrations
-#![deny(disjoint_capture_migration)]
-
+#![deny(rust_2021_incompatible_closure_captures)]
// Copy types as copied by the closure instead of being moved into the closure
// Therefore their drop order isn't tied to the closure and won't be requiring any
@@ -53,7 +52,6 @@ fn test4_insignificant_drop_non_drop_aggregate() {
c();
}
-
struct Foo(i32);
impl Drop for Foo {
fn drop(&mut self) {
@@ -80,5 +78,4 @@ fn main() {
test3_only_copy_types_move_closure();
test4_insignificant_drop_non_drop_aggregate();
test5_significant_drop_non_drop_aggregate();
-
}
diff --git a/src/test/ui/closures/2229_closure_analysis/migrations/old_name.rs b/src/test/ui/closures/2229_closure_analysis/migrations/old_name.rs
new file mode 100644
index 0000000000000..16e3cca7b7714
--- /dev/null
+++ b/src/test/ui/closures/2229_closure_analysis/migrations/old_name.rs
@@ -0,0 +1,9 @@
+// check-pass
+
+// Ensure that the old name for `rust_2021_incompatible_closure_captures` is still
+// accepted by the compiler
+
+#![allow(disjoint_capture_migration)]
+//~^ WARN lint `disjoint_capture_migration` has been renamed
+
+fn main() {}
diff --git a/src/test/ui/closures/2229_closure_analysis/migrations/old_name.stderr b/src/test/ui/closures/2229_closure_analysis/migrations/old_name.stderr
new file mode 100644
index 0000000000000..47cb689fa0193
--- /dev/null
+++ b/src/test/ui/closures/2229_closure_analysis/migrations/old_name.stderr
@@ -0,0 +1,10 @@
+warning: lint `disjoint_capture_migration` has been renamed to `rust_2021_incompatible_closure_captures`
+ --> $DIR/old_name.rs:6:10
+ |
+LL | #![allow(disjoint_capture_migration)]
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `rust_2021_incompatible_closure_captures`
+ |
+ = note: `#[warn(renamed_and_removed_lints)]` on by default
+
+warning: 1 warning emitted
+
diff --git a/src/test/ui/closures/2229_closure_analysis/migrations/precise.fixed b/src/test/ui/closures/2229_closure_analysis/migrations/precise.fixed
index 90ea1ed28836d..ba5e5b573f1d6 100644
--- a/src/test/ui/closures/2229_closure_analysis/migrations/precise.fixed
+++ b/src/test/ui/closures/2229_closure_analysis/migrations/precise.fixed
@@ -1,6 +1,6 @@
// run-rustfix
-#![deny(disjoint_capture_migration)]
+#![deny(rust_2021_incompatible_closure_captures)]
#[derive(Debug)]
struct Foo(i32);
@@ -17,8 +17,8 @@ fn test_precise_analysis_drop_paths_not_captured_by_move() {
let t = ConstainsDropField(Foo(10), Foo(20));
let c = || { let _ = &t;
- //~^ ERROR: drop order
- //~| HELP: add a dummy let to cause `t` to be fully captured
+ //~^ ERROR: drop order
+ //~| HELP: add a dummy let to cause `t` to be fully captured
let _t = t.0;
let _t = &t.1;
};
@@ -28,8 +28,7 @@ fn test_precise_analysis_drop_paths_not_captured_by_move() {
struct S;
impl Drop for S {
- fn drop(&mut self) {
- }
+ fn drop(&mut self) {}
}
struct T(S, S);
@@ -40,8 +39,8 @@ fn test_precise_analysis_long_path_missing() {
let u = U(T(S, S), T(S, S));
let c = || { let _ = &u;
- //~^ ERROR: drop order
- //~| HELP: add a dummy let to cause `u` to be fully captured
+ //~^ ERROR: drop order
+ //~| HELP: add a dummy let to cause `u` to be fully captured
let _x = u.0.0;
let _x = u.0.1;
let _x = u.1.0;
diff --git a/src/test/ui/closures/2229_closure_analysis/migrations/precise.rs b/src/test/ui/closures/2229_closure_analysis/migrations/precise.rs
index cb43230459262..92b6f25c80dad 100644
--- a/src/test/ui/closures/2229_closure_analysis/migrations/precise.rs
+++ b/src/test/ui/closures/2229_closure_analysis/migrations/precise.rs
@@ -1,6 +1,6 @@
// run-rustfix
-#![deny(disjoint_capture_migration)]
+#![deny(rust_2021_incompatible_closure_captures)]
#[derive(Debug)]
struct Foo(i32);
@@ -17,8 +17,8 @@ fn test_precise_analysis_drop_paths_not_captured_by_move() {
let t = ConstainsDropField(Foo(10), Foo(20));
let c = || {
- //~^ ERROR: drop order
- //~| HELP: add a dummy let to cause `t` to be fully captured
+ //~^ ERROR: drop order
+ //~| HELP: add a dummy let to cause `t` to be fully captured
let _t = t.0;
let _t = &t.1;
};
@@ -28,8 +28,7 @@ fn test_precise_analysis_drop_paths_not_captured_by_move() {
struct S;
impl Drop for S {
- fn drop(&mut self) {
- }
+ fn drop(&mut self) {}
}
struct T(S, S);
@@ -40,8 +39,8 @@ fn test_precise_analysis_long_path_missing() {
let u = U(T(S, S), T(S, S));
let c = || {
- //~^ ERROR: drop order
- //~| HELP: add a dummy let to cause `u` to be fully captured
+ //~^ ERROR: drop order
+ //~| HELP: add a dummy let to cause `u` to be fully captured
let _x = u.0.0;
let _x = u.0.1;
let _x = u.1.0;
diff --git a/src/test/ui/closures/2229_closure_analysis/migrations/precise.stderr b/src/test/ui/closures/2229_closure_analysis/migrations/precise.stderr
index f010c51f1361e..2788207296f11 100644
--- a/src/test/ui/closures/2229_closure_analysis/migrations/precise.stderr
+++ b/src/test/ui/closures/2229_closure_analysis/migrations/precise.stderr
@@ -13,8 +13,8 @@ LL | | };
note: the lint level is defined here
--> $DIR/precise.rs:3:9
|
-LL | #![deny(disjoint_capture_migration)]
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL | #![deny(rust_2021_incompatible_closure_captures)]
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
= note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/disjoint-capture-in-closures.html>
help: add a dummy let to cause `t` to be fully captured
|
@@ -27,7 +27,7 @@ LL | };
|
error: drop order will change in Rust 2021
- --> $DIR/precise.rs:42:13
+ --> $DIR/precise.rs:41:13
|
LL | let c = || {
| _____________^
diff --git a/src/test/ui/closures/2229_closure_analysis/migrations/precise_no_migrations.rs b/src/test/ui/closures/2229_closure_analysis/migrations/precise_no_migrations.rs
index e3a7220bf09d2..587d71c40fc69 100644
--- a/src/test/ui/closures/2229_closure_analysis/migrations/precise_no_migrations.rs
+++ b/src/test/ui/closures/2229_closure_analysis/migrations/precise_no_migrations.rs
@@ -1,6 +1,6 @@
// run-pass
-#![deny(disjoint_capture_migration)]
+#![deny(rust_2021_incompatible_closure_captures)]
#[derive(Debug)]
struct Foo(i32);
@@ -73,8 +73,7 @@ fn test_precise_analysis_parent_captured_2() {
struct S;
impl Drop for S {
- fn drop(&mut self) {
- }
+ fn drop(&mut self) {}
}
struct T(S, S);
diff --git a/src/test/ui/closures/2229_closure_analysis/migrations/significant_drop.fixed b/src/test/ui/closures/2229_closure_analysis/migrations/significant_drop.fixed
index 1c970175d182d..58ed2de26b3a7 100644
--- a/src/test/ui/closures/2229_closure_analysis/migrations/significant_drop.fixed
+++ b/src/test/ui/closures/2229_closure_analysis/migrations/significant_drop.fixed
@@ -1,5 +1,5 @@
// run-rustfix
-#![deny(disjoint_capture_migration)]
+#![deny(rust_2021_incompatible_closure_captures)]
//~^ NOTE: the lint level is defined here
// Test cases for types that implement a significant drop (user defined)
@@ -23,9 +23,9 @@ fn test1_all_need_migration() {
let t2 = (Foo(0), Foo(0));
let c = || { let _ = (&t, &t1, &t2);
- //~^ ERROR: drop order
- //~| NOTE: for more information, see
- //~| HELP: add a dummy let to cause `t`, `t1`, `t2` to be fully captured
+ //~^ ERROR: drop order
+ //~| NOTE: for more information, see
+ //~| HELP: add a dummy let to cause `t`, `t1`, `t2` to be fully captured
let _t = t.0;
let _t1 = t1.0;
let _t2 = t2.0;
@@ -42,9 +42,9 @@ fn test2_only_precise_paths_need_migration() {
let t2 = (Foo(0), Foo(0));
let c = || { let _ = (&t, &t1);
- //~^ ERROR: drop order
- //~| NOTE: for more information, see
- //~| HELP: add a dummy let to cause `t`, `t1` to be fully captured
+ //~^ ERROR: drop order
+ //~| NOTE: for more information, see
+ //~| HELP: add a dummy let to cause `t`, `t1` to be fully captured
let _t = t.0;
let _t1 = t1.0;
let _t2 = t2;
@@ -59,9 +59,9 @@ fn test3_only_by_value_need_migration() {
let t = (Foo(0), Foo(0));
let t1 = (Foo(0), Foo(0));
let c = || { let _ = &t;
- //~^ ERROR: drop order
- //~| NOTE: for more information, see
- //~| HELP: add a dummy let to cause `t` to be fully captured
+ //~^ ERROR: drop order
+ //~| NOTE: for more information, see
+ //~| HELP: add a dummy let to cause `t` to be fully captured
let _t = t.0;
println!("{:?}", t1.1);
};
@@ -77,9 +77,9 @@ fn test4_type_contains_drop_need_migration() {
let t = ConstainsDropField(Foo(0), Foo(0));
let c = || { let _ = &t;
- //~^ ERROR: drop order
- //~| NOTE: for more information, see
- //~| HELP: add a dummy let to cause `t` to be fully captured
+ //~^ ERROR: drop order
+ //~| NOTE: for more information, see
+ //~| HELP: add a dummy let to cause `t` to be fully captured
let _t = t.0;
};
@@ -93,9 +93,9 @@ fn test5_drop_non_drop_aggregate_need_migration() {
let t = (Foo(0), Foo(0), 0i32);
let c = || { let _ = &t;
- //~^ ERROR: drop order
- //~| NOTE: for more information, see
- //~| HELP: add a dummy let to cause `t` to be fully captured
+ //~^ ERROR: drop order
+ //~| NOTE: for more information, see
+ //~| HELP: add a dummy let to cause `t` to be fully captured
let _t = t.0;
};
@@ -107,9 +107,9 @@ fn test6_significant_insignificant_drop_aggregate_need_migration() {
let t = (Foo(0), String::new());
let c = || { let _ = &t;
- //~^ ERROR: drop order
- //~| NOTE: for more information, see
- //~| HELP: add a dummy let to cause `t` to be fully captured
+ //~^ ERROR: drop order
+ //~| NOTE: for more information, see
+ //~| HELP: add a dummy let to cause `t` to be fully captured
let _t = t.1;
};
@@ -123,9 +123,9 @@ fn test7_move_closures_non_copy_types_might_need_migration() {
let t1 = (Foo(0), Foo(0), Foo(0));
let c = move || { let _ = (&t1, &t);
- //~^ ERROR: drop order
- //~| NOTE: for more information, see
- //~| HELP: add a dummy let to cause `t1`, `t` to be fully captured
+ //~^ ERROR: drop order
+ //~| NOTE: for more information, see
+ //~| HELP: add a dummy let to cause `t1`, `t` to be fully captured
println!("{:?} {:?}", t1.1, t.1);
};
diff --git a/src/test/ui/closures/2229_closure_analysis/migrations/significant_drop.rs b/src/test/ui/closures/2229_closure_analysis/migrations/significant_drop.rs
index c479a6a54f09b..0890fc1c21256 100644
--- a/src/test/ui/closures/2229_closure_analysis/migrations/significant_drop.rs
+++ b/src/test/ui/closures/2229_closure_analysis/migrations/significant_drop.rs
@@ -1,5 +1,5 @@
// run-rustfix
-#![deny(disjoint_capture_migration)]
+#![deny(rust_2021_incompatible_closure_captures)]
//~^ NOTE: the lint level is defined here
// Test cases for types that implement a significant drop (user defined)
@@ -23,9 +23,9 @@ fn test1_all_need_migration() {
let t2 = (Foo(0), Foo(0));
let c = || {
- //~^ ERROR: drop order
- //~| NOTE: for more information, see
- //~| HELP: add a dummy let to cause `t`, `t1`, `t2` to be fully captured
+ //~^ ERROR: drop order
+ //~| NOTE: for more information, see
+ //~| HELP: add a dummy let to cause `t`, `t1`, `t2` to be fully captured
let _t = t.0;
let _t1 = t1.0;
let _t2 = t2.0;
@@ -42,9 +42,9 @@ fn test2_only_precise_paths_need_migration() {
let t2 = (Foo(0), Foo(0));
let c = || {
- //~^ ERROR: drop order
- //~| NOTE: for more information, see
- //~| HELP: add a dummy let to cause `t`, `t1` to be fully captured
+ //~^ ERROR: drop order
+ //~| NOTE: for more information, see
+ //~| HELP: add a dummy let to cause `t`, `t1` to be fully captured
let _t = t.0;
let _t1 = t1.0;
let _t2 = t2;
@@ -59,9 +59,9 @@ fn test3_only_by_value_need_migration() {
let t = (Foo(0), Foo(0));
let t1 = (Foo(0), Foo(0));
let c = || {
- //~^ ERROR: drop order
- //~| NOTE: for more information, see
- //~| HELP: add a dummy let to cause `t` to be fully captured
+ //~^ ERROR: drop order
+ //~| NOTE: for more information, see
+ //~| HELP: add a dummy let to cause `t` to be fully captured
let _t = t.0;
println!("{:?}", t1.1);
};
@@ -77,9 +77,9 @@ fn test4_type_contains_drop_need_migration() {
let t = ConstainsDropField(Foo(0), Foo(0));
let c = || {
- //~^ ERROR: drop order
- //~| NOTE: for more information, see
- //~| HELP: add a dummy let to cause `t` to be fully captured
+ //~^ ERROR: drop order
+ //~| NOTE: for more information, see
+ //~| HELP: add a dummy let to cause `t` to be fully captured
let _t = t.0;
};
@@ -93,9 +93,9 @@ fn test5_drop_non_drop_aggregate_need_migration() {
let t = (Foo(0), Foo(0), 0i32);
let c = || {
- //~^ ERROR: drop order
- //~| NOTE: for more information, see
- //~| HELP: add a dummy let to cause `t` to be fully captured
+ //~^ ERROR: drop order
+ //~| NOTE: for more information, see
+ //~| HELP: add a dummy let to cause `t` to be fully captured
let _t = t.0;
};
@@ -107,9 +107,9 @@ fn test6_significant_insignificant_drop_aggregate_need_migration() {
let t = (Foo(0), String::new());
let c = || {
- //~^ ERROR: drop order
- //~| NOTE: for more information, see
- //~| HELP: add a dummy let to cause `t` to be fully captured
+ //~^ ERROR: drop order
+ //~| NOTE: for more information, see
+ //~| HELP: add a dummy let to cause `t` to be fully captured
let _t = t.1;
};
@@ -123,9 +123,9 @@ fn test7_move_closures_non_copy_types_might_need_migration() {
let t1 = (Foo(0), Foo(0), Foo(0));
let c = move || {
- //~^ ERROR: drop order
- //~| NOTE: for more information, see
- //~| HELP: add a dummy let to cause `t1`, `t` to be fully captured
+ //~^ ERROR: drop order
+ //~| NOTE: for more information, see
+ //~| HELP: add a dummy let to cause `t1`, `t` to be fully captured
println!("{:?} {:?}", t1.1, t.1);
};
diff --git a/src/test/ui/closures/2229_closure_analysis/migrations/significant_drop.stderr b/src/test/ui/closures/2229_closure_analysis/migrations/significant_drop.stderr
index 873a9100bee4b..ebf9f169fd400 100644
--- a/src/test/ui/closures/2229_closure_analysis/migrations/significant_drop.stderr
+++ b/src/test/ui/closures/2229_closure_analysis/migrations/significant_drop.stderr
@@ -14,8 +14,8 @@ LL | | };
note: the lint level is defined here
--> $DIR/significant_drop.rs:2:9
|
-LL | #![deny(disjoint_capture_migration)]
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL | #![deny(rust_2021_incompatible_closure_captures)]
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
= note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/disjoint-capture-in-closures.html>
help: add a dummy let to cause `t`, `t1`, `t2` to be fully captured
|
diff --git a/src/test/ui/consts/const-eval/const_panic.rs b/src/test/ui/consts/const-eval/const_panic.rs
index 5807c5659b615..e4455d86a1440 100644
--- a/src/test/ui/consts/const-eval/const_panic.rs
+++ b/src/test/ui/consts/const-eval/const_panic.rs
@@ -1,5 +1,5 @@
#![feature(const_panic)]
-#![allow(non_fmt_panic)]
+#![allow(non_fmt_panics)]
#![crate_type = "lib"]
const MSG: &str = "hello";
diff --git a/src/test/ui/fmt/format-args-capture.rs b/src/test/ui/fmt/format-args-capture.rs
index 6c97a807b052b..b30e9a47a13e8 100644
--- a/src/test/ui/fmt/format-args-capture.rs
+++ b/src/test/ui/fmt/format-args-capture.rs
@@ -16,13 +16,13 @@ fn main() {
fn named_argument_takes_precedence_to_captured() {
let foo = "captured";
- let s = format!("{foo}", foo="named");
+ let s = format!("{foo}", foo = "named");
assert_eq!(&s, "named");
- let s = format!("{foo}-{foo}-{foo}", foo="named");
+ let s = format!("{foo}-{foo}-{foo}", foo = "named");
assert_eq!(&s, "named-named-named");
- let s = format!("{}-{bar}-{foo}", "positional", bar="named");
+ let s = format!("{}-{bar}-{foo}", "positional", bar = "named");
assert_eq!(&s, "positional-named-captured");
}
@@ -42,10 +42,11 @@ fn panic_with_single_argument_does_not_get_formatted() {
// RFC #2795 suggests that this may need to change so that captured arguments are formatted.
// For stability reasons this will need to part of an edition change.
- #[allow(non_fmt_panic)]
+ #[allow(non_fmt_panics)]
let msg = std::panic::catch_unwind(|| {
panic!("{foo}");
- }).unwrap_err();
+ })
+ .unwrap_err();
assert_eq!(msg.downcast_ref::<&str>(), Some(&"{foo}"))
}
@@ -55,8 +56,9 @@ fn panic_with_multiple_arguments_is_formatted() {
let foo = "captured";
let msg = std::panic::catch_unwind(|| {
- panic!("{}-{bar}-{foo}", "positional", bar="named");
- }).unwrap_err();
+ panic!("{}-{bar}-{foo}", "positional", bar = "named");
+ })
+ .unwrap_err();
assert_eq!(msg.downcast_ref::<String>(), Some(&"positional-named-captured".to_string()))
}
diff --git a/src/test/ui/macros/assert-macro-owned.rs b/src/test/ui/macros/assert-macro-owned.rs
index 2846f2a1f8353..753675872b9ca 100644
--- a/src/test/ui/macros/assert-macro-owned.rs
+++ b/src/test/ui/macros/assert-macro-owned.rs
@@ -2,7 +2,7 @@
// error-pattern:panicked at 'test-assert-owned'
// ignore-emscripten no processes
-#![allow(non_fmt_panic)]
+#![allow(non_fmt_panics)]
fn main() {
assert!(false, "test-assert-owned".to_string());
diff --git a/src/test/ui/macros/macro-comma-behavior-rpass.rs b/src/test/ui/macros/macro-comma-behavior-rpass.rs
index fd2c590ae5fd6..780e158fe0b8f 100644
--- a/src/test/ui/macros/macro-comma-behavior-rpass.rs
+++ b/src/test/ui/macros/macro-comma-behavior-rpass.rs
@@ -14,11 +14,12 @@
// revisions: std core
// ignore-wasm32-bare compiled with panic=abort by default
-
#![cfg_attr(core, no_std)]
-#[cfg(std)] use std::fmt;
-#[cfg(core)] use core::fmt;
+#[cfg(core)]
+use core::fmt;
+#[cfg(std)]
+use std::fmt;
// an easy mistake in the implementation of 'assert!'
// would cause this to say "explicit panic"
@@ -57,7 +58,7 @@ fn writeln_1arg() {
//
// (Example: Issue #48042)
#[test]
-#[allow(non_fmt_panic)]
+#[allow(non_fmt_panics)]
fn to_format_or_not_to_format() {
// ("{}" is the easiest string to test because if this gets
// sent to format_args!, it'll simply fail to compile.
@@ -80,13 +81,17 @@ fn to_format_or_not_to_format() {
// format!("{}",); // see check-fail
// format_args!("{}",); // see check-fail
- if falsum() { panic!("{}",); }
+ if falsum() {
+ panic!("{}",);
+ }
// print!("{}",); // see check-fail
// println!("{}",); // see check-fail
// unimplemented!("{}",); // see check-fail
- if falsum() { unreachable!("{}",); }
+ if falsum() {
+ unreachable!("{}",);
+ }
// write!(&mut stdout, "{}",); // see check-fail
// writeln!(&mut stdout, "{}",); // see check-fail
diff --git a/src/test/ui/macros/macro-or-patterns-back-compat.fixed b/src/test/ui/macros/macro-or-patterns-back-compat.fixed
index f5a42670fdd1c..b0d56e9bb1ef0 100644
--- a/src/test/ui/macros/macro-or-patterns-back-compat.fixed
+++ b/src/test/ui/macros/macro-or-patterns-back-compat.fixed
@@ -1,7 +1,7 @@
// run-rustfix
// aux-build:or-pattern.rs
-#![deny(or_patterns_back_compat)]
+#![deny(rust_2021_incompatible_or_patterns)]
#![allow(unused_macros)]
#[macro_use]
diff --git a/src/test/ui/macros/macro-or-patterns-back-compat.rs b/src/test/ui/macros/macro-or-patterns-back-compat.rs
index d6620f45f6270..9e24b5106b8bf 100644
--- a/src/test/ui/macros/macro-or-patterns-back-compat.rs
+++ b/src/test/ui/macros/macro-or-patterns-back-compat.rs
@@ -1,7 +1,7 @@
// run-rustfix
// aux-build:or-pattern.rs
-#![deny(or_patterns_back_compat)]
+#![deny(rust_2021_incompatible_or_patterns)]
#![allow(unused_macros)]
#[macro_use]
diff --git a/src/test/ui/macros/macro-or-patterns-back-compat.stderr b/src/test/ui/macros/macro-or-patterns-back-compat.stderr
index a48c926315403..eb6204fa02e69 100644
--- a/src/test/ui/macros/macro-or-patterns-back-compat.stderr
+++ b/src/test/ui/macros/macro-or-patterns-back-compat.stderr
@@ -7,8 +7,8 @@ LL | macro_rules! foo { ($x:pat | $y:pat) => {} }
note: the lint level is defined here
--> $DIR/macro-or-patterns-back-compat.rs:4:9
|
-LL | #![deny(or_patterns_back_compat)]
- | ^^^^^^^^^^^^^^^^^^^^^^^
+LL | #![deny(rust_2021_incompatible_or_patterns)]
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
= warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
= note: for more information, see issue #84869 <https://github.com/rust-lang/rust/issues/84869>
diff --git a/src/test/ui/non-fmt-panic.stderr b/src/test/ui/non-fmt-panic.stderr
index 0f451c1e0a9a3..6aa2eb174e922 100644
--- a/src/test/ui/non-fmt-panic.stderr
+++ b/src/test/ui/non-fmt-panic.stderr
@@ -4,7 +4,7 @@ warning: panic message contains a brace
LL | panic!("here's a brace: {");
| ^
|
- = note: `#[warn(non_fmt_panic)]` on by default
+ = note: `#[warn(non_fmt_panics)]` on by default
= note: this message is not used as a format string, but will be in Rust 2021
help: add a "{}" format string to use the message literally
|
diff --git a/src/test/ui/panics/explicit-panic-msg.rs b/src/test/ui/panics/explicit-panic-msg.rs
index bfcc12cd186bd..9d80357873488 100644
--- a/src/test/ui/panics/explicit-panic-msg.rs
+++ b/src/test/ui/panics/explicit-panic-msg.rs
@@ -1,6 +1,6 @@
#![allow(unused_assignments)]
#![allow(unused_variables)]
-#![allow(non_fmt_panic)]
+#![allow(non_fmt_panics)]
// run-fail
// error-pattern:wooooo
diff --git a/src/test/ui/panics/panic-macro-any-wrapped.rs b/src/test/ui/panics/panic-macro-any-wrapped.rs
index 100ac10c76717..663bf6713d090 100644
--- a/src/test/ui/panics/panic-macro-any-wrapped.rs
+++ b/src/test/ui/panics/panic-macro-any-wrapped.rs
@@ -2,7 +2,7 @@
// error-pattern:panicked at 'Box<dyn Any>'
// ignore-emscripten no processes
-#![allow(non_fmt_panic)]
+#![allow(non_fmt_panics)]
fn main() {
panic!(Box::new(612_i64));
diff --git a/src/test/ui/panics/panic-macro-any.rs b/src/test/ui/panics/panic-macro-any.rs
index a5ba30220e89a..08acc6e8078f9 100644
--- a/src/test/ui/panics/panic-macro-any.rs
+++ b/src/test/ui/panics/panic-macro-any.rs
@@ -3,7 +3,7 @@
// ignore-emscripten no processes
#![feature(box_syntax)]
-#![allow(non_fmt_panic)]
+#![allow(non_fmt_panics)]
fn main() {
panic!(box 413 as Box<dyn std::any::Any + Send>);
diff --git a/src/test/ui/rust-2021/future-prelude-collision-imported.fixed b/src/test/ui/rust-2021/future-prelude-collision-imported.fixed
index 725d5aa234eee..c5ff0b4bcd0f8 100644
--- a/src/test/ui/rust-2021/future-prelude-collision-imported.fixed
+++ b/src/test/ui/rust-2021/future-prelude-collision-imported.fixed
@@ -1,7 +1,7 @@
// run-rustfix
// edition:2018
// check-pass
-#![warn(future_prelude_collision)]
+#![warn(rust_2021_prelude_collisions)]
#![allow(dead_code)]
#![allow(unused_imports)]
diff --git a/src/test/ui/rust-2021/future-prelude-collision-imported.rs b/src/test/ui/rust-2021/future-prelude-collision-imported.rs
index 6ca9a919f3cd7..cd39eec47f2a4 100644
--- a/src/test/ui/rust-2021/future-prelude-collision-imported.rs
+++ b/src/test/ui/rust-2021/future-prelude-collision-imported.rs
@@ -1,7 +1,7 @@
// run-rustfix
// edition:2018
// check-pass
-#![warn(future_prelude_collision)]
+#![warn(rust_2021_prelude_collisions)]
#![allow(dead_code)]
#![allow(unused_imports)]
diff --git a/src/test/ui/rust-2021/future-prelude-collision-imported.stderr b/src/test/ui/rust-2021/future-prelude-collision-imported.stderr
index 8889485c91729..6197587681922 100644
--- a/src/test/ui/rust-2021/future-prelude-collision-imported.stderr
+++ b/src/test/ui/rust-2021/future-prelude-collision-imported.stderr
@@ -7,8 +7,8 @@ LL | let _: u32 = 3u8.try_into().unwrap();
note: the lint level is defined here
--> $DIR/future-prelude-collision-imported.rs:4:9
|
-LL | #![warn(future_prelude_collision)]
- | ^^^^^^^^^^^^^^^^^^^^^^^^
+LL | #![warn(rust_2021_prelude_collisions)]
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
= warning: this is accepted in the current edition (Rust 2018) but is a hard error in Rust 2021!
= note: for more information, see issue #85684 <https://github.com/rust-lang/rust/issues/85684>
diff --git a/src/test/ui/rust-2021/future-prelude-collision-shadow.rs b/src/test/ui/rust-2021/future-prelude-collision-shadow.rs
index c9d2529341f4f..27891a8d11db7 100644
--- a/src/test/ui/rust-2021/future-prelude-collision-shadow.rs
+++ b/src/test/ui/rust-2021/future-prelude-collision-shadow.rs
@@ -1,5 +1,5 @@
// edition:2018
-#![warn(future_prelude_collision)]
+#![warn(rust_2021_prelude_collisions)]
#![allow(dead_code)]
#![allow(unused_imports)]
diff --git a/src/test/ui/rust-2021/future-prelude-collision-unneeded.rs b/src/test/ui/rust-2021/future-prelude-collision-unneeded.rs
index a4a5b6667df8c..4be82056ad59b 100644
--- a/src/test/ui/rust-2021/future-prelude-collision-unneeded.rs
+++ b/src/test/ui/rust-2021/future-prelude-collision-unneeded.rs
@@ -1,12 +1,14 @@
// edition:2018
// check-pass
#![allow(unused)]
-#![deny(future_prelude_collision)]
+#![deny(rust_2021_prelude_collisions)]
struct S;
impl S {
- fn try_into(self) -> S { S }
+ fn try_into(self) -> S {
+ S
+ }
}
// See https://github.com/rust-lang/rust/issues/86633
diff --git a/src/test/ui/rust-2021/future-prelude-collision.fixed b/src/test/ui/rust-2021/future-prelude-collision.fixed
index 4bcbe6b094afd..43b0ec1c3e6a7 100644
--- a/src/test/ui/rust-2021/future-prelude-collision.fixed
+++ b/src/test/ui/rust-2021/future-prelude-collision.fixed
@@ -1,7 +1,7 @@
// run-rustfix
// edition:2018
// check-pass
-#![warn(future_prelude_collision)]
+#![warn(rust_2021_prelude_collisions)]
trait TryIntoU32 {
fn try_into(self) -> Result<u32, ()>;
diff --git a/src/test/ui/rust-2021/future-prelude-collision.rs b/src/test/ui/rust-2021/future-prelude-collision.rs
index bc23a8a92a6b5..4c7a47ffbe28a 100644
--- a/src/test/ui/rust-2021/future-prelude-collision.rs
+++ b/src/test/ui/rust-2021/future-prelude-collision.rs
@@ -1,7 +1,7 @@
// run-rustfix
// edition:2018
// check-pass
-#![warn(future_prelude_collision)]
+#![warn(rust_2021_prelude_collisions)]
trait TryIntoU32 {
fn try_into(self) -> Result<u32, ()>;
diff --git a/src/test/ui/rust-2021/future-prelude-collision.stderr b/src/test/ui/rust-2021/future-prelude-collision.stderr
index e167468ab1971..03b89da00d970 100644
--- a/src/test/ui/rust-2021/future-prelude-collision.stderr
+++ b/src/test/ui/rust-2021/future-prelude-collision.stderr
@@ -7,8 +7,8 @@ LL | let _: u32 = 3u8.try_into().unwrap();
note: the lint level is defined here
--> $DIR/future-prelude-collision.rs:4:9
|
-LL | #![warn(future_prelude_collision)]
- | ^^^^^^^^^^^^^^^^^^^^^^^^
+LL | #![warn(rust_2021_prelude_collisions)]
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
= warning: this is accepted in the current edition (Rust 2018) but is a hard error in Rust 2021!
= note: for more information, see issue #85684 <https://github.com/rust-lang/rust/issues/85684>
diff --git a/src/test/ui/rust-2021/generic-type-collision.fixed b/src/test/ui/rust-2021/generic-type-collision.fixed
index d1a085f23a01c..feba7d19b6615 100644
--- a/src/test/ui/rust-2021/generic-type-collision.fixed
+++ b/src/test/ui/rust-2021/generic-type-collision.fixed
@@ -1,7 +1,7 @@
// check-pass
// run-rustfix
// edition 2018
-#![warn(future_prelude_collision)]
+#![warn(rust_2021_prelude_collisions)]
trait MyTrait<A> {
fn from_iter(x: Option<A>);
diff --git a/src/test/ui/rust-2021/generic-type-collision.rs b/src/test/ui/rust-2021/generic-type-collision.rs
index 5069fba396ec6..335e7e520a495 100644
--- a/src/test/ui/rust-2021/generic-type-collision.rs
+++ b/src/test/ui/rust-2021/generic-type-collision.rs
@@ -1,7 +1,7 @@
// check-pass
// run-rustfix
// edition 2018
-#![warn(future_prelude_collision)]
+#![warn(rust_2021_prelude_collisions)]
trait MyTrait<A> {
fn from_iter(x: Option<A>);
diff --git a/src/test/ui/rust-2021/generic-type-collision.stderr b/src/test/ui/rust-2021/generic-type-collision.stderr
index 05591c3d4487d..d4999201c27f9 100644
--- a/src/test/ui/rust-2021/generic-type-collision.stderr
+++ b/src/test/ui/rust-2021/generic-type-collision.stderr
@@ -7,8 +7,8 @@ LL | <Vec<i32>>::from_iter(None);
note: the lint level is defined here
--> $DIR/generic-type-collision.rs:4:9
|
-LL | #![warn(future_prelude_collision)]
- | ^^^^^^^^^^^^^^^^^^^^^^^^
+LL | #![warn(rust_2021_prelude_collisions)]
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
= warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
= note: for more information, see issue #85684 <https://github.com/rust-lang/rust/issues/85684>
diff --git a/src/test/ui/rust-2021/inherent-dyn-collision.fixed b/src/test/ui/rust-2021/inherent-dyn-collision.fixed
index cf6287a758f91..5789a90393bae 100644
--- a/src/test/ui/rust-2021/inherent-dyn-collision.fixed
+++ b/src/test/ui/rust-2021/inherent-dyn-collision.fixed
@@ -5,7 +5,7 @@
// run-rustfix
// edition:2018
-#![warn(future_prelude_collision)]
+#![warn(rust_2021_prelude_collisions)]
trait TryIntoU32 {
fn try_into(&self) -> Result<u32, ()>;
diff --git a/src/test/ui/rust-2021/inherent-dyn-collision.rs b/src/test/ui/rust-2021/inherent-dyn-collision.rs
index 0349ad5b6415a..a3893c033e942 100644
--- a/src/test/ui/rust-2021/inherent-dyn-collision.rs
+++ b/src/test/ui/rust-2021/inherent-dyn-collision.rs
@@ -5,7 +5,7 @@
// run-rustfix
// edition:2018
-#![warn(future_prelude_collision)]
+#![warn(rust_2021_prelude_collisions)]
trait TryIntoU32 {
fn try_into(&self) -> Result<u32, ()>;
diff --git a/src/test/ui/rust-2021/inherent-dyn-collision.stderr b/src/test/ui/rust-2021/inherent-dyn-collision.stderr
index 9e95419715e31..605f9ced9ebb7 100644
--- a/src/test/ui/rust-2021/inherent-dyn-collision.stderr
+++ b/src/test/ui/rust-2021/inherent-dyn-collision.stderr
@@ -7,8 +7,8 @@ LL | get_dyn_trait().try_into().unwrap()
note: the lint level is defined here
--> $DIR/inherent-dyn-collision.rs:8:9
|
-LL | #![warn(future_prelude_collision)]
- | ^^^^^^^^^^^^^^^^^^^^^^^^
+LL | #![warn(rust_2021_prelude_collisions)]
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
= warning: this is accepted in the current edition (Rust 2018) but is a hard error in Rust 2021!
= note: for more information, see issue #85684 <https://github.com/rust-lang/rust/issues/85684>
diff --git a/src/test/ui/rust-2021/inherent-method-collision.rs b/src/test/ui/rust-2021/inherent-method-collision.rs
index c638351d5fc09..507105207d695 100644
--- a/src/test/ui/rust-2021/inherent-method-collision.rs
+++ b/src/test/ui/rust-2021/inherent-method-collision.rs
@@ -2,7 +2,7 @@
//
// check-pass
-#![deny(future_prelude_collision)]
+#![deny(rust_2021_prelude_collisions)]
pub struct MySeq {}
diff --git a/src/test/ui/rust-2021/reserved-prefixes-migration.fixed b/src/test/ui/rust-2021/reserved-prefixes-migration.fixed
index dbc2ec6d42ee2..e026f01e93fb0 100644
--- a/src/test/ui/rust-2021/reserved-prefixes-migration.fixed
+++ b/src/test/ui/rust-2021/reserved-prefixes-migration.fixed
@@ -2,7 +2,7 @@
// run-rustfix
// compile-flags: -Z unstable-options --edition 2018
-#![warn(reserved_prefix)]
+#![warn(rust_2021_prefixes_incompatible_syntax)]
macro_rules! m2 {
($a:tt $b:tt) => {};
@@ -14,16 +14,16 @@ macro_rules! m3 {
fn main() {
m2!(z "hey");
- //~^ WARNING prefix `z` is unknown [reserved_prefix]
+ //~^ WARNING prefix `z` is unknown [rust_2021_prefixes_incompatible_syntax]
//~| WARNING hard error in Rust 2021
m2!(prefix "hey");
- //~^ WARNING prefix `prefix` is unknown [reserved_prefix]
+ //~^ WARNING prefix `prefix` is unknown [rust_2021_prefixes_incompatible_syntax]
//~| WARNING hard error in Rust 2021
m3!(hey #123);
- //~^ WARNING prefix `hey` is unknown [reserved_prefix]
+ //~^ WARNING prefix `hey` is unknown [rust_2021_prefixes_incompatible_syntax]
//~| WARNING hard error in Rust 2021
m3!(hey #hey);
- //~^ WARNING prefix `hey` is unknown [reserved_prefix]
+ //~^ WARNING prefix `hey` is unknown [rust_2021_prefixes_incompatible_syntax]
//~| WARNING hard error in Rust 2021
}
@@ -33,6 +33,6 @@ macro_rules! quote {
quote! {
#name = #kind #value
- //~^ WARNING prefix `kind` is unknown [reserved_prefix]
+ //~^ WARNING prefix `kind` is unknown [rust_2021_prefixes_incompatible_syntax]
//~| WARNING hard error in Rust 2021
}
diff --git a/src/test/ui/rust-2021/reserved-prefixes-migration.rs b/src/test/ui/rust-2021/reserved-prefixes-migration.rs
index 6f7e3eb7a43a6..d24f29634806d 100644
--- a/src/test/ui/rust-2021/reserved-prefixes-migration.rs
+++ b/src/test/ui/rust-2021/reserved-prefixes-migration.rs
@@ -2,7 +2,7 @@
// run-rustfix
// compile-flags: -Z unstable-options --edition 2018
-#![warn(reserved_prefix)]
+#![warn(rust_2021_prefixes_incompatible_syntax)]
macro_rules! m2 {
($a:tt $b:tt) => {};
@@ -14,16 +14,16 @@ macro_rules! m3 {
fn main() {
m2!(z"hey");
- //~^ WARNING prefix `z` is unknown [reserved_prefix]
+ //~^ WARNING prefix `z` is unknown [rust_2021_prefixes_incompatible_syntax]
//~| WARNING hard error in Rust 2021
m2!(prefix"hey");
- //~^ WARNING prefix `prefix` is unknown [reserved_prefix]
+ //~^ WARNING prefix `prefix` is unknown [rust_2021_prefixes_incompatible_syntax]
//~| WARNING hard error in Rust 2021
m3!(hey#123);
- //~^ WARNING prefix `hey` is unknown [reserved_prefix]
+ //~^ WARNING prefix `hey` is unknown [rust_2021_prefixes_incompatible_syntax]
//~| WARNING hard error in Rust 2021
m3!(hey#hey);
- //~^ WARNING prefix `hey` is unknown [reserved_prefix]
+ //~^ WARNING prefix `hey` is unknown [rust_2021_prefixes_incompatible_syntax]
//~| WARNING hard error in Rust 2021
}
@@ -33,6 +33,6 @@ macro_rules! quote {
quote! {
#name = #kind#value
- //~^ WARNING prefix `kind` is unknown [reserved_prefix]
+ //~^ WARNING prefix `kind` is unknown [rust_2021_prefixes_incompatible_syntax]
//~| WARNING hard error in Rust 2021
}
diff --git a/src/test/ui/rust-2021/reserved-prefixes-migration.stderr b/src/test/ui/rust-2021/reserved-prefixes-migration.stderr
index 28ac1966a1bce..95105f932dcbd 100644
--- a/src/test/ui/rust-2021/reserved-prefixes-migration.stderr
+++ b/src/test/ui/rust-2021/reserved-prefixes-migration.stderr
@@ -7,8 +7,8 @@ LL | m2!(z"hey");
note: the lint level is defined here
--> $DIR/reserved-prefixes-migration.rs:5:9
|
-LL | #![warn(reserved_prefix)]
- | ^^^^^^^^^^^^^^^
+LL | #![warn(rust_2021_prefixes_incompatible_syntax)]
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
= warning: this is accepted in the current edition (Rust 2018) but is a hard error in Rust 2021!
= note: for more information, see issue #84978 <https://github.com/rust-lang/rust/issues/84978>
help: insert whitespace here to avoid this being parsed as a prefix in Rust 2021
diff --git a/src/tools/clippy/CHANGELOG.md b/src/tools/clippy/CHANGELOG.md
index f3a8070323879..421614057c577 100644
--- a/src/tools/clippy/CHANGELOG.md
+++ b/src/tools/clippy/CHANGELOG.md
@@ -592,7 +592,7 @@ Released 2021-02-11
* Previously deprecated [`str_to_string`] and [`string_to_string`] have been un-deprecated
as `restriction` lints [#6333](https://github.com/rust-lang/rust-clippy/pull/6333)
-* Deprecate `panic_params` lint. This is now available in rustc as `non_fmt_panic`
+* Deprecate `panic_params` lint. This is now available in rustc as `non_fmt_panics`
[#6351](https://github.com/rust-lang/rust-clippy/pull/6351)
* Move [`map_err_ignore`] to `restriction`
[#6416](https://github.com/rust-lang/rust-clippy/pull/6416)
diff --git a/src/tools/clippy/clippy_lints/src/lib.rs b/src/tools/clippy/clippy_lints/src/lib.rs
index e0325738466be..c29b3e7c74c2c 100644
--- a/src/tools/clippy/clippy_lints/src/lib.rs
+++ b/src/tools/clippy/clippy_lints/src/lib.rs
@@ -2171,7 +2171,7 @@ pub fn register_renamed(ls: &mut rustc_lint::LintStore) {
ls.register_renamed("clippy::unused_label", "unused_labels");
ls.register_renamed("clippy::drop_bounds", "drop_bounds");
ls.register_renamed("clippy::temporary_cstring_as_ptr", "temporary_cstring_as_ptr");
- ls.register_renamed("clippy::panic_params", "non_fmt_panic");
+ ls.register_renamed("clippy::panic_params", "non_fmt_panics");
ls.register_renamed("clippy::unknown_clippy_lints", "unknown_lints");
}
diff --git a/src/tools/clippy/tests/ui/assertions_on_constants.rs b/src/tools/clippy/tests/ui/assertions_on_constants.rs
index 6617ca183a8cb..2180f848d62cd 100644
--- a/src/tools/clippy/tests/ui/assertions_on_constants.rs
+++ b/src/tools/clippy/tests/ui/assertions_on_constants.rs
@@ -1,4 +1,4 @@
-#![allow(non_fmt_panic)]
+#![allow(non_fmt_panics)]
macro_rules! assert_const {
($len:expr) => {
diff --git a/src/tools/clippy/tests/ui/deprecated.stderr b/src/tools/clippy/tests/ui/deprecated.stderr
index 0af6b500115dc..c0002e5354310 100644
--- a/src/tools/clippy/tests/ui/deprecated.stderr
+++ b/src/tools/clippy/tests/ui/deprecated.stderr
@@ -60,11 +60,11 @@ error: lint `clippy::temporary_cstring_as_ptr` has been renamed to `temporary_cs
LL | #[warn(clippy::temporary_cstring_as_ptr)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the new name: `temporary_cstring_as_ptr`
-error: lint `clippy::panic_params` has been renamed to `non_fmt_panic`
+error: lint `clippy::panic_params` has been renamed to `non_fmt_panics`
--> $DIR/deprecated.rs:11:8
|
LL | #[warn(clippy::panic_params)]
- | ^^^^^^^^^^^^^^^^^^^^ help: use the new name: `non_fmt_panic`
+ | ^^^^^^^^^^^^^^^^^^^^ help: use the new name: `non_fmt_panics`
error: lint `clippy::unknown_clippy_lints` has been renamed to `unknown_lints`
--> $DIR/deprecated.rs:12:8
diff --git a/src/tools/lint-docs/src/lib.rs b/src/tools/lint-docs/src/lib.rs
index ea54a351e03b5..e5c7f12571238 100644
--- a/src/tools/lint-docs/src/lib.rs
+++ b/src/tools/lint-docs/src/lib.rs
@@ -467,7 +467,9 @@ fn lint_name(line: &str) -> Result<String, &'static str> {
return Err("lint name should end with comma");
}
let name = &name[..name.len() - 1];
- if !name.chars().all(|ch| ch.is_uppercase() || ch == '_') || name.is_empty() {
+ if !name.chars().all(|ch| ch.is_uppercase() || ch.is_ascii_digit() || ch == '_')
+ || name.is_empty()
+ {
return Err("lint name did not have expected format");
}
Ok(name.to_lowercase().to_string())