api-macros: Fix issues from previous refactoring

crates/ruma-api-macros/src/request.rs

@@ -119,10 +119,6 @@ impl Request {
         self.fields.iter().filter_map(RequestField::as_body_field)
     }
 
-    fn query_fields(&self) -> impl Iterator<Item = &Field> {
-        self.fields.iter().filter_map(RequestField::as_query_field)
-    }
-
     fn has_body_fields(&self) -> bool {
         self.fields
             .iter()
@@ -269,8 +265,8 @@ impl Request {
             }
         };
 
-        let has_body_fields = self.body_fields().count() > 0;
+        let has_body_fields = self.fields.iter().any(|f| matches!(f, RequestField::Body(_)));
-        let has_query_fields = self.query_fields().count() > 0;
+        let has_query_fields = self.fields.iter().any(|f| matches!(f, RequestField::Query(_)));
 
         if has_newtype_body_field && has_body_fields {
             return Err(syn::Error::new_spanned(
@@ -355,17 +351,26 @@ impl RequestField {
 
     /// Return the contained field if this request field is a raw body kind.
     pub fn as_raw_body_field(&self) -> Option<&Field> {
-        self.field_of_kind(RequestFieldKind::RawBody)
+        match self {
+            RequestField::RawBody(field) => Some(field),
+            _ => None,
+        }
     }
 
     /// Return the contained field if this request field is a query kind.
     pub fn as_query_field(&self) -> Option<&Field> {
-        self.field_of_kind(RequestFieldKind::Query)
+        match self {
+            RequestField::Query(field) => Some(field),
+            _ => None,
+        }
     }
 
     /// Return the contained field if this request field is a query map kind.
     pub fn as_query_map_field(&self) -> Option<&Field> {
-        self.field_of_kind(RequestFieldKind::QueryMap)
+        match self {
+            RequestField::QueryMap(field) => Some(field),
+            _ => None,
+        }
     }
 
     /// Gets the inner `Field` value.
@@ -380,20 +385,6 @@ impl RequestField {
             | RequestField::QueryMap(field) => field,
         }
     }
-
-    /// Gets the inner `Field` value if it's of the provided kind.
-    fn field_of_kind(&self, kind: RequestFieldKind) -> Option<&Field> {
-        match (self, kind) {
-            (RequestField::Body(field), RequestFieldKind::Body)
-            | (RequestField::Header(field, _), RequestFieldKind::Header)
-            | (RequestField::NewtypeBody(field), RequestFieldKind::NewtypeBody)
-            | (RequestField::RawBody(field), RequestFieldKind::RawBody)
-            | (RequestField::Path(field), RequestFieldKind::Path)
-            | (RequestField::Query(field), RequestFieldKind::Query)
-            | (RequestField::QueryMap(field), RequestFieldKind::QueryMap) => Some(field),
-            _ => None,
-        }
-    }
 }
 
 impl TryFrom<Field> for RequestField {

crates/ruma-api-macros/src/request/incoming.rs

@@ -2,7 +2,7 @@ use proc_macro2::{Ident, Span, TokenStream};
 use quote::quote;
 use syn::Field;
 
-use super::{Request, RequestField, RequestFieldKind};
+use super::{Request, RequestField};
 use crate::auth_scheme::AuthScheme;
 
 impl Request {
@@ -86,7 +86,10 @@ impl Request {
                 },
             )
         } else if self.has_query_fields() {
-            let (decls, names) = self.vars(RequestFieldKind::Query, quote! { request_query });
+            let (decls, names) = vars(
+                self.fields.iter().filter_map(RequestField::as_query_field),
+                quote! { request_query },
+            );
 
             let parse = quote! {
                 let request_query: <RequestQuery as #ruma_serde::Outgoing>::Incoming =
@@ -252,14 +255,6 @@ impl Request {
             #non_auth_impl
         }
     }
-
-    fn vars(
-        &self,
-        request_field_kind: RequestFieldKind,
-        src: TokenStream,
-    ) -> (TokenStream, TokenStream) {
-        vars(self.fields.iter().filter_map(|f| f.field_of_kind(request_field_kind)), src)
-    }
 }
 
 fn vars<'a>(

crates/ruma-api-macros/src/request/outgoing.rs

@@ -4,7 +4,7 @@ use syn::Field;
 
 use crate::auth_scheme::AuthScheme;
 
-use super::{Request, RequestField, RequestFieldKind};
+use super::{Request, RequestField};
 
 impl Request {
     pub fn expand_outgoing(&self, ruma_api: &TokenStream) -> TokenStream {
@@ -78,8 +78,10 @@ impl Request {
                 )
             }}
         } else if self.has_query_fields() {
-            let request_query_init_fields =
+            let request_query_init_fields = struct_init_fields(
-                self.struct_init_fields(RequestFieldKind::Query, quote! { self });
+                self.fields.iter().filter_map(RequestField::as_query_field),
+                quote! { self },
+            );
 
             quote! {{
                 let request_query = RequestQuery {
@@ -220,17 +222,6 @@ impl Request {
             #non_auth_impl
         }
     }
-
-    fn struct_init_fields(
-        &self,
-        request_field_kind: RequestFieldKind,
-        src: TokenStream,
-    ) -> TokenStream {
-        struct_init_fields(
-            self.fields.iter().filter_map(|f| f.field_of_kind(request_field_kind)),
-            src,
-        )
-    }
 }
 
 /// Produces code for a struct initializer for the given field kind to be accessed through the

crates/ruma-api-macros/src/response/outgoing.rs

@@ -42,7 +42,7 @@ impl Response {
         {
             let field_name = field.ident.as_ref().expect("expected field to have an identifier");
             quote! { #ruma_serde::slice_to_buf(&self.#field_name) }
-        } else if self.has_body_fields() {
+        } else {
             let fields = self.fields.iter().filter_map(|response_field| {
                 response_field.as_body_field().map(|field| {
                     let field_name =
@@ -59,8 +59,6 @@ impl Response {
             quote! {
                 #ruma_serde::json_to_buf(&ResponseBody { #(#fields)* })?
             }
-        } else {
-            quote! { <T as ::std::default::Default>::default() }
         };
 
         quote! {