fn load_fn_declaration()

in src/bindgen/parser.rs [699:758]

• 57 lines of code
• 5 McCabe index (conditional complexity)

    fn load_fn_declaration(
        &mut self,
        config: &Config,
        binding_crate_name: &str,
        crate_name: &str,
        mod_cfg: Option<&Cfg>,
        named_symbol: &dyn SynItemHelpers,
        self_type: Option<&Path>,
        sig: &syn::Signature,
        attrs: &[syn::Attribute],
    ) {
        if !config
            .parse
            .should_generate_top_level_item(crate_name, binding_crate_name)
        {
            info!(
                "Skip {}::{} - (fn's outside of the binding crate are not used).",
                crate_name, &sig.ident
            );
            return;
        }

        let loggable_item_name = || {
            let mut items = Vec::with_capacity(3);
            items.push(crate_name.to_owned());
            if let Some(ref self_type) = self_type {
                items.push(self_type.to_string());
            }
            items.push(sig.ident.unraw().to_string());
            items.join("::")
        };

        let is_extern_c = sig.abi.is_omitted() || sig.abi.is_c();
        let exported_name = named_symbol.exported_name();

        match (is_extern_c, exported_name) {
            (true, Some(exported_name)) => {
                let path = Path::new(exported_name);
                match Function::load(path, self_type, sig, false, attrs, mod_cfg) {
                    Ok(func) => {
                        info!("Take {}.", loggable_item_name());
                        self.functions.push(func);
                    }
                    Err(msg) => {
                        error!("Cannot use fn {} ({}).", loggable_item_name(), msg);
                    }
                }
            }
            (true, None) => {
                warn!(
                    "Skipping {} - (not `no_mangle`, and has no `export_name` attribute)",
                    loggable_item_name()
                );
            }
            (false, Some(_exported_name)) => {
                warn!("Skipping {} - (not `extern \"C\"`)", loggable_item_name());
            }
            (false, None) => {}
        }
    }