Explicitly instantiate function return values that are template classes

src/bindgen/config.rs

@@ -341,6 +341,15 @@ pub struct ExportConfig {
     pub renaming_overrides_prefixing: bool,
     /// Mangling configuration.
     pub mangle: MangleConfig,
+    /// Whether to instantiate the monomorphs of template types used as function return values. This
+    /// is needed for C compatibility, because otherwise compilers warn (`-Wreturn-type-c-linkage`
+    /// on gcc/clang) or even reject (MSVC) those function definitions. The compensation is made by
+    /// emitting a single struct with one field for each monomorphized type. The emitted wrapper
+    /// struct's name can optionally be overridden by [`return_value_monomorphs_struct_name`].
+    pub instantiate_return_value_monomorphs: bool,
+    /// Overrides the struct name to use when [`instantiate_return_value_monomorphs`] is enabled
+    /// (ignored otherwise). If not specified, the default is `__cbindgen_return_value_monomorphs`.
+    pub return_value_monomorphs_struct_name: Option<String>,
 }
 
 /// Mangling-specific configuration.

src/bindgen/ir/cfg.rs

@@ -42,7 +42,7 @@ impl<'a> DefineKey<'a> {
     }
 }
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Hash, PartialEq, Eq)]
 pub enum Cfg {
     Boolean(String),
     Named(String, String),
@@ -129,10 +129,10 @@ impl syn::parse::Parse for Cfg {
 
 impl Cfg {
     pub fn join(cfgs: &[Cfg]) -> Option<Cfg> {
-        if cfgs.is_empty() {
-            None
-        } else {
-            Some(Cfg::All(cfgs.to_owned()))
+        match cfgs {
+            [] => None,
+            [cfg] => Some(cfg.clone()),
+            _ => Some(Cfg::All(cfgs.to_owned())),
         }
     }
 

src/bindgen/ir/documentation.rs

@@ -4,7 +4,7 @@
 
 use crate::bindgen::utilities::SynAttributeHelpers;
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Default)]
 pub struct Documentation {
     pub doc_comment: Vec<String>,
 }
@@ -27,8 +27,6 @@ impl Documentation {
     }
 
     pub fn none() -> Self {
-        Documentation {
-            doc_comment: Vec::new(),
-        }
+        Self::default()
     }
 }

src/bindgen/ir/enumeration.rs

@@ -17,7 +17,7 @@ use crate::bindgen::ir::{
 use crate::bindgen::language_backend::LanguageBackend;
 use crate::bindgen::library::Library;
 use crate::bindgen::mangle;
-use crate::bindgen::monomorph::Monomorphs;
+use crate::bindgen::monomorph::{Monomorphs, ReturnValueMonomorphs};
 use crate::bindgen::rename::{IdentifierType, RenameRule};
 use crate::bindgen::reserved;
 use crate::bindgen::writer::{ListType, SourceWriter};
@@ -317,6 +317,16 @@ impl Enum {
         repr.style != ReprStyle::C
     }
 
+    pub fn find_return_value_monomorphs(&self, monomorphs: &mut ReturnValueMonomorphs<'_>) {
+        monomorphs.with_active_cfg(self.cfg.clone(), |m| {
+            for v in &self.variants {
+                if let VariantBody::Body { ref body, .. } = v.body {
+                    body.find_return_value_monomorphs(m);
+                }
+            }
+        });
+    }
+
     pub fn add_monomorphs(&self, library: &Library, out: &mut Monomorphs) {
         if self.is_generic() {
             return;

src/bindgen/ir/function.rs

@@ -9,9 +9,11 @@ use syn::ext::IdentExt;
 use crate::bindgen::config::{Config, Language};
 use crate::bindgen::declarationtyperesolver::DeclarationTypeResolver;
 use crate::bindgen::dependencies::Dependencies;
-use crate::bindgen::ir::{AnnotationSet, Cfg, Documentation, GenericPath, Path, Type};
+use crate::bindgen::ir::{
+    AnnotationSet, Cfg, Documentation, GenericParams, GenericPath, Path, Type,
+};
 use crate::bindgen::library::Library;
-use crate::bindgen::monomorph::Monomorphs;
+use crate::bindgen::monomorph::{Monomorphs, ReturnValueMonomorphs};
 use crate::bindgen::rename::{IdentifierType, RenameRule};
 use crate::bindgen::reserved;
 use crate::bindgen::utilities::IterHelpers;
@@ -47,6 +49,11 @@ impl Function {
         attrs: &[syn::Attribute],
         mod_cfg: Option<&Cfg>,
     ) -> Result<Function, String> {
+        let GenericParams(generics) = GenericParams::load(&sig.generics)?;
+        if !generics.is_empty() {
+            return Err("Generic functions are not supported".to_owned());
+        }
+
         let mut args = sig.inputs.iter().try_skip_map(|x| x.as_argument())?;
         if sig.variadic.is_some() {
             args.push(FunctionArgument {
@@ -129,6 +136,11 @@ impl Function {
         }
     }
 
+    pub fn find_return_value_monomorphs(&self, monomorphs: &mut ReturnValueMonomorphs<'_>) {
+        monomorphs.with_active_cfg(self.cfg.clone(), |m| {
+            m.handle_function(&self.ret, self.args.iter().map(|arg| &arg.ty));
+        });
+    }
     pub fn add_monomorphs(&self, library: &Library, out: &mut Monomorphs) {
         self.ret.add_monomorphs(library, out);
         for arg in &self.args {

src/bindgen/ir/structure.rs

@@ -15,7 +15,7 @@ use crate::bindgen::ir::{
 };
 use crate::bindgen::library::Library;
 use crate::bindgen::mangle;
-use crate::bindgen::monomorph::Monomorphs;
+use crate::bindgen::monomorph::{Monomorphs, ReturnValueMonomorphs};
 use crate::bindgen::rename::{IdentifierType, RenameRule};
 use crate::bindgen::reserved;
 use crate::bindgen::utilities::IterHelpers;
@@ -168,10 +168,17 @@ impl Struct {
 
     /// Attempts to convert this struct to a typedef (only works for transparent structs).
     pub fn as_typedef(&self) -> Option<Typedef> {
-        match self.fields.first() {
-            Some(field) if self.is_transparent => Some(Typedef::new_from_struct_field(self, field)),
-            _ => None,
-        }
+        let field = self.fields.first()?;
+        self.is_transparent
+            .then(|| Typedef::new_from_struct_field(self, field))
+    }
+
+    pub fn find_return_value_monomorphs(&self, monomorphs: &mut ReturnValueMonomorphs<'_>) {
+        monomorphs.with_active_cfg(self.cfg.clone(), |m| {
+            for field in &self.fields {
+                field.ty.find_return_value_monomorphs(m, false);
+            }
+        });
     }
 
     pub fn add_monomorphs(&self, library: &Library, out: &mut Monomorphs) {

src/bindgen/ir/ty.rs

@@ -11,7 +11,7 @@ use crate::bindgen::declarationtyperesolver::DeclarationTypeResolver;
 use crate::bindgen::dependencies::Dependencies;
 use crate::bindgen::ir::{GenericArgument, GenericParams, GenericPath, Path};
 use crate::bindgen::library::Library;
-use crate::bindgen::monomorph::Monomorphs;
+use crate::bindgen::monomorph::{Monomorphs, ReturnValueMonomorphs};
 use crate::bindgen::utilities::IterHelpers;
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
@@ -739,6 +739,22 @@ impl Type {
         self.add_dependencies_ignoring_generics(&GenericParams::default(), library, out)
     }
 
+    pub fn find_return_value_monomorphs(
+        &self,
+        monomorphs: &mut ReturnValueMonomorphs<'_>,
+        is_return_value: bool,
+    ) {
+        match self {
+            Type::Ptr { ty, .. } => ty.find_return_value_monomorphs(monomorphs, false),
+            Type::Path(generic) => monomorphs.handle_return_value_path(generic, is_return_value),
+            Type::Primitive(_) => {}
+            Type::Array(ty, _) => ty.find_return_value_monomorphs(monomorphs, false),
+            Type::FuncPtr { ret, args, .. } => {
+                monomorphs.handle_function(ret, args.iter().map(|(_, arg)| arg))
+            }
+        }
+    }
+
     pub fn add_monomorphs(&self, library: &Library, out: &mut Monomorphs) {
         match *self {
             Type::Ptr { ref ty, .. } => {

src/bindgen/ir/typedef.rs

@@ -15,7 +15,7 @@ use crate::bindgen::ir::{
 };
 use crate::bindgen::library::Library;
 use crate::bindgen::mangle;
-use crate::bindgen::monomorph::Monomorphs;
+use crate::bindgen::monomorph::{Monomorphs, ReturnValueMonomorphs};
 
 /// A type alias that is represented as a C typedef
 #[derive(Debug, Clone)]
@@ -102,6 +102,17 @@ impl Typedef {
         }
     }
 
+    pub fn find_return_value_monomorphs(
+        &self,
+        monomorphs: &mut ReturnValueMonomorphs<'_>,
+        is_return_value: bool,
+    ) {
+        monomorphs.with_active_cfg(self.cfg.clone(), |m| {
+            self.aliased
+                .find_return_value_monomorphs(m, is_return_value);
+        });
+    }
+
     pub fn add_monomorphs(&self, library: &Library, out: &mut Monomorphs) {
         // Generic structs can instantiate monomorphs only once they've been
         // instantiated. See `instantiate_monomorph` for more details.

src/bindgen/ir/union.rs

@@ -13,7 +13,7 @@ use crate::bindgen::ir::{
 };
 use crate::bindgen::library::Library;
 use crate::bindgen::mangle;
-use crate::bindgen::monomorph::Monomorphs;
+use crate::bindgen::monomorph::{Monomorphs, ReturnValueMonomorphs};
 use crate::bindgen::rename::{IdentifierType, RenameRule};
 use crate::bindgen::utilities::IterHelpers;
 
@@ -100,6 +100,14 @@ impl Union {
         }
     }
 
+    pub fn find_return_value_monomorphs(&self, monomorphs: &mut ReturnValueMonomorphs<'_>) {
+        monomorphs.with_active_cfg(self.cfg.clone(), |m| {
+            for field in &self.fields {
+                field.ty.find_return_value_monomorphs(m, false);
+            }
+        });
+    }
+
     pub fn add_monomorphs(&self, library: &Library, out: &mut Monomorphs) {
         // Generic unions can instantiate monomorphs only once they've been
         // instantiated. See `instantiate_monomorph` for more details.

src/bindgen/library.rs

@@ -10,9 +10,11 @@ use crate::bindgen::config::{Config, Language, SortKey};
 use crate::bindgen::declarationtyperesolver::DeclarationTypeResolver;
 use crate::bindgen::dependencies::Dependencies;
 use crate::bindgen::error::Error;
-use crate::bindgen::ir::{Constant, Enum, Function, Item, ItemContainer, ItemMap};
-use crate::bindgen::ir::{OpaqueItem, Path, Static, Struct, Typedef, Union};
-use crate::bindgen::monomorph::Monomorphs;
+use crate::bindgen::ir::{
+    Constant, Enum, Function, Item, ItemContainer, ItemMap, OpaqueItem, Path, Static, Struct,
+    Typedef, Union,
+};
+use crate::bindgen::monomorph::{Monomorphs, ReturnValueMonomorphs};
 use crate::bindgen::ItemType;
 
 #[derive(Debug, Clone)]
@@ -81,6 +83,12 @@ impl Library {
 
         let mut dependencies = Dependencies::new();
 
+        if self.config.language == Language::Cxx
+            && self.config.export.instantiate_return_value_monomorphs
+        {
+            self.instantiate_return_value_monomorphs(&mut dependencies);
+        }
+
         for function in &self.functions {
             function.add_dependencies(&self, &mut dependencies);
         }
@@ -447,4 +455,28 @@ impl Library {
             x.mangle_paths(&monomorphs);
         }
     }
+
+    fn instantiate_return_value_monomorphs(&mut self, dependencies: &mut Dependencies) {
+        let mut monomorphs = ReturnValueMonomorphs::new(self);
+        self.structs
+            .for_all_items(|x| x.find_return_value_monomorphs(&mut monomorphs));
+        self.unions
+            .for_all_items(|x| x.find_return_value_monomorphs(&mut monomorphs));
+        self.enums
+            .for_all_items(|x| x.find_return_value_monomorphs(&mut monomorphs));
+        self.typedefs
+            .for_all_items(|x| x.find_return_value_monomorphs(&mut monomorphs, false));
+        for x in &self.functions {
+            x.find_return_value_monomorphs(&mut monomorphs);
+        }
+
+        let struct_name = match self.config.export.return_value_monomorphs_struct_name {
+            Some(ref name) => name,
+            _ => "__cbindgen_return_value_monomorphs",
+        };
+        if let Some((struct_name, struct_def)) = monomorphs.into_struct(struct_name) {
+            self.structs.try_insert(struct_def);
+            struct_name.add_dependencies(self, dependencies);
+        }
+    }
 }