Handle no return attributes

src/clang.rs

@@ -645,6 +645,24 @@ impl Cursor {
         self.has_attr("warn_unused_result", Some(CXCursor_WarnUnusedResultAttr))
     }
 
+    pub fn has_no_return_attr(&self) -> bool {
+        let mut found_attr = false;
+        self.visit(|cur| {
+            found_attr = cur.kind() == CXCursor_UnexposedAttr &&
+                cur.tokens().iter().any(|t| {
+                    t.kind == CXToken_Keyword && t.spelling() == b"_Noreturn"
+                });
+
+            if found_attr {
+                CXChildVisit_Break
+            } else {
+                CXChildVisit_Continue
+            }
+        });
+
+        found_attr
+    }
+
     /// Does this cursor have the given attribute?
     ///
     /// `name` is checked against unexposed attributes.

src/codegen/mod.rs

@@ -4704,6 +4704,10 @@ pub mod utils {
         ctx: &BindgenContext,
         sig: &FunctionSig,
     ) -> proc_macro2::TokenStream {
+        if sig.is_divergent() {
+            return quote! { -> ! };
+        }
+
         let return_item = ctx.resolve_item(sig.return_type());
         if let TypeKind::Void = *return_item.kind().expect_type().kind() {
             quote! {}

src/ir/function.rs

@@ -228,6 +228,7 @@ pub struct FunctionSig {
 
     /// Whether this function is variadic.
     is_variadic: bool,
+    is_divergent: bool,
 
     /// Whether this function's return value must be used.
     must_use: bool,
@@ -358,13 +359,15 @@ impl FunctionSig {
         return_type: TypeId,
         argument_types: Vec<(Option<String>, TypeId)>,
         is_variadic: bool,
+        is_divergent: bool,
         must_use: bool,
         abi: Abi,
     ) -> Self {
         FunctionSig {
             return_type,
             argument_types,
             is_variadic,
+            is_divergent,
             must_use,
             abi,
         }
@@ -378,6 +381,7 @@ impl FunctionSig {
     ) -> Result<Self, ParseError> {
         use clang_sys::*;
         debug!("FunctionSig::from_ty {:?} {:?}", ty, cursor);
+        let is_divergent = cursor.has_no_return_attr();
 
         // Skip function templates
         let kind = cursor.kind();
@@ -528,7 +532,14 @@ impl FunctionSig {
             warn!("Unknown calling convention: {:?}", call_conv);
         }
 
-        Ok(Self::new(ret, args, ty.is_variadic(), must_use, abi))
+        Ok(Self::new(
+            ret,
+            args,
+            ty.is_variadic(),
+            is_divergent,
+            must_use,
+            abi,
+        ))
     }
 
     /// Get this function signature's return type.
@@ -575,6 +586,10 @@ impl FunctionSig {
 
         matches!(self.abi, Abi::C | Abi::Unknown(..))
     }
+
+    pub(crate) fn is_divergent(&self) -> bool {
+        self.is_divergent
+    }
 }
 
 impl ClangSubItemParser for Function {

tests/headers/noreturn.h

@@ -0,0 +1,3 @@
+_Noreturn void f(void);
+// TODO (pvdrz): figure out how to handle this case.
+__attribute__((noreturn)) void g(void);