fix(macros/generate/convert/auxiliary/c): Correctly generate function types

src/macros/generate/convert/auxiliary/c/function/mod.rs

@@ -29,10 +29,14 @@ impl Function {
     pub fn to_auxiliary_c(&self, namespaces: &[&Identifier]) -> String {
         let doc_comments: String = Attribute::to_auxiliary_c_merged(&self.attributes);
         let ident = self.identifier.to_c_with_path(namespaces);
-        let inputs: Vec<TokenStream2> = self.inputs.iter().map(NamedType::to_auxiliary_c).collect();
+        let inputs: Vec<TokenStream2> = self
+            .inputs
+            .iter()
+            .map(NamedType::to_auxiliary_c)
+            .collect();
 
         let function_output = if let Some(out) = &self.output {
-            let type_name = &out.to_auxiliary_c(true);
+            let type_name = &out.to_auxiliary_c(true, None);
             let comma = if !inputs.is_empty() {
                 quote! {
                     ,
@@ -66,7 +70,7 @@ impl Function {
         let ident = self.identifier.to_rust();
 
         let (output, output_comma) = if let Some(output) = &self.output {
-            let output = output.to_auxiliary_c(true);
+            let output = output.to_auxiliary_c(true, None);
             (quote! { #output }, quote! {,})
         } else {
             (TokenStream2::default(), TokenStream2::default())
@@ -79,7 +83,7 @@ impl Function {
                 .inputs
                 .iter()
                 .map(|named_type| &named_type.r#type)
-                .map(|r#type| r#type.to_auxiliary_c(false))
+                .map(|r#type| r#type.to_auxiliary_c(false, None))
                 .collect();
             quote! {
                 #output_comma #(#inputs),*

src/macros/generate/convert/auxiliary/c/structure/mod.rs

@@ -25,7 +25,7 @@ use crate::parser::command_spec::{Attribute, DocNamedType, Structure};
 impl Structure {
     pub fn to_auxiliary_c(&self) -> String {
         let doc_comments: String = Attribute::to_auxiliary_c_merged(&self.attributes);
-        let ident = self.identifier.to_rust();
+        let ident = self.identifier.to_auxiliary_c();
         let contents = self
             .contents
             .iter()

src/macros/generate/convert/auxiliary/c/type/doc_named_type.rs

@@ -20,13 +20,18 @@
 * If not, see <https://www.gnu.org/licenses/>.
 */
 
-use crate::parser::command_spec::{Attribute, DocNamedType};
+use crate::parser::command_spec::{Attribute, DocNamedType, Type};
 
 impl DocNamedType {
     pub fn to_auxiliary_c(&self) -> String {
         let doc_comments: String = Attribute::to_auxiliary_c_merged(&self.attributes);
         let ident = &self.name.to_rust();
-        let r#type = self.r#type.to_auxiliary_c(false);
+        let r#type = self.r#type.to_auxiliary_c(false, Some(&self.name));
-        format!("{}{} {};", doc_comments, r#type, ident)
+
+        if let Type::Function { .. } = self.r#type {
+            format!("{}{};\n", doc_comments, r#type)
+        } else {
+            format!("{}{} {};\n", doc_comments, r#type, ident)
+        }
     }
 }

src/macros/generate/convert/auxiliary/c/type/mod.rs

@@ -23,7 +23,7 @@
 use proc_macro2::TokenStream as TokenStream2;
 use quote::quote;
 
-use crate::parser::command_spec::{NamedType, Type};
+use crate::parser::command_spec::{Identifier, Type};
 
 mod doc_named_type;
 mod named_type;
@@ -32,7 +32,7 @@ mod named_type;
 // pub use named_type::*;
 
 impl Type {
-    pub fn to_auxiliary_c(&self, is_output: bool) -> TokenStream2 {
+    pub fn to_auxiliary_c(&self, is_output: bool, field_name: Option<&Identifier>) -> TokenStream2 {
         match self {
             Type::Typical {
                 identifier,
@@ -55,18 +55,23 @@ impl Type {
                 assert_eq!(is_output, false);
 
                 let output = if let Some(output) = output {
-                    output.to_auxiliary_c(false)
+                    output.to_auxiliary_c(false, None)
                 } else {
                     quote! {
                         void
                     }
                 };
 
-                let inputs: Vec<TokenStream2> =
+                let inputs: Vec<TokenStream2> = inputs
-                    inputs.iter().map(NamedType::to_auxiliary_c).collect();
+                    .iter()
+                    .map(|input| &input.r#type)
+                    .map(|r#type| r#type.to_auxiliary_c(false, field_name))
+                    .collect();
+
+                let field_name = field_name.expect("This is some, when I'm a function type").to_rust();
 
                 quote! {
-                    #output (*name) (#(#inputs),*)
+                    #output (*#field_name) (#(#inputs),*)
                 }
             }
         }

src/macros/generate/convert/auxiliary/c/type/named_type.rs

@@ -23,14 +23,21 @@
 use proc_macro2::TokenStream as TokenStream2;
 use quote::quote;
 
-use crate::parser::command_spec::NamedType;
+use crate::parser::command_spec::{NamedType, Type};
 
 impl NamedType {
     pub fn to_auxiliary_c(&self) -> TokenStream2 {
         let ident = self.name.to_rust();
-        let c_type = self.r#type.to_auxiliary_c(false);
+        let c_type = self.r#type.to_auxiliary_c(false, Some(&self.name));
+
+        if let Type::Function { .. } = self.r#type {
+            quote! {
+                #c_type
+            }
+        } else {
             quote! {
                 #c_type #ident
             }
         }
+    }
 }

tests/types/expected.md

@@ -162,7 +162,7 @@ struct Callback
   /**
    * Very important field
    */
-  const char *(*name) (const char *name)func;
+  const char *(*func) (const char *);
   /**
    * Very important field for keeping time constant
    */