Allow macro definitions to pick up precise C types

Upon activating the `--macro-const-use-ctypes` flag, `bindgen` should
generate bindings with precise type resolution to the exact C types.

This flag implies `--clang-macro-fallback` as its pre-requisite.

Signed-off-by: Xiangfei Ding <dingxiangfei2009@protonmail.ch>

Author: dingxiangfei2009

bindgen-tests/tests/expectations/tests/issue-753.rs

@@ -7,6 +7,6 @@
 
 #define CONST UINT32_C(5)
 #define OTHER_CONST UINT32_C(6)
-#define LARGE_CONST UINT32_C(6 << 8)
+#define LARGE_CONST (UINT32_C(6) << 8)
 
 #endif

bindgen-tests/tests/expectations/tests/issue-923.rs

@@ -0,0 +1,13 @@
+// bindgen-flags: --macro-const-use-ctypes
+
+#ifndef ISSUE_923_H
+#define ISSUE_923_H
+
+#define ULONG_ZERO 0UL
+#define ULONGLONG_ZERO 0ULL
+#define CHAR_ZERO ((char)'\0')
+#define FLOAT_LIT 0.f
+#define DOUBLE_LIT ((double)0.f)
+#define UINT_LIT 0x80000000
+
+#endif

bindgen-tests/tests/expectations/tests/libclang-9/issue-923.rs

@@ -269,6 +269,16 @@ fn create_bindgen_builder(header: &Path) -> Result<BuilderState, Error> {
 
     let source = fs::File::open(header)?;
     let reader = BufReader::new(source);
+    let basename = header.file_name().unwrap();
+    let per_test_folder = format!(
+        "./{}",
+        basename
+            .to_str()
+            .unwrap()
+            .replace('_', "__")
+            .replace('.', "_")
+    );
+    fs::create_dir_all(&per_test_folder)?;
 
     // Scoop up bindgen-flags from test header
     let mut flags = Vec::with_capacity(2);
@@ -334,6 +344,8 @@ fn create_bindgen_builder(header: &Path) -> Result<BuilderState, Error> {
         "#![allow(dead_code, non_snake_case, non_camel_case_types, non_upper_case_globals)]",
         "--raw-line",
         "",
+        "--clang-macro-fallback-build-dir",
+        &per_test_folder,
     ];
 
     let args = prepend.iter().map(ToString::to_string).chain(flags);

bindgen-tests/tests/expectations/tests/test_macro_fallback_non_system_dir.rs

@@ -246,11 +246,10 @@ impl Cursor {
     pub(crate) fn is_toplevel(&self) -> bool {
         let mut semantic_parent = self.fallible_semantic_parent();
 
-        while semantic_parent.is_some() &&
-            (semantic_parent.unwrap().kind() == CXCursor_Namespace ||
-                semantic_parent.unwrap().kind() ==
-                    CXCursor_NamespaceAlias ||
-                semantic_parent.unwrap().kind() == CXCursor_NamespaceRef)
+        while semantic_parent.is_some()
+            && (semantic_parent.unwrap().kind() == CXCursor_Namespace
+                || semantic_parent.unwrap().kind() == CXCursor_NamespaceAlias
+                || semantic_parent.unwrap().kind() == CXCursor_NamespaceRef)
         {
             semantic_parent =
                 semantic_parent.unwrap().fallible_semantic_parent();
@@ -267,9 +266,9 @@ impl Cursor {
     pub(crate) fn is_template_like(&self) -> bool {
         matches!(
             self.kind(),
-            CXCursor_ClassTemplate |
-                CXCursor_ClassTemplatePartialSpecialization |
-                CXCursor_TypeAliasTemplateDecl
+            CXCursor_ClassTemplate
+                | CXCursor_ClassTemplatePartialSpecialization
+                | CXCursor_TypeAliasTemplateDecl
         )
     }
 
@@ -296,9 +295,9 @@ impl Cursor {
     /// Is the referent a fully specialized template specialization without any
     /// remaining free template arguments?
     pub(crate) fn is_fully_specialized_template(&self) -> bool {
-        self.is_template_specialization() &&
-            self.kind() != CXCursor_ClassTemplatePartialSpecialization &&
-            self.num_template_args().unwrap_or(0) > 0
+        self.is_template_specialization()
+            && self.kind() != CXCursor_ClassTemplatePartialSpecialization
+            && self.num_template_args().unwrap_or(0) > 0
     }
 
     /// Is the referent a template specialization that still has remaining free
@@ -324,9 +323,9 @@ impl Cursor {
     pub(crate) fn is_template_parameter(&self) -> bool {
         matches!(
             self.kind(),
-            CXCursor_TemplateTemplateParameter |
-                CXCursor_TemplateTypeParameter |
-                CXCursor_NonTypeTemplateParameter
+            CXCursor_TemplateTemplateParameter
+                | CXCursor_TemplateTypeParameter
+                | CXCursor_NonTypeTemplateParameter
         )
     }
 
@@ -664,9 +663,9 @@ impl Cursor {
         // inline function without a definition, and it's not a defaulted
         // function, we can reasonably safely conclude that it's a deleted
         // function.
-        self.is_inlined_function() &&
-            self.definition().is_none() &&
-            !self.is_defaulted_function()
+        self.is_inlined_function()
+            && self.definition().is_none()
+            && !self.is_defaulted_function()
     }
 
     /// Is the referent a bit field declaration?
@@ -788,11 +787,11 @@ impl Cursor {
                 let found_attr = &mut found_attrs[idx];
                 if !*found_attr {
                     // `attr.name` and` attr.token_kind` are checked against unexposed attributes only.
-                    if attr.kind == Some(kind) ||
-                        (kind == CXCursor_UnexposedAttr &&
-                            cur.tokens().iter().any(|t| {
-                                t.kind == attr.token_kind &&
-                                    t.spelling() == attr.name
+                    if attr.kind == Some(kind)
+                        || (kind == CXCursor_UnexposedAttr
+                            && cur.tokens().iter().any(|t| {
+                                t.kind == attr.token_kind
+                                    && t.spelling() == attr.name
                             }))
                     {
                         *found_attr = true;
@@ -1408,12 +1407,12 @@ impl Type {
     /// to.
     pub(crate) fn pointee_type(&self) -> Option<Type> {
         match self.kind() {
-            CXType_Pointer |
-            CXType_RValueReference |
-            CXType_LValueReference |
-            CXType_MemberPointer |
-            CXType_BlockPointer |
-            CXType_ObjCObjectPointer => {
+            CXType_Pointer
+            | CXType_RValueReference
+            | CXType_LValueReference
+            | CXType_MemberPointer
+            | CXType_BlockPointer
+            | CXType_ObjCObjectPointer => {
                 let ret = Type {
                     x: unsafe { clang_getPointeeType(self.x) },
                 };
@@ -1516,12 +1515,12 @@ impl Type {
         // Yep, the spelling of this containing type-parameter is extremely
         // nasty... But can happen in <type_traits>. Unfortunately I couldn't
         // reduce it enough :(
-        self.template_args().is_some_and(|args| args.len() > 0) &&
-            !matches!(
+        self.template_args().is_some_and(|args| args.len() > 0)
+            && !matches!(
                 self.declaration().kind(),
-                CXCursor_ClassTemplatePartialSpecialization |
-                    CXCursor_TypeAliasTemplateDecl |
-                    CXCursor_TemplateTemplateParameter
+                CXCursor_ClassTemplatePartialSpecialization
+                    | CXCursor_TypeAliasTemplateDecl
+                    | CXCursor_TemplateTemplateParameter
             )
     }
 
@@ -1546,9 +1545,9 @@ impl Type {
                 .is_match(spelling.as_ref())
         }
 
-        self.kind() == CXType_Unexposed &&
-            (hacky_parse_associated_type(self.spelling()) ||
-                hacky_parse_associated_type(
+        self.kind() == CXType_Unexposed
+            && (hacky_parse_associated_type(self.spelling())
+                || hacky_parse_associated_type(
                     self.canonical_type().spelling(),
                 ))
     }
@@ -2309,8 +2308,8 @@ impl EvalResult {
         {
             let mut found_cant_eval = false;
             cursor.visit(|c| {
-                if c.kind() == CXCursor_TypeRef &&
-                    c.cur_type().canonical_type().kind() == CXType_Unexposed
+                if c.kind() == CXCursor_TypeRef
+                    && c.cur_type().canonical_type().kind() == CXType_Unexposed
                 {
                     found_cant_eval = true;
                     return CXChildVisit_Break;
@@ -2329,7 +2328,8 @@ impl EvalResult {
         })
     }
 
-    fn kind(&self) -> CXEvalResultKind {
+    /// Return the kind of the evaluation result.
+    pub(crate) fn kind(&self) -> CXEvalResultKind {
         unsafe { clang_EvalResult_getKind(self.x) }
     }
 
@@ -2370,6 +2370,30 @@ impl EvalResult {
         Some(value as i64)
     }
 
+    /// Try to resolve the result into a string literal.
+    /// This returns `None` if the result is not immediately a string literal.
+    pub(crate) fn as_str_literal(&self) -> Option<Vec<u8>> {
+        if !matches!(
+            self.kind(),
+            CXEval_StrLiteral | CXEval_CFStr | CXEval_ObjCStrLiteral,
+        ) {
+            return None;
+        }
+        // Safety: we are only copying the content, not assuming a borrow.
+        // TODO(@dingxiangfei2009): LLVM Libclang does not return the true size
+        // of a string literal, which could be truncated due to a null character
+        // '\0' in the middle.
+        // Tracking issue: https://github.com/llvm/llvm-project/issues/69749
+        let value =
+            unsafe { CStr::from_ptr(clang_EvalResult_getAsStr(self.x)) };
+        Some(value.to_bytes().into())
+    }
+
+    /// Return the type of the value.
+    pub(crate) fn value_type(&self) -> Type {
+        self.ty
+    }
+
     /// Evaluates the expression as a literal string, that may or may not be
     /// valid utf-8.
     pub(crate) fn as_literal_string(&self) -> Option<Vec<u8>> {

bindgen-tests/tests/headers/issue-753.h

@@ -353,7 +353,7 @@ pub(crate) struct BindgenContext {
     /// hard errors while parsing duplicated macros, as well to allow macro
     /// expression parsing.
     ///
-    /// This needs to be an `std::HashMap` because the `cexpr` API requires it.
+    /// This needs to be an `std::HashMap` because the [`cexpr`] API requires it.
     parsed_macros: StdHashMap<Vec<u8>, cexpr::expr::EvalResult>,
 
     /// A map with all include locations.
@@ -2131,6 +2131,7 @@ If you encounter an error missing from this list, please file an issue or a PR!"
     }
 
     /// Get the currently parsed macros.
+    /// This map only contains macros accepted by [`cexpr`]
     pub(crate) fn parsed_macros(
         &self,
     ) -> &StdHashMap<Vec<u8>, cexpr::expr::EvalResult> {