cbindgen 0.2.0

/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

use std::collections::{HashMap, HashSet};
use std::fs::File;
use std::io::Read;
use std::path::{Path, PathBuf};

use syn;

use bindgen::cargo::{Cargo, PackageRef};
use bindgen::ir::{AnnotationSet, Cfg, Constant, Documentation, Enum, Function};
use bindgen::ir::{ItemMap, OpaqueItem, Specialization, Static, Struct, Typedef, Union};
use bindgen::utilities::{SynAbiHelpers, SynItemHelpers};

const STD_CRATES: &'static [&'static str] = &["std",
                                              "std_unicode",
                                              "alloc",
                                              "collections",
                                              "core",
                                              "proc_macro"];

type ParseResult = Result<Parse, String>;

/// Parses a single rust source file, not following `mod` or `extern crate`.
pub fn parse_src(src_file: &Path) -> ParseResult {
    let src_parsed = {
        let mut s = String::new();
        let mut f = File::open(src_file).map_err(|_| format!("Parsing: cannot open file `{:?}`.", src_file))?;
        f.read_to_string(&mut s).map_err(|_| format!("Parsing: cannot open file `{:?}`.", src_file))?;
        syn::parse_crate(&s).map_err(|msg| format!("Parsing:\n{}.", msg))?
    };

    let mut parsed = Parse::new();
    parsed.load_syn_crate_mod("", "", &None, &src_parsed.items);
    Ok(parsed)
}

/// Recursively parses a rust library starting at the root crate's directory.
///
/// Inside a crate, `mod` and `extern crate` declarations are followed
/// and parsed. To find an external crate, the parser uses the `cargo metadata`
/// command to find the location of dependencies.
pub fn parse_lib(lib: Cargo,
                 parse_deps: bool,
                 include: &Option<Vec<String>>,
                 exclude: &Vec<String>,
                 expand: &Vec<String>) -> ParseResult {
    let mut context = Parser {
        lib: lib,
        parse_deps: parse_deps,
        include: include.clone(),
        exclude: exclude.clone(),
        expand: expand.clone(),
        parsed_crates: HashSet::new(),
        cache_src: HashMap::new(),
        cache_expanded_crate: HashMap::new(),
        cfg_stack: Vec::new(),
        out: Parse::new(),
    };

    let binding_crate = context.lib.binding_crate_ref();
    context.parse_crate(&binding_crate)?;
    Ok(context.out)
}

#[derive(Debug, Clone)]
struct Parser {
    lib: Cargo,
    parse_deps: bool,

    include: Option<Vec<String>>,
    exclude: Vec<String>,
    expand: Vec<String>,

    parsed_crates: HashSet<String>,
    cache_src: HashMap<PathBuf, Vec<syn::Item>>,
    cache_expanded_crate: HashMap<String, Vec<syn::Item>>,

    cfg_stack: Vec<Cfg>,

    out: Parse,
}

impl Parser {
    fn should_parse_dependency(&self, pkg_name: &String) -> bool {
        if self.parsed_crates.contains(pkg_name) {
            return false;
        }

        if !self.parse_deps {
            return false;
        }

        // Skip any whitelist or blacklist for expand
        if self.expand.contains(&pkg_name) {
            return true;
        }

        // If we have a whitelist, check it
        if let Some(ref include) = self.include {
            if !include.contains(&pkg_name) {
                return false;
            }
        }

        // Check the blacklist
        return !STD_CRATES.contains(&pkg_name.as_ref()) &&
               !self.exclude.contains(&pkg_name);
    }

    fn parse_crate(&mut self, pkg: &PackageRef) -> Result<(), String> {
        self.parsed_crates.insert(pkg.name.clone());

        // Check if we should use cargo expand for this crate
        if self.expand.contains(&pkg.name) {
            return self.parse_expand_crate(pkg);
        }

        // Otherwise do our normal parse
        let crate_src = self.lib.find_crate_src(pkg);

        match crate_src {
            Some(crate_src) => {
                self.parse_mod(pkg, crate_src.as_path())
            },
            None => {
                // This should be an error, but is common enough to just elicit a warning
                warn!("Parsing crate `{}`: can't find lib.rs with `cargo metadata`.", pkg.name);
                Ok(())
            },
        }
    }

    fn parse_expand_crate(&mut self, pkg: &PackageRef) -> Result<(), String> {
        let mod_parsed = {
            if !self.cache_expanded_crate.contains_key(&pkg.name) {
                let s = self.lib.expand_crate(pkg)?;
                let i = syn::parse_crate(&s).map_err(|msg| format!("Parsing crate `{}`:\n{}.", pkg.name, msg))?;
                self.cache_expanded_crate.insert(pkg.name.clone(), i.items);
            }

            self.cache_expanded_crate.get(&pkg.name).unwrap().clone()
        };

        self.process_expanded_mod(pkg, &mod_parsed)
    }

    fn process_expanded_mod(&mut self,
                            pkg: &PackageRef,
                            items: &Vec<syn::Item>) -> Result<(), String> {
        self.out.load_syn_crate_mod(self.lib.binding_crate_name(),
                                       &pkg.name,
                                       &Cfg::join(&self.cfg_stack),
                                       items);

        for item in items {
            match item.node {
                syn::ItemKind::Mod(ref inline_items) => {
                    let cfg = Cfg::load(&item.attrs);
                    if let &Some(ref cfg) = &cfg {
                        self.cfg_stack.push(cfg.clone());
                    }

                    if let &Some(ref inline_items) = inline_items {
                        self.process_expanded_mod(pkg, inline_items)?;
                    } else {
                        error!("Parsing crate `{}`: external mod found in expanded source, this shouldn't be possible.", pkg.name);
                    }

                    if cfg.is_some() {
                        self.cfg_stack.pop();
                    }
                }
                syn::ItemKind::ExternCrate(_) => {
                    let dep_pkg_name = item.ident.to_string();

                    let cfg = Cfg::load(&item.attrs);
                    if let &Some(ref cfg) = &cfg {
                        self.cfg_stack.push(cfg.clone());
                    }

                    if self.should_parse_dependency(&dep_pkg_name) {
                        let dep_pkg_ref = self.lib.find_dep_ref(pkg, &dep_pkg_name);

                        if let Some(dep_pkg_ref) = dep_pkg_ref {
                            self.parse_crate(&dep_pkg_ref)?;
                        } else {
                            error!("Parsing crate `{}`: can't find dependency version for {}`.", pkg.name, dep_pkg_name);
                        }
                    }

                    if cfg.is_some() {
                        self.cfg_stack.pop();
                    }
                }
                _ => {}
            }
        }

        Ok(())
    }

    fn parse_mod(&mut self,
                 pkg: &PackageRef,
                 mod_path: &Path) -> Result<(), String> {
        let mod_parsed = {
            let owned_mod_path = mod_path.to_path_buf();

            if !self.cache_src.contains_key(&owned_mod_path) {
                let mut s = String::new();
                let mut f = File::open(mod_path).map_err(|_| format!("Parsing crate `{}`: cannot open file `{:?}`.", pkg.name, mod_path))?;
                f.read_to_string(&mut s).map_err(|_| format!("Parsing crate `{}`: cannot open file `{:?}`.", pkg.name, mod_path))?;
                let i = syn::parse_crate(&s).map_err(|msg| format!("Parsing crate `{}`:\n{}.", pkg.name, msg))?;
                self.cache_src.insert(owned_mod_path.clone(), i.items);
            }

            self.cache_src.get(&owned_mod_path).unwrap().clone()
        };

        let mod_dir = mod_path.parent().unwrap();

        self.process_mod(pkg,
                         mod_dir,
                        &mod_parsed)
    }

    fn process_mod(&mut self,
                   pkg: &PackageRef,
                   mod_dir: &Path,
                   items: &Vec<syn::Item>) -> Result<(), String> {
        self.out.load_syn_crate_mod(self.lib.binding_crate_name(),
                                       &pkg.name,
                                       &Cfg::join(&self.cfg_stack),
                                       items);

        for item in items {
            match item.node {
                syn::ItemKind::Mod(ref inline_items) => {
                    let next_mod_name = item.ident.to_string();

                    let cfg = Cfg::load(&item.attrs);
                    if let &Some(ref cfg) = &cfg {
                        self.cfg_stack.push(cfg.clone());
                    }

                    if let &Some(ref inline_items) = inline_items {
                        self.process_mod(pkg,
                                         &mod_dir.join(&next_mod_name),
                                         inline_items)?;
                    } else {
                        let next_mod_path1 = mod_dir.join(next_mod_name.clone() + ".rs");
                        let next_mod_path2 = mod_dir.join(next_mod_name.clone()).join("mod.rs");

                        if next_mod_path1.exists() {
                            self.parse_mod(pkg,
                                           next_mod_path1.as_path())?;
                        } else if next_mod_path2.exists() {
                            self.parse_mod(pkg,
                                           next_mod_path2.as_path())?;
                        } else {
                            // This should be an error, but is common enough to just elicit a warning
                            warn!("Parsing crate `{}`: can't find mod {}`.", pkg.name, next_mod_name);
                        }
                    }

                    if cfg.is_some() {
                        self.cfg_stack.pop();
                    }
                }
                syn::ItemKind::ExternCrate(ref cr) => {
                    let dep_pkg_name = if let Some(ref name) = *cr {
                        name.to_string()
                    } else {
                        item.ident.to_string()
                    };

                    let cfg = Cfg::load(&item.attrs);
                    if let &Some(ref cfg) = &cfg {
                        self.cfg_stack.push(cfg.clone());
                    }

                    if self.should_parse_dependency(&dep_pkg_name) {
                        let dep_pkg_ref = self.lib.find_dep_ref(pkg, &dep_pkg_name);

                        if let Some(dep_pkg_ref) = dep_pkg_ref {
                            self.parse_crate(&dep_pkg_ref)?;
                        } else {
                            error!("Parsing crate `{}`: can't find dependency version for {}`.", pkg.name, dep_pkg_name);
                        }
                    }

                    if cfg.is_some() {
                        self.cfg_stack.pop();
                    }
                }
                _ => {}
            }
        }

        Ok(())
    }
}

#[derive(Debug, Clone)]
pub struct Parse {
    pub constants: ItemMap<Constant>,
    pub globals: ItemMap<Static>,
    pub enums: ItemMap<Enum>,
    pub structs: ItemMap<Struct>,
    pub unions: ItemMap<Union>,
    pub opaque_items: ItemMap<OpaqueItem>,
    pub typedefs: ItemMap<Typedef>,
    pub specializations: ItemMap<Specialization>,
    pub functions: Vec<Function>,
}

impl Parse {
    pub fn new() -> Parse {
        Parse {
            constants: ItemMap::new(),
            globals: ItemMap::new(),
            enums: ItemMap::new(),
            structs: ItemMap::new(),
            unions: ItemMap::new(),
            opaque_items: ItemMap::new(),
            typedefs: ItemMap::new(),
            specializations: ItemMap::new(),
            functions: Vec::new(),
        }
    }

    pub fn add_std_types(&mut self) {
        let mut add_opaque = |name: &str, generic_params: Vec<&str>| {
            self.opaque_items.try_insert(OpaqueItem {
                name: name.to_owned(),
                generic_params: generic_params.iter()
                                              .map(|x| (*x).to_owned())
                                              .collect(),
                cfg: None,
                annotations: AnnotationSet::new(),
                documentation: Documentation::none(),
            })
        };

        add_opaque("String", vec![]);
        add_opaque("Box", vec!["T"]);
        add_opaque("Rc", vec!["T"]);
        add_opaque("Arc", vec!["T"]);
        add_opaque("Result", vec!["T", "E"]);
        add_opaque("Option", vec!["T"]);
        add_opaque("Vec", vec!["T"]);
        add_opaque("HashMap", vec!["K", "V"]);
        add_opaque("BTreeMap", vec!["K", "V"]);
        add_opaque("HashSet", vec!["T"]);
        add_opaque("BTreeSet", vec!["T"]);
        add_opaque("LinkedList", vec!["T"]);
        add_opaque("VecDeque", vec!["T"]);
    }

    pub fn extend_with(&mut self, other: &Parse) {
        self.constants.extend_with(&other.constants);
        self.globals.extend_with(&other.globals);
        self.enums.extend_with(&other.enums);
        self.structs.extend_with(&other.structs);
        self.unions.extend_with(&other.unions);
        self.opaque_items.extend_with(&other.opaque_items);
        self.typedefs.extend_with(&other.typedefs);
        self.specializations.extend_with(&other.specializations);
        self.functions.extend_from_slice(&other.functions);
    }

    pub fn load_syn_crate_mod(&mut self,
                              binding_crate_name: &str,
                              crate_name: &str,
                              mod_cfg: &Option<Cfg>,
                              items: &Vec<syn::Item>) {
        for item in items {
            match item.node {
                syn::ItemKind::ForeignMod(ref block) => {
                    self.load_syn_foreign_mod(binding_crate_name,
                                              crate_name,
                                              mod_cfg,
                                              item,
                                              block);
                }
                syn::ItemKind::Fn(ref decl,
                                  ref _unsafe,
                                  ref _const,
                                  ref abi,
                                  ref _generic,
                                  ref _block) => {
                    self.load_syn_fn(binding_crate_name,
                                     crate_name,
                                     mod_cfg,
                                     item,
                                     decl,
                                     abi);
                }
                syn::ItemKind::Const(ref ty, ref expr) => {
                    self.load_syn_const(binding_crate_name,
                                        crate_name,
                                        mod_cfg,
                                        item,
                                        ty,
                                        expr);
                }
                syn::ItemKind::Static(ref ty, ref mutability, ref _expr) => {
                    self.load_syn_static(binding_crate_name,
                                         crate_name,
                                         mod_cfg,
                                         item,
                                         ty,
                                         mutability);
                }
                syn::ItemKind::Struct(ref variant, ref generics) => {
                    self.load_syn_struct(crate_name, mod_cfg, item, variant, generics);
                }
                syn::ItemKind::Union(ref variant, ref generics) => {
                    self.load_syn_union(crate_name, mod_cfg, item, variant, generics);
                }
                syn::ItemKind::Enum(ref variants, ref generics) => {
                    self.load_syn_enum(crate_name, mod_cfg, item, variants, generics);
                }
                syn::ItemKind::Ty(ref ty, ref generics) => {
                    self.load_syn_ty(crate_name, mod_cfg, item, ty, generics);
                }
                _ => { }
            }
        }
    }

    /// Enters a `extern "C" { }` declaration and loads function declarations.
    fn load_syn_foreign_mod(&mut self,
                            binding_crate_name: &str,
                            crate_name: &str,
                            mod_cfg: &Option<Cfg>,
                            item: &syn::Item,
                            block: &syn::ForeignMod) {
        if !block.abi.is_c() {
            info!("Skip {}::{} - (extern block must be extern C).", crate_name, &item.ident);
            return;
        }

        for foreign_item in &block.items {
            match foreign_item.node {
                syn::ForeignItemKind::Fn(ref decl,
                                         ref _generic) => {
                    if crate_name != binding_crate_name {
                        info!("Skip {}::{} - (fn's outside of the binding crate are not used).",
                              crate_name,
                              &foreign_item.ident);
                        return;
                    }

                    match Function::load(foreign_item.ident.to_string(),
                                         decl,
                                         true,
                                         &foreign_item.attrs,
                                         mod_cfg) {
                        Ok(func) => {
                            info!("Take {}::{}.", crate_name, &foreign_item.ident);

                            self.functions.push(func);
                        }
                        Err(msg) => {
                            error!("Cannot use fn {}::{} ({}).",
                                   crate_name,
                                   &foreign_item.ident,
                                   msg);
                        },
                    }
                }
                _ => {}
            }
        }
    }

    /// Loads a `fn` declaration
    fn load_syn_fn(&mut self,
                   binding_crate_name: &str,
                   crate_name: &str,
                   mod_cfg: &Option<Cfg>,
                   item: &syn::Item,
                   decl: &syn::FnDecl,
                   abi: &Option<syn::Abi>) {
        if crate_name != binding_crate_name {
            info!("Skip {}::{} - (fn's outside of the binding crate are not used).",
                  crate_name,
                  &item.ident);
            return;
        }

        if item.is_no_mangle() && (abi.is_omitted() || abi.is_c()) {
            match Function::load(item.ident.to_string(),
                                 decl,
                                 false,
                                 &item.attrs,
                                 mod_cfg) {
                Ok(func) => {
                    info!("Take {}::{}.", crate_name, &item.ident);

                    self.functions.push(func);
                }
                Err(msg) => {
                    error!("Cannot use fn {}::{} ({}).",
                           crate_name,
                           &item.ident,
                           msg);
                },
            }
        } else {
            if (abi.is_omitted() || abi.is_c()) && !item.is_no_mangle() {
                warn!("Skip {}::{} - (`extern` but not `no_mangle`).",
                      crate_name,
                      &item.ident);
            }
            if abi.is_some() && !(abi.is_omitted() || abi.is_c()) {
                warn!("Skip {}::{} - (non `extern \"C\"`).",
                      crate_name,
                      &item.ident);
            }
        }
    }

    /// Loads a `const` declaration
    fn load_syn_const(&mut self,
                      binding_crate_name: &str,
                      crate_name: &str,
                      mod_cfg: &Option<Cfg>,
                      item: &syn::Item,
                      ty: &syn::Ty,
                      expr: &syn::Expr) {
        if crate_name != binding_crate_name {
            info!("Skip {}::{} - (const's outside of the binding crate are not used).",
                  crate_name,
                  &item.ident);
            return;
        }

        let const_name = item.ident.to_string();

        match Constant::load(const_name.clone(),
                             ty,
                             expr,
                             &item.attrs,
                             mod_cfg) {
            Ok(constant) => {
                info!("Take {}::{}.", crate_name, &item.ident);

                self.constants.try_insert(constant);
            }
            Err(msg) => {
                warn!("Skip {}::{} - ({})",
                      crate_name,
                      &item.ident,
                      msg);
            }
        }
    }

    /// Loads a `static` declaration
    fn load_syn_static(&mut self,
                       binding_crate_name: &str,
                       crate_name: &str,
                       mod_cfg: &Option<Cfg>,
                       item: &syn::Item,
                       ty: &syn::Ty,
                       mutability: &syn::Mutability) {
        if crate_name != binding_crate_name {
            info!("Skip {}::{} - (static's outside of the binding crate are not used).",
                  crate_name,
                  &item.ident);
            return;
        }

        let static_name = item.ident.to_string();

        match Static::load(static_name.clone(),
                           ty,
                           mutability,
                           &item.attrs,
                            mod_cfg) {
            Ok(constant) => {
                info!("Take {}::{}.", crate_name, &item.ident);

                self.globals.try_insert(constant);
            }
            Err(msg) => {
                warn!("Skip {}::{} - ({})",
                      crate_name,
                      &item.ident,
                      msg);
            }
        }
    }

    /// Loads a `struct` declaration
    fn load_syn_struct(&mut self,
                       crate_name: &str,
                       mod_cfg: &Option<Cfg>,
                       item: &syn::Item,
                       variant: &syn::VariantData,
                       generics: &syn::Generics) {
        let struct_name = item.ident.to_string();

        match Struct::load(struct_name.clone(),
                           variant,
                           generics,
                           &item.attrs,
                           mod_cfg) {
            Ok(st) => {
                info!("Take {}::{}.", crate_name, &item.ident);

                self.structs.try_insert(st);
            }
            Err(msg) => {
                info!("Take {}::{} - opaque ({}).",
                      crate_name,
                      &item.ident,
                      msg);
                self.opaque_items.try_insert(OpaqueItem::new(struct_name,
                                                             generics,
                                                             &item.attrs,
                                                             mod_cfg));
            }
        }
    }

    /// Loads a `union` declaration
    fn load_syn_union(&mut self,
                      crate_name: &str,
                      mod_cfg: &Option<Cfg>,
                      item: &syn::Item,
                      variant: &syn::VariantData,
                      generics: &syn::Generics) {
        let union_name = item.ident.to_string();

        match Union::load(union_name.clone(),
                          variant,
                          generics,
                          &item.attrs,
                          mod_cfg) {
            Ok(st) => {
                info!("Take {}::{}.", crate_name, &item.ident);

                self.unions.try_insert(st);
            }
            Err(msg) => {
                info!("Take {}::{} - opaque ({}).",
                      crate_name,
                      &item.ident,
                      msg);
                self.opaque_items.try_insert(OpaqueItem::new(union_name,
                                                             generics,
                                                             &item.attrs,
                                                             mod_cfg));
            }
        }
    }

    /// Loads a `enum` declaration
    fn load_syn_enum(&mut self,
                     crate_name: &str,
                     mod_cfg: &Option<Cfg>,
                     item: &syn::Item,
                     variants: &Vec<syn::Variant>,
                     generics: &syn::Generics) {
        if !generics.lifetimes.is_empty() ||
           !generics.ty_params.is_empty() ||
           !generics.where_clause.predicates.is_empty() {
            info!("Skip {}::{} - (has generics or lifetimes or where bounds).",
                  crate_name,
                  &item.ident);
            return;
        }
        let enum_name = item.ident.to_string();

        match Enum::load(enum_name.clone(),
                         variants,
                         &item.attrs,
                         mod_cfg) {
            Ok(en) => {
                info!("Take {}::{}.", crate_name, &item.ident);
                self.enums.try_insert(en);
            }
            Err(msg) => {
                info!("Take {}::{} - opaque ({}).", crate_name, &item.ident, msg);
                self.opaque_items.try_insert(OpaqueItem::new(enum_name,
                                                             generics,
                                                             &item.attrs,
                                                             mod_cfg));
            }
        }
    }

    /// Loads a `type` declaration
    fn load_syn_ty(&mut self,
                   crate_name: &str,
                   mod_cfg: &Option<Cfg>,
                   item: &syn::Item,
                   ty: &syn::Ty,
                   generics: &syn::Generics) {
        let alias_name = item.ident.to_string();

        let fail1 = if generics.lifetimes.is_empty() &&
                       generics.ty_params.is_empty()
        {
            match Typedef::load(alias_name.clone(),
                                ty,
                                &item.attrs,
                                mod_cfg)
            {
                Ok(typedef) => {
                    info!("Take {}::{}.", crate_name, &item.ident);
                    self.typedefs.try_insert(typedef);
                    return;
                }
                Err(msg) => msg,
            }
        } else {
            format!("Cannot have generics in typedef.")
        };

        let fail2 = match Specialization::load(alias_name.clone(),
                                               generics,
                                               ty,
                                               &item.attrs,
                                               mod_cfg) {
            Ok(spec) => {
                info!("Take {}::{}.", crate_name, &item.ident);
                self.specializations.try_insert(spec);
                return;
            }
            Err(msg) => msg,
        };

        info!("Skip {}::{} - ({} and {}).",
              crate_name,
              &item.ident,
              fail1,
              fail2);
    }
}