rustfix on more dependencies

Summary: applying more 2021->2024 edition migration changes

Reviewed By: dtolnay

Differential Revision: D73444477

fbshipit-source-id: 280f98103510c6c74f98ed52f5bddf6d8e474a78

Author: cjlongoria

gazebo/dupe_derive/src/clone.rs

@@ -19,7 +19,7 @@ pub fn derive_clone_(input: proc_macro::TokenStream) -> proc_macro::TokenStream
 
     let name = &input.ident;
     let body = duplicate_impl(&input.data, &quote! { ::std::clone::Clone::clone });
-    let gen = quote! {
+    let r#gen = quote! {
         // Clippy wants us to use Copy if we can - we prefer to be agnostic.
         // Add unknown_lints temporarily.
         #[allow(unknown_lints)]
@@ -30,5 +30,5 @@ pub fn derive_clone_(input: proc_macro::TokenStream) -> proc_macro::TokenStream
             }
         }
     };
-    gen.into()
+    r#gen.into()
 }

gazebo/dupe_derive/src/copy.rs

@@ -16,9 +16,9 @@ pub fn derive_copy_(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
     let (impl_generics, ty_generics, where_clause) = input.generics.split_for_impl();
 
     let name = &input.ident;
-    let gen = quote! {
+    let r#gen = quote! {
         impl #impl_generics ::std::marker::Copy for #name #ty_generics #where_clause {
         }
     };
-    gen.into()
+    r#gen.into()
 }

gazebo/dupe_derive/src/dupe.rs

@@ -57,7 +57,7 @@ fn derive_dupe_explicit(
         name.span(),
     );
 
-    let gen = quote! {
+    let r#gen = quote! {
         impl #impl_generics dupe::Dupe for #name #ty_generics #where_clause {
         }
 
@@ -68,7 +68,7 @@ fn derive_dupe_explicit(
         }
     };
 
-    gen.into()
+    r#gen.into()
 }
 
 fn check_each_field_dupe<'a>(tys: impl IntoIterator<Item = &'a Type>) -> TokenStream {

gazebo/gazebo/src/cast.rs

@@ -29,24 +29,24 @@ pub fn ptr_to_usize<T: ?Sized>(x: &T) -> usize {
 /// of type `T`.
 #[inline(always)]
 pub unsafe fn usize_to_ptr<'a, T>(x: usize) -> &'a T {
-    &*(x as *const T)
+    unsafe { &*(x as *const T) }
 }
 
 /// Undefined behaviour if the argument does not satisfy the alignment of type `To`.
 #[inline(always)]
 pub unsafe fn ptr<From, To>(x: &From) -> &To {
-    &*(x as *const From as *const To)
+    unsafe { &*(x as *const From as *const To) }
 }
 
 /// Undefined behaviour if the argument does not satisfy the alignment of type `To`.
 #[inline(always)]
 pub unsafe fn ptr_mut<From, To>(x: &mut From) -> &mut To {
-    &mut *(x as *mut From as *mut To)
+    unsafe { &mut *(x as *mut From as *mut To) }
 }
 
 #[inline(always)]
 pub unsafe fn ptr_lifetime<'a, 'b, T: ?Sized>(x: &'a T) -> &'b T {
-    &*(x as *const T)
+    unsafe { &*(x as *const T) }
 }
 
 /// Like normal [`transmute`](std::mem::transmute), but without the compile-time
@@ -59,18 +59,20 @@ pub unsafe fn ptr_lifetime<'a, 'b, T: ?Sized>(x: &'a T) -> &'b T {
 /// e.g. `Vec<T>`, that `transmute` cannot be applied to.
 #[inline]
 pub unsafe fn transmute_unchecked<A, B>(x: A) -> B {
-    assert_eq!(mem::size_of::<A>(), mem::size_of::<B>());
-    debug_assert_eq!(0, (&x as *const A).align_offset(mem::align_of::<B>()));
-    let b = ptr::read(&x as *const A as *const B);
-    mem::forget(x);
-    b
+    unsafe {
+        assert_eq!(mem::size_of::<A>(), mem::size_of::<B>());
+        debug_assert_eq!(0, (&x as *const A).align_offset(mem::align_of::<B>()));
+        let b = ptr::read(&x as *const A as *const B);
+        mem::forget(x);
+        b
+    }
 }
 
 #[macro_export]
 /// `transmute!(from-type, to-type, value)` will do a [`transmute`](std::mem::transmute),
 /// but the original and result types must be specified.
 macro_rules! transmute {
-    ($from:ty, $to:ty, $e:expr) => {
+    ($from:ty, $to:ty, $e:expr_2021) => {
         std::mem::transmute::<$from, $to>($e)
     };
 }
@@ -85,7 +87,7 @@ mod tests {
     fn test_transmute() {
         #[allow(clippy::useless_transmute)]
         unsafe fn downcast_string<'a>(x: &'a str) -> &'static str {
-            transmute!(&'a str, &'static str, x)
+            unsafe { transmute!(&'a str, &'static str, x) }
         }
         assert_eq!(unsafe { downcast_string("test") }, "test");
     }

gazebo/gazebo/src/cmp.rs

@@ -35,10 +35,10 @@
 /// ```
 #[macro_export]
 macro_rules! cmp_chain {
-    ($e:expr) => {
+    ($e:expr_2021) => {
         $e
     };
-    ($e:expr, $($x:expr),+ $(,)?) => {
+    ($e:expr_2021, $($x:expr_2021),+ $(,)?) => {
         match $e {
             std::cmp::Ordering::Equal => {
                 cmp_chain!($($x),+)
@@ -73,10 +73,10 @@ macro_rules! cmp_chain {
 /// ```
 #[macro_export]
 macro_rules! eq_chain {
-    ($e:expr) => {
+    ($e:expr_2021) => {
         $e
     };
-    ($e:expr, $($x:expr),+ $(,)?) => {
+    ($e:expr_2021, $($x:expr_2021),+ $(,)?) => {
         if $e {
             eq_chain!($($x),+)
         } else {

gazebo/gazebo_derive/src/default.rs

@@ -21,14 +21,14 @@ pub fn derive_default_(input: DeriveInput) -> proc_macro::TokenStream {
 
     let name = &input.ident;
     let body = default_impl(&input.data);
-    let gen = quote! {
+    let r#gen = quote! {
         impl #impl_generics ::std::default::Default for #name #ty_generics #where_clause {
             fn default() -> Self {
                 #body
             }
         }
     };
-    gen.into()
+    r#gen.into()
 }
 
 fn default_struct(data: &DataStruct) -> TokenStream {

gazebo/gazebo_derive/src/variant.rs

@@ -39,7 +39,7 @@ pub(crate) fn derive_variant_names(input: DeriveInput) -> syn::Result<proc_macro
         let name = &input.ident;
         let (impl_generics, ty_generics, where_clause) = input.generics.split_for_impl();
 
-        let gen = quote! {
+        let r#gen = quote! {
             impl #impl_generics gazebo::variants::VariantName for #name #ty_generics #where_clause {
                 fn variant_name(&self) -> &'static str {
                     match self {
@@ -55,7 +55,7 @@ pub(crate) fn derive_variant_names(input: DeriveInput) -> syn::Result<proc_macro
             }
         };
 
-        Ok(gen.into())
+        Ok(r#gen.into())
     } else {
         Err(syn::Error::new(
             input.span(),
@@ -137,13 +137,13 @@ pub(crate) fn derive_unpack_variants(input: DeriveInput) -> syn::Result<proc_mac
         let name = &input.ident;
         let (impl_generics, ty_generics, where_clause) = input.generics.split_for_impl();
 
-        let gen = quote! {
+        let r#gen = quote! {
             impl #impl_generics #name #ty_generics #where_clause {
                 #(#variant_fns)*
             }
         };
 
-        Ok(gen.into())
+        Ok(r#gen.into())
     } else {
         Err(syn::Error::new(
             input.span(),

starlark/src/cast.rs

@@ -26,12 +26,12 @@ pub(crate) fn ptr_to_usize<T: ?Sized>(x: &T) -> usize {
 pub(crate) unsafe fn usize_to_ptr<'a, T>(x: usize) -> &'a T {
     debug_assert!(x != 0, "Zero is not a valid pointer");
     debug_assert!(x % std::mem::align_of::<T>() == 0, "Pointer is not aligned");
-    &*(x as *const T)
+    unsafe { &*(x as *const T) }
 }
 
 #[inline(always)]
 pub(crate) unsafe fn ptr_lifetime<'a, 'b, T: ?Sized>(x: &'a T) -> &'b T {
-    &*(x as *const T)
+    unsafe { &*(x as *const T) }
 }
 
 /// `transmute!(from-type, to-type, value)` will do a [`transmute`](std::mem::transmute),

starlark/src/docs/multipage.rs

@@ -142,12 +142,9 @@ impl<'a> MultipageRender<'a> {
 
             let render_linked_ty_starlark_value = move |ty: &TyStarlarkValue| {
                 let type_name = ty.to_string();
-                if let Some(type_path) =
-                    ty_to_path_map.get(&Ty::basic(TyBasic::StarlarkValue(ty.dupe())))
-                {
-                    linked_ty_mapper(type_path, &type_name)
-                } else {
-                    type_name.to_owned()
+                match ty_to_path_map.get(&Ty::basic(TyBasic::StarlarkValue(ty.dupe()))) {
+                    Some(type_path) => linked_ty_mapper(type_path, &type_name),
+                    _ => type_name.to_owned(),
                 }
             };
 

starlark/src/environment/globals.rs

@@ -374,10 +374,13 @@ impl GlobalsStatic {
     }
 }
 
-pub(crate) fn common_documentation<'a>(
+pub(crate) fn common_documentation<'a, T: IntoIterator<Item = (&'a str, FrozenValue)>>(
     docstring: &Option<String>,
-    members: impl IntoIterator<Item = (&'a str, FrozenValue)>,
-) -> (Option<DocString>, impl Iterator<Item = (String, DocItem)>) {
+    members: T,
+) -> (
+    Option<DocString>,
+    impl Iterator<Item = (String, DocItem)> + use<T>,
+) {
     let main_docs = docstring
         .as_ref()
         .and_then(|ds| DocString::from_docstring(DocStringKind::Rust, ds));