rename

Author: bend-n

compiler/rustc_codegen_cranelift/example/example.rs

@@ -1,6 +1,6 @@
 #![feature(no_core, unboxed_closures)]
 #![no_core]
-#![allow(dead_code, unnecessary_transmutate)]
+#![allow(dead_code, unnecessary_transmutes)]
 
 extern crate mini_core;
 

compiler/rustc_codegen_gcc/example/example.rs

@@ -1,6 +1,6 @@
 #![feature(no_core, unboxed_closures)]
 #![no_core]
-#![allow(dead_code, unnecessary_transmutate)]
+#![allow(dead_code, unnecessary_transmutes)]
 
 extern crate mini_core;
 
@@ -11,11 +11,7 @@ fn abc(a: u8) -> u8 {
 }
 
 fn bcd(b: bool, a: u8) -> u8 {
-    if b {
-        a * 2
-    } else {
-        a * 3
-    }
+    if b { a * 2 } else { a * 3 }
 }
 
 fn call() {

compiler/rustc_lint_defs/src/builtin.rs

@@ -119,7 +119,7 @@ declare_lint_pass! {
         UNKNOWN_OR_MALFORMED_DIAGNOSTIC_ATTRIBUTES,
         UNNAMEABLE_TEST_ITEMS,
         UNNAMEABLE_TYPES,
-        UNNECESSARY_TRANSMUTATE,
+        UNNECESSARY_TRANSMUTES,
         UNREACHABLE_CODE,
         UNREACHABLE_PATTERNS,
         UNSAFE_ATTR_OUTSIDE_UNSAFE,
@@ -4945,7 +4945,7 @@ declare_lint! {
 }
 
 declare_lint! {
-    /// The `unnecessary_transmutate` lint detects transmutations that have safer alternatives.
+    /// The `unnecessary_transmutes` lint detects transmutations that have safer alternatives.
     ///
     /// ### Example
     ///
@@ -4963,7 +4963,7 @@ declare_lint! {
     /// [`transmute`](https://doc.rust-lang.org/std/mem/fn.transmute.html) as
     /// they more clearly communicate the intent, are easier to review, and
     /// are less likely to accidentally result in unsoundness.
-    pub UNNECESSARY_TRANSMUTATE,
+    pub UNNECESSARY_TRANSMUTES,
     Warn,
     "detects transmutes that are shadowed by std methods"
 }

compiler/rustc_mir_transform/src/check_unnecessary_transmutes.rs

@@ -1,7 +1,7 @@
 use rustc_middle::mir::visit::Visitor;
 use rustc_middle::mir::{Body, Location, Operand, Terminator, TerminatorKind};
 use rustc_middle::ty::*;
-use rustc_session::lint::builtin::UNNECESSARY_TRANSMUTATE;
+use rustc_session::lint::builtin::UNNECESSARY_TRANSMUTES;
 use rustc_span::source_map::Spanned;
 use rustc_span::{Span, sym};
 
@@ -94,7 +94,7 @@ impl<'tcx> Visitor<'tcx> for UnnecessaryTransmuteChecker<'_, 'tcx> {
             )
             && let Some(hir_id) = terminator.source_info.scope.lint_root(&self.body.source_scopes)
         {
-            self.tcx.emit_node_span_lint(UNNECESSARY_TRANSMUTATE, hir_id, span, lint);
+            self.tcx.emit_node_span_lint(UNNECESSARY_TRANSMUTES, hir_id, span, lint);
         }
     }
 }

library/alloctests/tests/fmt.rs

@@ -1,7 +1,7 @@
 #![deny(warnings)]
 // FIXME(static_mut_refs): Do not allow `static_mut_refs` lint
 #![allow(static_mut_refs)]
-#![cfg_attr(not(bootstrap), allow(unnecessary_transmutate))]
+#![cfg_attr(not(bootstrap), allow(unnecessary_transmutes))]
 
 use std::cell::RefCell;
 use std::fmt::{self, Write};

library/core/src/char/convert.rs

@@ -21,7 +21,7 @@ pub(super) const fn from_u32(i: u32) -> Option<char> {
 /// Converts a `u32` to a `char`, ignoring validity. See [`char::from_u32_unchecked`].
 #[inline]
 #[must_use]
-#[cfg_attr(not(bootstrap), allow(unnecessary_transmutate))]
+#[cfg_attr(not(bootstrap), allow(unnecessary_transmutes))]
 pub(super) const unsafe fn from_u32_unchecked(i: u32) -> char {
     // SAFETY: the caller must guarantee that `i` is a valid char value.
     unsafe {
@@ -222,7 +222,7 @@ impl FromStr for char {
 }
 
 #[inline]
-#[cfg_attr(not(bootstrap), allow(unnecessary_transmutate))]
+#[cfg_attr(not(bootstrap), allow(unnecessary_transmutes))]
 const fn char_try_from_u32(i: u32) -> Result<char, CharTryFromError> {
     // This is an optimized version of the check
     // (i > MAX as u32) || (i >= 0xD800 && i <= 0xDFFF),

library/core/src/intrinsics/mod.rs

@@ -1498,7 +1498,7 @@ pub const fn forget<T: ?Sized>(_: T);
 /// Turning raw bytes (`[u8; SZ]`) into `u32`, `f64`, etc.:
 ///
 /// ```
-/// # #![cfg_attr(not(bootstrap), allow(unnecessary_transmutate))]
+/// # #![cfg_attr(not(bootstrap), allow(unnecessary_transmutes))]
 /// let raw_bytes = [0x78, 0x56, 0x34, 0x12];
 ///
 /// let num = unsafe {

library/core/src/num/f128.rs

@@ -898,7 +898,7 @@ impl f128 {
     #[inline]
     #[unstable(feature = "f128", issue = "116909")]
     #[must_use = "this returns the result of the operation, without modifying the original"]
-    #[cfg_attr(not(bootstrap), allow(unnecessary_transmutate))]
+    #[cfg_attr(not(bootstrap), allow(unnecessary_transmutes))]
     pub const fn to_bits(self) -> u128 {
         // SAFETY: `u128` is a plain old datatype so we can always transmute to it.
         unsafe { mem::transmute(self) }
@@ -946,7 +946,7 @@ impl f128 {
     #[inline]
     #[must_use]
     #[unstable(feature = "f128", issue = "116909")]
-    #[cfg_attr(not(bootstrap), allow(unnecessary_transmutate))]
+    #[cfg_attr(not(bootstrap), allow(unnecessary_transmutes))]
     pub const fn from_bits(v: u128) -> Self {
         // It turns out the safety issues with sNaN were overblown! Hooray!
         // SAFETY: `u128` is a plain old datatype so we can always transmute from it.

library/core/src/num/f16.rs

@@ -886,7 +886,7 @@ impl f16 {
     #[inline]
     #[unstable(feature = "f16", issue = "116909")]
     #[must_use = "this returns the result of the operation, without modifying the original"]
-    #[cfg_attr(not(bootstrap), allow(unnecessary_transmutate))]
+    #[cfg_attr(not(bootstrap), allow(unnecessary_transmutes))]
     pub const fn to_bits(self) -> u16 {
         // SAFETY: `u16` is a plain old datatype so we can always transmute to it.
         unsafe { mem::transmute(self) }
@@ -933,7 +933,7 @@ impl f16 {
     #[inline]
     #[must_use]
     #[unstable(feature = "f16", issue = "116909")]
-    #[cfg_attr(not(bootstrap), allow(unnecessary_transmutate))]
+    #[cfg_attr(not(bootstrap), allow(unnecessary_transmutes))]
     pub const fn from_bits(v: u16) -> Self {
         // It turns out the safety issues with sNaN were overblown! Hooray!
         // SAFETY: `u16` is a plain old datatype so we can always transmute from it.

library/core/src/num/f32.rs

@@ -1089,7 +1089,7 @@ impl f32 {
     #[stable(feature = "float_bits_conv", since = "1.20.0")]
     #[rustc_const_stable(feature = "const_float_bits_conv", since = "1.83.0")]
     #[inline]
-    #[cfg_attr(not(bootstrap), allow(unnecessary_transmutate))]
+    #[cfg_attr(not(bootstrap), allow(unnecessary_transmutes))]
     pub const fn to_bits(self) -> u32 {
         // SAFETY: `u32` is a plain old datatype so we can always transmute to it.
         unsafe { mem::transmute(self) }
@@ -1135,7 +1135,7 @@ impl f32 {
     #[rustc_const_stable(feature = "const_float_bits_conv", since = "1.83.0")]
     #[must_use]
     #[inline]
-    #[cfg_attr(not(bootstrap), allow(unnecessary_transmutate))]
+    #[cfg_attr(not(bootstrap), allow(unnecessary_transmutes))]
     pub const fn from_bits(v: u32) -> Self {
         // It turns out the safety issues with sNaN were overblown! Hooray!
         // SAFETY: `u32` is a plain old datatype so we can always transmute from it.

library/core/src/num/f64.rs

@@ -1088,7 +1088,7 @@ impl f64 {
                   without modifying the original"]
     #[stable(feature = "float_bits_conv", since = "1.20.0")]
     #[rustc_const_stable(feature = "const_float_bits_conv", since = "1.83.0")]
-    #[cfg_attr(not(bootstrap), allow(unnecessary_transmutate))]
+    #[cfg_attr(not(bootstrap), allow(unnecessary_transmutes))]
     #[inline]
     pub const fn to_bits(self) -> u64 {
         // SAFETY: `u64` is a plain old datatype so we can always transmute to it.
@@ -1135,7 +1135,7 @@ impl f64 {
     #[rustc_const_stable(feature = "const_float_bits_conv", since = "1.83.0")]
     #[must_use]
     #[inline]
-    #[cfg_attr(not(bootstrap), allow(unnecessary_transmutate))]
+    #[cfg_attr(not(bootstrap), allow(unnecessary_transmutes))]
     pub const fn from_bits(v: u64) -> Self {
         // It turns out the safety issues with sNaN were overblown! Hooray!
         // SAFETY: `u64` is a plain old datatype so we can always transmute from it.

library/core/src/num/int_macros.rs

@@ -3678,7 +3678,7 @@ macro_rules! int_impl {
         /// ```
         #[stable(feature = "int_to_from_bytes", since = "1.32.0")]
         #[rustc_const_stable(feature = "const_int_conversion", since = "1.44.0")]
-        #[cfg_attr(not(bootstrap), allow(unnecessary_transmutate))]
+        #[cfg_attr(not(bootstrap), allow(unnecessary_transmutes))]
         // SAFETY: const sound because integers are plain old datatypes so we can always
         // transmute them to arrays of bytes
         #[must_use = "this returns the result of the operation, \
@@ -3782,7 +3782,7 @@ macro_rules! int_impl {
         /// ```
         #[stable(feature = "int_to_from_bytes", since = "1.32.0")]
         #[rustc_const_stable(feature = "const_int_conversion", since = "1.44.0")]
-        #[cfg_attr(not(bootstrap), allow(unnecessary_transmutate))]
+        #[cfg_attr(not(bootstrap), allow(unnecessary_transmutes))]
         #[must_use]
         // SAFETY: const sound because integers are plain old datatypes so we can always
         // transmute to them

library/core/src/num/uint_macros.rs

@@ -3523,7 +3523,7 @@ macro_rules! uint_impl {
         #[rustc_const_stable(feature = "const_int_conversion", since = "1.44.0")]
         #[must_use = "this returns the result of the operation, \
                       without modifying the original"]
-        #[cfg_attr(not(bootstrap), allow(unnecessary_transmutate))]
+        #[cfg_attr(not(bootstrap), allow(unnecessary_transmutes))]
         // SAFETY: const sound because integers are plain old datatypes so we can always
         // transmute them to arrays of bytes
         #[inline]
@@ -3625,7 +3625,7 @@ macro_rules! uint_impl {
         /// ```
         #[stable(feature = "int_to_from_bytes", since = "1.32.0")]
         #[rustc_const_stable(feature = "const_int_conversion", since = "1.44.0")]
-        #[cfg_attr(not(bootstrap), allow(unnecessary_transmutate))]
+        #[cfg_attr(not(bootstrap), allow(unnecessary_transmutes))]
         #[must_use]
         // SAFETY: const sound because integers are plain old datatypes so we can always
         // transmute to them

src/tools/clippy/tests/ui/blocks_in_conditions.fixed

@@ -3,7 +3,7 @@
 #![warn(clippy::blocks_in_conditions)]
 #![allow(
     unused,
-    unnecessary_transmutate,
+    unnecessary_transmutes,
     clippy::let_and_return,
     clippy::needless_if,
     clippy::missing_transmute_annotations

src/tools/clippy/tests/ui/blocks_in_conditions.rs

@@ -3,7 +3,7 @@
 #![warn(clippy::blocks_in_conditions)]
 #![allow(
     unused,
-    unnecessary_transmutate,
+    unnecessary_transmutes,
     clippy::let_and_return,
     clippy::needless_if,
     clippy::missing_transmute_annotations

src/tools/clippy/tests/ui/crashes/ice-1782.rs

@@ -1,6 +1,6 @@
 //@ check-pass
 
-#![allow(dead_code, unused_variables, unnecessary_transmutate)]
+#![allow(dead_code, unused_variables, unnecessary_transmutes)]
 #![allow(clippy::unnecessary_cast, clippy::missing_transmute_annotations)]
 
 /// Should not trigger an ICE in `SpanlessEq` / `consts::constant`

src/tools/clippy/tests/ui/transmute.rs

@@ -3,7 +3,7 @@
 #![allow(
     dead_code,
     clippy::borrow_as_ptr,
-    unnecessary_transmutate,
+    unnecessary_transmutes,
     clippy::needless_lifetimes,
     clippy::missing_transmute_annotations
 )]

src/tools/clippy/tests/ui/transmute_float_to_int.fixed

@@ -1,5 +1,5 @@
 #![warn(clippy::transmute_float_to_int)]
-#![allow(clippy::missing_transmute_annotations, unnecessary_transmutate)]
+#![allow(clippy::missing_transmute_annotations, unnecessary_transmutes)]
 #![feature(f128)]
 #![feature(f16)]
 

src/tools/clippy/tests/ui/transmute_float_to_int.rs

@@ -1,5 +1,5 @@
 #![warn(clippy::transmute_float_to_int)]
-#![allow(clippy::missing_transmute_annotations, unnecessary_transmutate)]
+#![allow(clippy::missing_transmute_annotations, unnecessary_transmutes)]
 #![feature(f128)]
 #![feature(f16)]
 

src/tools/clippy/tests/ui/transmute_int_to_char.fixed

@@ -1,5 +1,5 @@
 #![warn(clippy::transmute_int_to_char)]
-#![allow(clippy::missing_transmute_annotations, unnecessary_transmutate)]
+#![allow(clippy::missing_transmute_annotations, unnecessary_transmutes)]
 
 fn int_to_char() {
     let _: char = unsafe { std::char::from_u32(0_u32).unwrap() };

src/tools/clippy/tests/ui/transmute_int_to_char.rs

@@ -1,5 +1,5 @@
 #![warn(clippy::transmute_int_to_char)]
-#![allow(clippy::missing_transmute_annotations, unnecessary_transmutate)]
+#![allow(clippy::missing_transmute_annotations, unnecessary_transmutes)]
 
 fn int_to_char() {
     let _: char = unsafe { std::mem::transmute(0_u32) };

src/tools/clippy/tests/ui/transmute_int_to_char_no_std.fixed

@@ -1,7 +1,7 @@
 #![no_std]
 #![feature(lang_items)]
 #![warn(clippy::transmute_int_to_char)]
-#![allow(clippy::missing_transmute_annotations, unnecessary_transmutate)]
+#![allow(clippy::missing_transmute_annotations, unnecessary_transmutes)]
 
 use core::panic::PanicInfo;
 

src/tools/clippy/tests/ui/transmute_int_to_char_no_std.rs

@@ -1,7 +1,7 @@
 #![no_std]
 #![feature(lang_items)]
 #![warn(clippy::transmute_int_to_char)]
-#![allow(clippy::missing_transmute_annotations, unnecessary_transmutate)]
+#![allow(clippy::missing_transmute_annotations, unnecessary_transmutes)]
 
 use core::panic::PanicInfo;
 

src/tools/miri/tests/fail/validity/invalid_bool.rs

@@ -1,4 +1,4 @@
-#![allow(unnecessary_transmutate)]
+#![allow(unnecessary_transmutes)]
 fn main() {
     let _b = unsafe { std::mem::transmute::<u8, bool>(2) }; //~ ERROR: expected a boolean
 }

src/tools/miri/tests/fail/validity/invalid_bool_op.rs

@@ -2,7 +2,7 @@
 // Make sure we find these even with many checks disabled.
 //@compile-flags: -Zmiri-disable-alignment-check -Zmiri-disable-stacked-borrows -Zmiri-disable-validation
 
-#![allow(unnecessary_transmutate)]
+#![allow(unnecessary_transmutes)]
 fn main() {
     let b = unsafe { std::mem::transmute::<u8, bool>(2) };
     let _x = b == std::hint::black_box(true); //~ ERROR: interpreting an invalid 8-bit value as a bool

src/tools/miri/tests/fail/validity/invalid_char.rs

@@ -1,4 +1,4 @@
-#![allow(unnecessary_transmutate)]
+#![allow(unnecessary_transmutes)]
 fn main() {
     assert!(std::char::from_u32(-1_i32 as u32).is_none());
     let _val = match unsafe { std::mem::transmute::<i32, char>(-1) } {

src/tools/miri/tests/fail/validity/invalid_char_op.rs

@@ -2,7 +2,7 @@
 // Make sure we find these even with many checks disabled.
 //@compile-flags: -Zmiri-disable-alignment-check -Zmiri-disable-stacked-borrows -Zmiri-disable-validation
 
-#![allow(unnecessary_transmutate)]
+#![allow(unnecessary_transmutes)]
 fn main() {
     let c = 0xFFFFFFu32;
     assert!(std::char::from_u32(c).is_none());

src/tools/miri/tests/pass/float.rs

@@ -6,7 +6,7 @@
 #![feature(f16)]
 #![allow(arithmetic_overflow)]
 #![allow(internal_features)]
-#![allow(unnecessary_transmutate)]
+#![allow(unnecessary_transmutes)]
 
 use std::any::type_name;
 use std::cmp::min;

src/tools/miri/tests/pass/issues/issue-miri-184.rs

@@ -1,4 +1,4 @@
-#![allow(unnecessary_transmutate)]
+#![allow(unnecessary_transmutes)]
 pub fn main() {
     let bytes: [u8; 8] = unsafe { ::std::mem::transmute(0u64) };
     let _val: &[u8] = &bytes;

src/tools/miri/tests/pass/shims/x86/intrinsics-x86-sse.rs

@@ -1,6 +1,6 @@
 // We're testing x86 target specific features
 //@only-target: x86_64 i686
-#![allow(unnecessary_transmutate)]
+#![allow(unnecessary_transmutes)]
 
 #[cfg(target_arch = "x86")]
 use std::arch::x86::*;

tests/ui/consts/const-eval/raw-bytes.rs

@@ -2,7 +2,7 @@
 //@ ignore-endian-big
 // ignore-tidy-linelength
 //@ normalize-stderr: "╾─*ALLOC[0-9]+(\+[a-z0-9]+)?(<imm>)?─*╼" -> "╾ALLOC_ID$1╼"
-#![allow(invalid_value, unnecessary_transmutate)]
+#![allow(invalid_value, unnecessary_transmutes)]
 #![feature(never_type, rustc_attrs, ptr_metadata, slice_from_ptr_range, const_slice_from_ptr_range)]
 
 use std::mem;

tests/ui/consts/const-eval/transmute-const-promotion.rs

@@ -1,4 +1,4 @@
-#![allow(unnecessary_transmutate)]
+#![allow(unnecessary_transmutes)]
 use std::mem;
 
 fn main() {

tests/ui/consts/const-eval/transmute-const.rs

@@ -1,4 +1,4 @@
-#![allow(unnecessary_transmutate)]
+#![allow(unnecessary_transmutes)]
 use std::mem;
 
 static FOO: bool = unsafe { mem::transmute(3u8) };

tests/ui/consts/const-eval/ub-enum.rs

@@ -3,7 +3,7 @@
 //@ normalize-stderr: "([0-9a-f][0-9a-f] |╾─*ALLOC[0-9]+(\+[a-z0-9]+)?(<imm>)?─*╼ )+ *│.*" -> "HEX_DUMP"
 //@ normalize-stderr: "0x0+" -> "0x0"
 #![feature(never_type)]
-#![allow(invalid_value, unnecessary_transmutate)]
+#![allow(invalid_value, unnecessary_transmutes)]
 
 use std::mem;
 

tests/ui/consts/const-eval/ub-wide-ptr.rs

@@ -1,5 +1,5 @@
 // ignore-tidy-linelength
-#![allow(unused, unnecessary_transmutate)]
+#![allow(unused, unnecessary_transmutes)]
 #![feature(ptr_metadata)]
 
 use std::{ptr, mem};

tests/ui/consts/extra-const-ub/detect-extra-ub.rs

@@ -2,7 +2,7 @@
 //@ [no_flag] check-pass
 //@ [with_flag] compile-flags: -Zextra-const-ub-checks
 #![feature(never_type)]
-#![allow(unnecessary_transmutate)]
+#![allow(unnecessary_transmutes)]
 
 use std::mem::transmute;
 use std::ptr::addr_of;