events-macros: Reduce turbofish usage

ruma-events-macros/src/event.rs

@@ -18,7 +18,7 @@ pub fn expand_event(input: DeriveInput) -> syn::Result<TokenStream> {
         syn::Error::new(Span::call_site(), "not a valid ruma event struct identifier")
     })?;
 
-    let fields = if let Data::Struct(DataStruct { fields, .. }) = input.data.clone() {
+    let fields: Vec<_> = if let Data::Struct(DataStruct { fields, .. }) = input.data.clone() {
         if let Fields::Named(FieldsNamed { named, .. }) = fields {
             if !named.iter().any(|f| f.ident.as_ref().unwrap() == "content") {
                 return Err(syn::Error::new(
@@ -27,7 +27,7 @@ pub fn expand_event(input: DeriveInput) -> syn::Result<TokenStream> {
                 ));
             }
 
-            named.into_iter().collect::<Vec<_>>()
+            named.into_iter().collect()
         } else {
             return Err(syn::Error::new_spanned(
                 fields,
@@ -66,7 +66,7 @@ fn expand_serialize_event(
 
     let ident = &input.ident;
     let (impl_gen, ty_gen, where_clause) = input.generics.split_for_impl();
-    let serialize_fields = fields
+    let serialize_fields: Vec<_> = fields
         .iter()
         .map(|field| {
             let name = field.ident.as_ref().unwrap();
@@ -105,7 +105,7 @@ fn expand_serialize_event(
                 }
             }
         })
-        .collect::<Vec<_>>();
+        .collect();
 
     quote! {
         #[automatically_derived]
@@ -150,15 +150,15 @@ fn expand_deserialize_event(
     let (impl_generics, ty_gen, where_clause) = input.generics.split_for_impl();
     let is_generic = !input.generics.params.is_empty();
 
-    let enum_variants = fields
+    let enum_variants: Vec<_> = fields
         .iter()
         .map(|field| {
             let name = field.ident.as_ref().unwrap();
             to_camel_case(name)
         })
-        .collect::<Vec<_>>();
+        .collect();
 
-    let deserialize_var_types = fields
+    let deserialize_var_types: Vec<_> = fields
         .iter()
         .map(|field| {
             let name = field.ident.as_ref().unwrap();
@@ -175,9 +175,9 @@ fn expand_deserialize_event(
                 quote! { #ty }
             }
         })
-        .collect::<Vec<_>>();
+        .collect();
 
-    let ok_or_else_fields = fields
+    let ok_or_else_fields: Vec<_> = fields
         .iter()
         .map(|field| {
             let name = field.ident.as_ref().unwrap();
@@ -253,9 +253,9 @@ fn expand_deserialize_event(
                 }
             }
         })
-        .collect::<Vec<_>>();
+        .collect();
 
-    let field_names = fields.iter().flat_map(|f| &f.ident).collect::<Vec<_>>();
+    let field_names: Vec<_> = fields.iter().flat_map(|f| &f.ident).collect();
 
     let deserialize_impl_gen = if is_generic {
         let gen = &input.generics.params;
@@ -366,10 +366,10 @@ fn expand_from_into(
 
     let (impl_generics, ty_gen, where_clause) = input.generics.split_for_impl();
 
-    let fields = fields.iter().flat_map(|f| &f.ident).collect::<Vec<_>>();
+    let fields: Vec<_> = fields.iter().flat_map(|f| &f.ident).collect();
 
-    let fields_without_unsigned =
+    let fields_without_unsigned: Vec<_> =
-        fields.iter().filter(|id| id.to_string().as_str() != "unsigned").collect::<Vec<_>>();
+        fields.iter().filter(|id| id.to_string().as_str() != "unsigned").collect();
 
     let (into, into_full_event) = if var.is_redacted() {
         (quote! { unsigned: unsigned.into(), }, quote! { unsigned: unsigned.into_full(room_id), })

ruma-events-macros/src/event_content.rs

@@ -123,7 +123,7 @@ pub fn expand_event_content(
                 })
                 .unwrap_or(Ok(()))?;
 
-            let mut fields = named
+            let mut fields: Vec<_> = named
                 .iter()
                 .filter(|f| {
                     matches!(
@@ -132,7 +132,7 @@ pub fn expand_event_content(
                     )
                 })
                 .cloned()
-                .collect::<Vec<_>>();
+                .collect();
 
             // don't re-emit our `ruma_event` attributes
             for f in &mut fields {

ruma-events-macros/src/event_enum.rs

@@ -123,10 +123,8 @@ fn expand_any_with_deser(
     // a valid event enum.
     let (event_struct, ident) = generate_event_idents(kind, var)?;
 
-    let content = events
+    let content: Vec<_> =
-        .iter()
+        events.iter().map(|event| to_event_path(event, &event_struct, ruma_events)).collect();
-        .map(|event| to_event_path(event, &event_struct, ruma_events))
-        .collect::<Vec<_>>();
 
     let variant_decls = variants.iter().map(|v| v.decl());
     let self_variants = variants.iter().map(|v| v.ctor(quote!(Self)));
@@ -211,7 +209,7 @@ fn expand_conversion_impl(
     let ruma_identifiers = quote! { #ruma_events::exports::ruma_identifiers };
 
     let ident = kind.to_event_enum_ident(var)?;
-    let variants = &variants
+    let variants: Vec<_> = variants
         .iter()
         .filter(|v| {
             // We filter this variant out only for non redacted events.
@@ -220,7 +218,7 @@ fn expand_conversion_impl(
             !(v.ident == "RoomRedaction"
                 && matches!(var, EventKindVariation::Full | EventKindVariation::Sync))
         })
-        .collect::<Vec<_>>();
+        .collect();
 
     match var {
         EventKindVariation::Full | EventKindVariation::Redacted => {
@@ -372,8 +370,8 @@ fn expand_content_enum(
     let ident = kind.to_content_enum();
     let event_type_str = events;
 
-    let content =
+    let content: Vec<_> =
-        events.iter().map(|ev| to_event_content_path(kind, ev, ruma_events)).collect::<Vec<_>>();
+        events.iter().map(|ev| to_event_content_path(kind, ev, ruma_events)).collect();
 
     let variant_decls = variants.iter().map(|v| v.decl());
 
@@ -801,7 +799,7 @@ fn to_event_path(name: &LitStr, struct_name: &Ident, ruma_events: &TokenStream)
     // There is no need to give a good compiler error as `to_camel_case` is called first.
     assert_eq!(&name[..2], "m.");
 
-    let path = name[2..].split('.').collect::<Vec<_>>();
+    let path: Vec<_> = name[2..].split('.').collect();
 
     let event_str = path.last().unwrap();
     let event = event_str
@@ -854,7 +852,7 @@ fn to_event_content_path(
     // There is no need to give a good compiler error as `to_camel_case` is called first.
     assert_eq!(&name[..2], "m.");
 
-    let path = name[2..].split('.').collect::<Vec<_>>();
+    let path: Vec<_> = name[2..].split('.').collect();
 
     let event_str = path.last().unwrap();
     let event = event_str