Move codegen config checks into Codegen impls

This means that we only need to check in one place, rather than at ever call
site.

Author: fitzgen

src/codegen/mod.rs

@@ -1760,49 +1760,43 @@ impl CodeGenerator for CompInfo {
             }
 
             let mut method_names = Default::default();
-            if ctx.options().codegen_config.methods {
-                for method in self.methods() {
-                    assert!(method.kind() != MethodKind::Constructor);
-                    method.codegen_method(ctx,
-                                          &mut methods,
-                                          &mut method_names,
-                                          result,
-                                          whitelisted_items,
-                                          self);
-                }
-            }
-
-            if ctx.options().codegen_config.constructors {
-                for sig in self.constructors() {
-                    Method::new(MethodKind::Constructor,
-                                *sig,
-                                /* const */
-                                false)
-                        .codegen_method(ctx,
-                                        &mut methods,
-                                        &mut method_names,
-                                        result,
-                                        whitelisted_items,
-                                        self);
-                }
-            }
-
-            if ctx.options().codegen_config.destructors {
-                if let Some((is_virtual, destructor)) = self.destructor() {
-                    let kind = if is_virtual {
-                        MethodKind::VirtualDestructor
-                    } else {
-                        MethodKind::Destructor
-                    };
+            for method in self.methods() {
+                assert!(method.kind() != MethodKind::Constructor);
+                method.codegen_method(ctx,
+                                      &mut methods,
+                                      &mut method_names,
+                                      result,
+                                      whitelisted_items,
+                                      self);
+            }
+
+            for sig in self.constructors() {
+                Method::new(MethodKind::Constructor,
+                            *sig,
+                            /* const */
+                            false)
+                    .codegen_method(ctx,
+                                    &mut methods,
+                                    &mut method_names,
+                                    result,
+                                    whitelisted_items,
+                                    self);
+            }
+
+            if let Some((is_virtual, destructor)) = self.destructor() {
+                let kind = if is_virtual {
+                    MethodKind::VirtualDestructor
+                } else {
+                    MethodKind::Destructor
+                };
 
-                    Method::new(kind, destructor, false)
-                        .codegen_method(ctx,
-                                        &mut methods,
-                                        &mut method_names,
-                                        result,
-                                        whitelisted_items,
-                                        self);
-                }
+                Method::new(kind, destructor, false)
+                    .codegen_method(ctx,
+                                    &mut methods,
+                                    &mut method_names,
+                                    result,
+                                    whitelisted_items,
+                                    self);
             }
         }
 
@@ -1897,6 +1891,17 @@ impl MethodCodegen for Method {
                           result: &mut CodegenResult<'a>,
                           whitelisted_items: &ItemSet,
                           _parent: &CompInfo) {
+        let config = &ctx.options().codegen_config;
+        match self.kind() {
+            MethodKind::Constructor if !config.constructors => return,
+            MethodKind::Destructor if !config.destructors => return,
+            MethodKind::VirtualDestructor if !config.destructors => return,
+            MethodKind::Static if !config.methods => return,
+            MethodKind::Normal if !config.methods => return,
+            MethodKind::Virtual if !config.methods => return,
+            _ => {}
+        }
+
         if self.is_virtual() {
             return; // FIXME
         }

tests/expectations/tests/issue-826-generating-methods-when-asked-not-to.rs

@@ -0,0 +1,25 @@
+/* automatically generated by rust-bindgen */
+
+
+#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)]
+
+
+#[repr(C)]
+#[derive(Debug, Default, Copy)]
+pub struct Foo {
+    pub _address: u8,
+}
+#[test]
+fn bindgen_test_layout_Foo() {
+    assert_eq!(::std::mem::size_of::<Foo>() , 1usize , concat ! (
+               "Size of: " , stringify ! ( Foo ) ));
+    assert_eq! (::std::mem::align_of::<Foo>() , 1usize , concat ! (
+                "Alignment of " , stringify ! ( Foo ) ));
+}
+impl Clone for Foo {
+    fn clone(&self) -> Self { *self }
+}
+extern "C" {
+    #[link_name = "_ZN3Foo4testEv"]
+    pub fn Foo_test(this: *mut Foo);
+}

tests/headers/issue-826-generating-methods-when-asked-not-to.hpp

@@ -0,0 +1,5 @@
+// bindgen-flags: --ignore-methods
+
+struct Foo {
+    void test();
+};