Rename some Rust 2021 lints to better names

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",

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

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) {

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 {

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,

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());

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)
 }

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)]

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 {

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 {

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
  |