codegen: Support new-type-alias constants

Fixes #3287

Author: maurer

bindgen-integration/build.rs

@@ -251,6 +251,10 @@ fn setup_macro_test() {
         .blocklist_function("my_prefixed_function_to_remove")
         .constified_enum("my_prefixed_enum_to_be_constified")
         .opaque_type("my_prefixed_templated_foo<my_prefixed_baz>")
+        .new_type_alias("MyInt")
+        .new_type_alias("MyBool")
+        .new_type_alias("MyFloat")
+        .new_type_alias("MyChar")
         .new_type_alias("TestDeriveOnAlias")
         .depfile(out_rust_file_relative.display().to_string(), &out_dep_file)
         .generate()

bindgen-integration/cpp/Test.h

@@ -246,3 +246,16 @@ enum MyOrderedEnum {
 
 // Used to test custom derives on new-type alias. See `test_custom_derive`.
 typedef int TestDeriveOnAlias;
+
+// Used to test new-type alias constants. See `test_new_type_alias_const`.
+typedef int MyInt;
+const MyInt MY_INT = 5;
+
+typedef bool MyBool;
+const MyBool MY_BOOL = true;
+
+typedef float MyFloat;
+const MyFloat MY_FLOAT = 1.23f;
+
+typedef char MyChar;
+const MyChar MY_CHAR = 'a';

bindgen-integration/src/lib.rs

@@ -355,3 +355,11 @@ fn test_colon_define() {
     let gold: u32 = (1u32 << 16) | 2;
     assert_eq!(gold, bindings::TESTMACRO_COLON_VALUE);
 }
+
+#[test]
+fn test_new_type_alias_const() {
+    assert_eq!(bindings::MY_INT.0, 5);
+    assert_eq!(bindings::MY_BOOL.0, true);
+    assert_eq!(bindings::MY_FLOAT.0, 1.23f32);
+    assert_eq!(bindings::MY_CHAR.0, b'a' as i8);
+}

bindgen/codegen/mod.rs

@@ -680,14 +680,16 @@ impl CodeGenerator for Var {
         let var_ty = self.ty();
         let ty = var_ty.to_rust_ty_or_opaque(ctx, &());
 
+        let var_ty_item = ctx.resolve_item(var_ty);
+        let alias_style = var_ty_item.alias_style(ctx);
+        let is_new_type_alias = matches!(
+            alias_style,
+            AliasVariation::NewType | AliasVariation::NewTypeDeref
+        );
+
         if let Some(val) = self.val() {
-            match *val {
-                VarType::Bool(val) => {
-                    result.push(quote! {
-                        #(#attrs)*
-                        pub const #canonical_ident : #ty = #val ;
-                    });
-                }
+            let const_expr = match *val {
+                VarType::Bool(val) => Some(val.to_token_stream()),
                 VarType::Int(val) => {
                     let int_kind = var_ty
                         .into_resolver()
@@ -702,10 +704,7 @@ impl CodeGenerator for Var {
                     } else {
                         helpers::ast_ty::uint_expr(val as _)
                     };
-                    result.push(quote! {
-                        #(#attrs)*
-                        pub const #canonical_ident : #ty = #val ;
-                    });
+                    Some(val)
                 }
                 VarType::String(ref bytes) => {
                     let prefix = ctx.trait_prefix();
@@ -758,21 +757,20 @@ impl CodeGenerator for Var {
                             pub const #canonical_ident: &#(#lifetime )*#array_ty = #bytes ;
                         });
                     }
+                    None
                 }
-                VarType::Float(f) => {
-                    if let Ok(expr) = helpers::ast_ty::float_expr(f) {
-                        result.push(quote! {
-                            #(#attrs)*
-                            pub const #canonical_ident : #ty = #expr ;
-                        });
-                    }
-                }
-                VarType::Char(c) => {
-                    result.push(quote! {
-                        #(#attrs)*
-                        pub const #canonical_ident : #ty = #c ;
-                    });
+                VarType::Float(f) => helpers::ast_ty::float_expr(f).ok(),
+                VarType::Char(c) => Some(c.to_token_stream()),
+            };
+
+            if let Some(mut val) = const_expr {
+                if is_new_type_alias {
+                    val = quote! { #ty(#val) };
                 }
+                result.push(quote! {
+                    #(#attrs)*
+                    pub const #canonical_ident : #ty = #val ;
+                });
             }
         } else {
             let symbol: &str = self.link_name().unwrap_or_else(|| {
@@ -1005,15 +1003,7 @@ impl CodeGenerator for Type {
                     quote! {}
                 };
 
-                let alias_style = if ctx.options().type_alias.matches(&name) {
-                    AliasVariation::TypeAlias
-                } else if ctx.options().new_type_alias.matches(&name) {
-                    AliasVariation::NewType
-                } else if ctx.options().new_type_alias_deref.matches(&name) {
-                    AliasVariation::NewTypeDeref
-                } else {
-                    ctx.options().default_alias_style
-                };
+                let alias_style = item.alias_style(ctx);
 
                 // We prefer using `pub use` over `pub type` because of:
                 // https://github.com/rust-lang/rust/issues/26264

bindgen/ir/item.rs

@@ -1,6 +1,8 @@
 //! Bindgen's core intermediate representation type.
 
-use super::super::codegen::{EnumVariation, CONSTIFIED_ENUM_MODULE_REPR_NAME};
+use super::super::codegen::{
+    AliasVariation, EnumVariation, CONSTIFIED_ENUM_MODULE_REPR_NAME,
+};
 use super::analysis::{HasVtable, HasVtableResult, Sizedness, SizednessResult};
 use super::annotations::Annotations;
 use super::comp::{CompKind, MethodKind};
@@ -1103,6 +1105,20 @@ impl Item {
     pub(crate) fn must_use(&self, ctx: &BindgenContext) -> bool {
         self.annotations().must_use_type() || ctx.must_use_type_by_name(self)
     }
+
+    /// Get the alias style for this item.
+    pub(crate) fn alias_style(&self, ctx: &BindgenContext) -> AliasVariation {
+        let name = self.canonical_name(ctx);
+        if ctx.options().type_alias.matches(&name) {
+            AliasVariation::TypeAlias
+        } else if ctx.options().new_type_alias.matches(&name) {
+            AliasVariation::NewType
+        } else if ctx.options().new_type_alias_deref.matches(&name) {
+            AliasVariation::NewTypeDeref
+        } else {
+            ctx.options().default_alias_style
+        }
+    }
 }
 
 impl<T> IsOpaque for T