ir: Unify function checks so they apply to non-methods.

Author: emilio

libbindgen/src/ir/comp.rs

@@ -652,29 +652,6 @@ impl CompInfo {
                     ci.has_destructor |= cur.kind() == CXCursor_Destructor;
                     ci.has_vtable |= is_virtual;
 
-                    let linkage = cur.linkage();
-                    if linkage != CXLinkage_External {
-                        return CXChildVisit_Continue;
-                    }
-
-                    if cur.access_specifier() == CX_CXXPrivate {
-                        return CXChildVisit_Continue;
-                    }
-
-                    let visibility = cur.visibility();
-                    if visibility != CXVisibility_Default {
-                        return CXChildVisit_Continue;
-                    }
-
-                    if cur.is_inlined_function() {
-                        return CXChildVisit_Continue;
-                    }
-
-                    let spelling = cur.spelling();
-                    if spelling.starts_with("operator") {
-                        return CXChildVisit_Continue;
-                    }
-
                     // This used to not be here, but then I tried generating
                     // stylo bindings with this (without path filters), and
                     // cried a lot with a method in gfx/Point.h
@@ -691,8 +668,10 @@ impl CompInfo {
 
                     // NB: This gets us an owned `Function`, not a
                     // `FunctionSig`.
-                    let signature = Item::parse(cur, Some(potential_id), ctx)
-                        .expect("CXXMethod");
+                    let signature = match Item::parse(cur, Some(potential_id), ctx) {
+                        Ok(item) if ctx.resolve_item(item).kind().is_function() => item,
+                        _ => return CXChildVisit_Continue,
+                    };
 
                     match cur.kind() {
                         CXCursor_Constructor => {

libbindgen/src/ir/function.rs

@@ -150,6 +150,7 @@ impl FunctionSig {
         } else {
             ty.declaration()
         };
+
         let mut args: Vec<_> = match cursor.kind() {
             CXCursor_FunctionDecl |
             CXCursor_Constructor |
@@ -262,6 +263,24 @@ impl ClangSubItemParser for Function {
 
         debug!("Function::parse({:?}, {:?})", cursor, cursor.cur_type());
 
+        let visibility = cursor.visibility();
+        if visibility != CXVisibility_Default {
+            return Err(ParseError::Continue);
+        }
+
+        if cursor.access_specifier() == CX_CXXPrivate {
+            return Err(ParseError::Continue);
+        }
+
+        if cursor.is_inlined_function() {
+            return Err(ParseError::Continue);
+        }
+
+        let linkage = cursor.linkage();
+        if linkage != CXLinkage_External && linkage != CXLinkage_UniqueExternal {
+            return Err(ParseError::Continue);
+        }
+
         // Grab the signature using Item::from_ty.
         let sig = try!(Item::from_ty(&cursor.cur_type(),
                                      Some(cursor),

libbindgen/tests/expectations/tests/inline-function.rs

@@ -0,0 +1,7 @@
+/* automatically generated by rust-bindgen */
+
+
+#![allow(non_snake_case)]
+
+
+

libbindgen/tests/expectations/tests/namespace.rs

@@ -37,9 +37,22 @@ pub mod root {
             assert_eq!(::std::mem::size_of::<A>() , 4usize);
             assert_eq!(::std::mem::align_of::<A>() , 4usize);
         }
+        extern "C" {
+            #[link_name = "_ZN12_GLOBAL__N_11A20lets_hope_this_worksEv"]
+            pub fn A_lets_hope_this_works(this:
+                                              *mut root::_bindgen_mod_id_13::A)
+             -> ::std::os::raw::c_int;
+        }
         impl Clone for A {
             fn clone(&self) -> Self { *self }
         }
+        impl A {
+            #[inline]
+            pub unsafe fn lets_hope_this_works(&mut self)
+             -> ::std::os::raw::c_int {
+                A_lets_hope_this_works(&mut *self)
+            }
+        }
     }
     #[repr(C)]
     #[derive(Debug)]

libbindgen/tests/headers/inline-function.h

@@ -0,0 +1,6 @@
+// bindgen-unstable
+
+/** The point of this test is to _not_ generate these functions. */
+
+inline static int myadd(const int x, const int y) { return x + y; }
+static int mysub(const int x, const int y) { return x - y; }