Keep radix for integer literals in generated bindings

Author: miikkas

bindgen/clang.rs

@@ -5,6 +5,7 @@
 #![deny(clippy::missing_docs_in_private_items)]
 
 use crate::ir::context::BindgenContext;
+use crate::ir::var::LiteralRadix;
 use clang_sys::*;
 use std::cmp;
 
@@ -973,6 +974,20 @@ impl Cursor {
     pub(crate) fn is_inline_namespace(&self) -> bool {
         unsafe { clang_Cursor_isInlineNamespace(self.x) != 0 }
     }
+
+    /// Obtain the number base (radix) of a literal definition corresponding to the cursor.
+    ///
+    /// Returns `None` if unable to infer a base.
+    pub(crate) fn get_literal_radix(&self) -> Option<LiteralRadix> {
+        self.cexpr_tokens()
+            .iter()
+            .filter(|cexpr_token| {
+                cexpr_token.kind == cexpr::token::Kind::Literal
+            })
+            .find_map(|lit_tok| {
+                LiteralRadix::from_literal_token_raw(&lit_tok.raw)
+            })
+    }
 }
 
 /// A struct that owns the tokenizer result from a given cursor.

bindgen/codegen/helpers.rs

@@ -139,6 +139,7 @@ pub(crate) mod ast_ty {
     use crate::ir::function::FunctionSig;
     use crate::ir::layout::Layout;
     use crate::ir::ty::{FloatKind, IntKind};
+    use crate::ir::var::LiteralRadix;
     use crate::RustTarget;
     use proc_macro2::TokenStream;
     use std::str::FromStr;
@@ -291,16 +292,70 @@ pub(crate) mod ast_ty {
         }
     }
 
-    pub(crate) fn int_expr(val: i64) -> TokenStream {
+    pub(crate) fn int_expr(
+        val: i64,
+        radix: Option<&LiteralRadix>,
+    ) -> TokenStream {
         // Don't use quote! { #val } because that adds the type suffix.
-        let val = proc_macro2::Literal::i64_unsuffixed(val);
-        quote!(#val)
+        let sign = if val.is_negative() { "-" } else { "" };
+        if let Some(radix) = radix {
+            match radix {
+                LiteralRadix::Decimal => {
+                    let val = proc_macro2::Literal::i64_unsuffixed(val);
+                    quote!(#val)
+                }
+                LiteralRadix::Binary => {
+                    let val = val.unsigned_abs();
+                    let val = format!("{sign}0b{val:b}");
+                    TokenStream::from_str(val.as_str()).unwrap()
+                }
+                LiteralRadix::Octal => {
+                    let val = val.unsigned_abs();
+                    let val = format!("{sign}0o{val:o}");
+                    TokenStream::from_str(val.as_str()).unwrap()
+                }
+                LiteralRadix::Hexadecimal => {
+                    let val = val.unsigned_abs();
+                    let val = format!("{sign}0x{val:x}");
+                    TokenStream::from_str(val.as_str()).unwrap()
+                }
+            }
+        } else {
+            // same as for Decimal
+            let val = proc_macro2::Literal::i64_unsuffixed(val);
+            quote!(#val)
+        }
     }
 
-    pub(crate) fn uint_expr(val: u64) -> TokenStream {
+    pub(crate) fn uint_expr(
+        val: u64,
+        radix: Option<&LiteralRadix>,
+    ) -> TokenStream {
         // Don't use quote! { #val } because that adds the type suffix.
-        let val = proc_macro2::Literal::u64_unsuffixed(val);
-        quote!(#val)
+        if let Some(radix) = radix {
+            match radix {
+                LiteralRadix::Decimal => {
+                    let val = proc_macro2::Literal::u64_unsuffixed(val);
+                    quote!(#val)
+                }
+                LiteralRadix::Binary => {
+                    let val = format!("0b{val:b}");
+                    TokenStream::from_str(val.as_str()).unwrap()
+                }
+                LiteralRadix::Octal => {
+                    let val = format!("0o{val:o}");
+                    TokenStream::from_str(val.as_str()).unwrap()
+                }
+                LiteralRadix::Hexadecimal => {
+                    let val = format!("0x{val:x}");
+                    TokenStream::from_str(val.as_str()).unwrap()
+                }
+            }
+        } else {
+            // same as for Decimal
+            let val = proc_macro2::Literal::u64_unsuffixed(val);
+            quote!(#val)
+        }
     }
 
     pub(crate) fn cstr_expr(mut string: String) -> TokenStream {

bindgen/codegen/mod.rs

@@ -692,6 +692,7 @@ impl CodeGenerator for Var {
                     });
                 }
                 VarType::Int(val) => {
+                    let radix = self.radix();
                     let int_kind = var_ty
                         .into_resolver()
                         .through_type_aliases()
@@ -701,9 +702,9 @@ impl CodeGenerator for Var {
                         .as_integer()
                         .unwrap();
                     let val = if int_kind.is_signed() {
-                        helpers::ast_ty::int_expr(val)
+                        helpers::ast_ty::int_expr(val, radix)
                     } else {
-                        helpers::ast_ty::uint_expr(val as _)
+                        helpers::ast_ty::uint_expr(val as _, radix)
                     };
                     result.push(quote! {
                         #(#attrs)*
@@ -2438,7 +2439,7 @@ impl CodeGenerator for CompInfo {
             if let Some(explicit) = explicit_align {
                 // Ensure that the struct has the correct alignment even in
                 // presence of alignas.
-                let explicit = helpers::ast_ty::int_expr(explicit as i64);
+                let explicit = helpers::ast_ty::int_expr(explicit as i64, None);
                 attributes.push(quote! {
                     #[repr(align(#explicit))]
                 });
@@ -3384,11 +3385,15 @@ impl EnumBuilder {
         let is_rust_enum = self.is_rust_enum();
         let expr = match variant.val() {
             EnumVariantValue::Boolean(v) if is_rust_enum => {
-                helpers::ast_ty::uint_expr(u64::from(v))
+                helpers::ast_ty::uint_expr(u64::from(v), None)
             }
             EnumVariantValue::Boolean(v) => quote!(#v),
-            EnumVariantValue::Signed(v) => helpers::ast_ty::int_expr(v),
-            EnumVariantValue::Unsigned(v) => helpers::ast_ty::uint_expr(v),
+            EnumVariantValue::Signed(v) => {
+                helpers::ast_ty::int_expr(v, variant.radix())
+            }
+            EnumVariantValue::Unsigned(v) => {
+                helpers::ast_ty::uint_expr(v, variant.radix())
+            }
         };
 
         match self.kind {

bindgen/ir/enum_ty.rs

@@ -6,6 +6,7 @@ use super::item::Item;
 use super::ty::{Type, TypeKind};
 use crate::clang;
 use crate::ir::annotations::Annotations;
+use crate::ir::var::LiteralRadix;
 use crate::parse::ParseError;
 use crate::regex_set::RegexSet;
 
@@ -101,8 +102,10 @@ impl Enum {
                 } else {
                     cursor.enum_val_unsigned().map(EnumVariantValue::Unsigned)
                 };
+
                 if let Some(val) = value {
                     let name = cursor.spelling();
+                    let radix = cursor.get_literal_radix();
                     let annotations = Annotations::new(&cursor);
                     let custom_behavior = ctx
                         .options()
@@ -142,6 +145,7 @@ impl Enum {
                         comment,
                         val,
                         custom_behavior,
+                        radix,
                     ));
                 }
             }
@@ -254,6 +258,9 @@ pub(crate) struct EnumVariant {
 
     /// The custom behavior this variant may have, if any.
     custom_behavior: Option<EnumVariantCustomBehavior>,
+
+    /// The radix of the literal value of the variant.
+    radix: Option<LiteralRadix>,
 }
 
 /// A constant value assigned to an enumeration variant.
@@ -277,13 +284,15 @@ impl EnumVariant {
         comment: Option<String>,
         val: EnumVariantValue,
         custom_behavior: Option<EnumVariantCustomBehavior>,
+        radix: Option<LiteralRadix>,
     ) -> Self {
         EnumVariant {
             name,
             name_for_allowlisting,
             comment,
             val,
             custom_behavior,
+            radix,
         }
     }
 
@@ -302,6 +311,11 @@ impl EnumVariant {
         self.val
     }
 
+    /// Get this variant's radix.
+    pub(crate) fn radix(&self) -> Option<&LiteralRadix> {
+        self.radix.as_ref()
+    }
+
     /// Get this variant's documentation.
     pub(crate) fn comment(&self) -> Option<&str> {
         self.comment.as_deref()