Use a graph the represend the dependencies between exported items

Cargo.toml

@@ -22,6 +22,7 @@ serde_derive = "0.9"
 serde_json = "0.9"
 tempdir = "0.3"
 toml = "0.3"
+petgraph = "0.4"
 
 [dependencies.syn]
 version = "0.11"

compile-tests/cycle.rs

@@ -0,0 +1,13 @@
+#[repr(C)]
+pub struct Foo {
+    a: i32,
+    b: *const Bar,
+}
+
+#[repr(C)]
+pub struct Bar {
+    a: *mut Foo,
+}
+
+#[no_mangle]
+pub extern "C" fn foo(f: Foo) {}

src/bindgen/bindings.rs

@@ -8,27 +8,20 @@ use std::path;
 use std::fs;
 
 use bindgen::config::{Config, Language};
-use bindgen::ir::{Item, Function};
-use bindgen::monomorph::TemplateSpecialization;
-use bindgen::writer::{ListType, Source, SourceWriter};
+use bindgen::ir::Item;
+use bindgen::writer::{Source, SourceWriter};
 
 pub struct Bindings {
     config: Config,
     items: Vec<Item>,
-    functions: Vec<Function>,
-    template_specializations: Vec<TemplateSpecialization>,
 }
 
 impl Bindings {
     pub fn new(config: Config,
-               items: Vec<Item>,
-               functions: Vec<Function>,
-               template_specializations: Vec<TemplateSpecialization>) -> Bindings {
+               items: Vec<Item>) -> Bindings {
         Bindings {
-            config: config,
-            items: items,
-            functions: functions,
-            template_specializations: template_specializations,
+            config,
+            items,
         }
     }
 
@@ -83,77 +76,25 @@ impl Bindings {
 
         if self.config.language == Language::Cxx {
             out.new_line_if_not_start();
-            out.write("extern \"C\" {");
-            out.new_line();
 
             self.open_namespaces(&mut out);
         }
 
-        for item in &self.items {
-            out.new_line_if_not_start();
-            match item {
-                &Item::Enum(ref x) => x.write(&self.config, &mut out),
-                &Item::Struct(ref x) => x.write(&self.config, &mut out),
-                &Item::OpaqueItem(ref x) => x.write(&self.config, &mut out),
-                &Item::Typedef(ref x) => x.write(&self.config, &mut out),
-                &Item::Specialization(_) => {
-                    unreachable!("should not encounter a specialization in a generated library")
-                }
-            }
-            out.new_line();
-        }
 
         if let Some(ref f) = self.config.autogen_warning {
             out.new_line_if_not_start();
             out.write(&f);
             out.new_line();
         }
 
-        for function in &self.functions {
+        for item in &self.items {
             out.new_line_if_not_start();
-            function.write(&self.config, &mut out);
+            item.write(&self.config, &mut out);
             out.new_line();
         }
 
         if self.config.language == Language::Cxx {
             self.close_namespaces(&mut out);
-
-            out.new_line_if_not_start();
-            out.write("} // extern \"C\"");
-            out.new_line();
-        }
-
-        if self.config.structure.generic_template_specialization &&
-           self.config.language == Language::Cxx {
-            self.open_namespaces(&mut out);
-            for template in &self.template_specializations {
-              out.new_line_if_not_start();
-              out.write("template<");
-              for (i, param) in template.generic.generic_params.iter().enumerate() {
-                  if i != 0 {
-                      out.write(", ")
-                  }
-                  out.write("typename ");
-                  out.write(param);
-              }
-              out.write(">");
-              out.new_line();
-              out.write(&format!("struct {};", template.generic.name));
-              out.new_line();
-
-              for &(ref monomorph_path, ref generic_values) in &template.monomorphs {
-                out.new_line();
-                out.write("template<>");
-                out.new_line();
-                out.write(&format!("struct {}<", template.generic.name));
-                out.write_horizontal_source_list(generic_values, ListType::Join(", "));
-                out.write(&format!("> : public {}", monomorph_path));
-                out.open_brace();
-                out.close_brace(true);
-                out.new_line();
-              }
-            }
-            self.close_namespaces(&mut out);
         }
 
         if let Some(ref f) = self.config.autogen_warning {

src/bindgen/builder.rs

@@ -11,7 +11,7 @@ use syn;
 use bindgen::cargo::Cargo;
 use bindgen::config::Config;
 use bindgen::ir::{AnnotationSet, Cfg, Documentation, Enum, Function};
-use bindgen::ir::{OpaqueItem, Specialization, Struct, Typedef};
+use bindgen::ir::{OpaqueItem, Struct, Typedef};
 use bindgen::library::Library;
 use bindgen::rust_lib;
 use bindgen::utilities::{SynAbiHelpers, SynItemHelpers};
@@ -25,7 +25,6 @@ pub struct LibraryBuilder {
     structs: BTreeMap<String, Struct>,
     opaque_items: BTreeMap<String, OpaqueItem>,
     typedefs: BTreeMap<String, Typedef>,
-    specializations: BTreeMap<String, Specialization>,
     functions: Vec<Function>,
 }
 
@@ -39,7 +38,6 @@ impl LibraryBuilder {
             structs: BTreeMap::new(),
             opaque_items: BTreeMap::new(),
             typedefs: BTreeMap::new(),
-            specializations: BTreeMap::new(),
             functions: Vec::new(),
         }
     }
@@ -115,14 +113,11 @@ impl LibraryBuilder {
             })?;
         }
 
-        self.functions.sort_by(|x, y| x.name.cmp(&y.name));
-
         Ok(Library::new(self.config,
                         self.enums,
                         self.structs,
                         self.opaque_items,
                         self.typedefs,
-                        self.specializations,
                         self.functions))
     }
 
@@ -333,42 +328,23 @@ impl LibraryBuilder {
                    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(),
+                            &item.attrs,
+                            generics,
+                            ty,
+                            mod_cfg)
         {
-            match Typedef::load(alias_name.clone(),
-                                ty,
-                                &item.attrs,
-                                mod_cfg)
-            {
-                Ok(typedef) => {
-                    info!("take {}::{}", crate_name, &item.ident);
-                    self.typedefs.insert(alias_name, 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) => {
+            Ok(typedef) => {
                 info!("take {}::{}", crate_name, &item.ident);
-                self.specializations.insert(alias_name, spec);
+                self.typedefs.insert(alias_name, typedef);
                 return;
             }
-            Err(msg) => msg,
-        };
-
-        info!("skip {}::{} - ({} and {})",
-              crate_name,
-              &item.ident,
-              fail1,
-              fail2);
+            Err(msg) => {
+                info!("skip {}::{} - ({})",
+                    crate_name,
+                    &item.ident,
+                    msg);
+            },
+        }
     }
 }

src/bindgen/cdecl.rs

@@ -62,17 +62,14 @@ impl CDecl {
     fn build_type(&mut self, t: &Type, is_const: bool) {
         match t {
             &Type::Path(ref path) => {
-                // We should be assured that there are no generics by instantiating
-                // monomorphs and mangling paths.
-                assert!(path.generics.len() == 0);
 
                 if is_const {
                     assert!(self.type_qualifers.len() == 0);
                     self.type_qualifers = "const".to_owned();
                 }
 
                 assert!(self.type_name.len() == 0);
-                self.type_name = path.name.clone();
+                self.type_name = path.mangle();
             }
             &Type::Primitive(ref p) => {
                 if is_const {