Update tests for unnecessary_refs lint

Author: obeis

compiler/rustc_query_impl/src/lib.rs

@@ -84,6 +84,7 @@ where
     }
 
     #[inline(always)]
+    #[cfg_attr(not(bootstrap), allow(unnecessary_refs))]
     fn query_state<'a>(self, qcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>
     where
         QueryCtxt<'tcx>: 'a,
@@ -98,6 +99,7 @@ where
     }
 
     #[inline(always)]
+    #[cfg_attr(not(bootstrap), allow(unnecessary_refs))]
     fn query_cache<'a>(self, qcx: QueryCtxt<'tcx>) -> &'a Self::Cache
     where
         'tcx: 'a,

library/alloc/src/boxed.rs

@@ -1723,6 +1723,7 @@ impl<T: Clone, A: Allocator + Clone> Clone for Box<T, A> {
     /// # Examples
     ///
     /// ```
+    /// #![allow(unnecessary_refs)]
     /// let x = Box::new(5);
     /// let y = x.clone();
     ///

library/alloctests/tests/boxed.rs

@@ -5,6 +5,7 @@ use core::ptr::NonNull;
 
 #[test]
 #[expect(dangling_pointers_from_temporaries)]
+#[allow(unnecessary_refs)]
 fn uninitialized_zero_size_box() {
     assert_eq!(
         &*Box::<()>::new_uninit() as *const _,

library/alloctests/tests/str.rs

@@ -2228,6 +2228,7 @@ fn test_str_escapes() {
 }
 
 #[test]
+#[allow(unnecessary_refs)]
 fn const_str_ptr() {
     const A: [u8; 2] = ['h' as u8, 'i' as u8];
     const B: &'static [u8; 2] = &A;

library/alloctests/tests/sync.rs

@@ -330,6 +330,7 @@ fn weak_self_cyclic() {
 }
 
 #[test]
+#[allow(unnecessary_refs)]
 fn drop_arc() {
     let mut canary = AtomicUsize::new(0);
     let x = Arc::new(Canary(&mut canary as *mut AtomicUsize));
@@ -338,6 +339,7 @@ fn drop_arc() {
 }
 
 #[test]
+#[allow(unnecessary_refs)]
 fn drop_arc_weak() {
     let mut canary = AtomicUsize::new(0);
     let arc = Arc::new(Canary(&mut canary as *mut AtomicUsize));

library/alloctests/tests/vec.rs

@@ -1380,6 +1380,7 @@ fn assert_covariance() {
 }
 
 #[test]
+#[allow(unnecessary_refs)]
 fn from_into_inner() {
     let vec = vec![1, 2, 3];
     let ptr = vec.as_ptr();

library/alloctests/tests/vec_deque.rs

@@ -1838,6 +1838,7 @@ fn test_collect_from_into_iter_keeps_allocation() {
     v.extend(0..7);
     check(&v[0], &v[v.len() - 1], v.into_iter());
 
+    #[allow(unnecessary_refs)]
     fn check(buf: *const i32, last: *const i32, mut it: impl Iterator<Item = i32>) {
         assert_eq!(it.next(), Some(0));
         assert_eq!(it.next(), Some(1));

library/core/src/ffi/c_str.rs

@@ -498,8 +498,7 @@ impl CStr {
     const fn as_non_null_ptr(&self) -> NonNull<c_char> {
         // FIXME(const_trait_impl) replace with `NonNull::from`
         // SAFETY: a reference is never null
-        unsafe { NonNull::new_unchecked(&self.inner as *const [c_char] as *mut [c_char]) }
-            .as_non_null_ptr()
+        unsafe { NonNull::new_unchecked(&raw const self.inner as *mut [c_char]) }.as_non_null_ptr()
     }
 
     /// Returns the length of `self`. Like C's `strlen`, this does not include the nul terminator.

library/core/src/fmt/mod.rs

@@ -2881,7 +2881,7 @@ impl<T: ?Sized> Pointer for &T {
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<T: ?Sized> Pointer for &mut T {
     fn fmt(&self, f: &mut Formatter<'_>) -> Result {
-        Pointer::fmt(&(&**self as *const T), f)
+        Pointer::fmt(&(&raw const **self), f)
     }
 }
 

library/core/src/hash/sip.rs

@@ -103,7 +103,7 @@ macro_rules! load_int_le {
         let mut data = 0 as $int_ty;
         ptr::copy_nonoverlapping(
             $buf.as_ptr().add($i),
-            &mut data as *mut _ as *mut u8,
+            &raw mut data as *mut u8,
             size_of::<$int_ty>(),
         );
         data.to_le()