transpile: save override_tys in fn convert_expr in a map and use them for const macros

Author: kkysen

c2rust-transpile/src/translator/mod.rs

@@ -7,7 +7,6 @@ use std::path::{self, PathBuf};
 use std::result::Result; // To override syn::Result from glob import
 
 use dtoa;
-
 use failure::{err_msg, format_err, Fail};
 use indexmap::indexmap;
 use indexmap::{IndexMap, IndexSet};
@@ -258,6 +257,15 @@ pub struct Translation<'c> {
     potential_flexible_array_members: RefCell<IndexSet<CDeclId>>,
     macro_expansions: RefCell<IndexMap<CDeclId, Option<MacroExpansion>>>,
 
+    /// For every call to [`Self::convert_expr`],
+    /// we record the `override_ty` that is used for that expression.
+    ///
+    /// This is needed [`Self::recreate_const_macro_from_expansions`]
+    /// when we call [`Self::convert_expr`] for each of the macro expansions,
+    /// as unlike normal [`Self::convert_expr`]s, there is no surrounding context
+    /// higher in the call stack calculating the `override_ty`.
+    expr_override_tys: RefCell<HashMap<CExprId, CQualTypeId>>,
+
     // Comment support
     pub comment_context: CommentContext,      // Incoming comments
     pub comment_store: RefCell<CommentStore>, // Outgoing comments
@@ -1209,6 +1217,7 @@ impl<'c> Translation<'c> {
             function_context: RefCell::new(FuncContext::new()),
             potential_flexible_array_members: RefCell::new(IndexSet::new()),
             macro_expansions: RefCell::new(IndexMap::new()),
+            expr_override_tys: Default::default(),
             comment_context,
             comment_store: RefCell::new(CommentStore::new()),
             spans: HashMap::new(),
@@ -2195,7 +2204,11 @@ impl<'c> Translation<'c> {
                     .ast_context
                     .resolve_expr_type_id(id)
                     .unwrap_or((id, ty));
-                let expr = self.convert_expr(ctx, expr_id, None)?;
+
+                let override_ty = self.expr_override_tys.borrow().get(&expr_id).copied();
+                let expr = self.convert_expr(ctx, expr_id, override_ty)?;
+
+                let ty = override_ty.map(|ty| ty.ctype).unwrap_or(ty);
 
                 // Join ty and cur_ty to the smaller of the two types. If the
                 // types are not cast-compatible, abort the fold.
@@ -3247,6 +3260,12 @@ impl<'c> Translation<'c> {
         expr_id: CExprId,
         override_ty: Option<CQualTypeId>,
     ) -> TranslationResult<WithStmts<Box<Expr>>> {
+        if let Some(override_ty) = override_ty {
+            self.expr_override_tys
+                .borrow_mut()
+                .insert(expr_id, override_ty);
+        }
+
         let Located {
             loc: src_loc,
             kind: expr_kind,

c2rust-transpile/tests/snapshots/[email protected]

@@ -30,7 +30,7 @@ pub struct fn_ptrs {
     pub fn2: Option<unsafe extern "C" fn(std::ffi::c_int) -> std::ffi::c_int>,
 }
 pub type zstd_platform_dependent_type = std::ffi::c_long;
-pub const UINTPTR_MAX: std::ffi::c_ulong = unsafe { 18446744073709551615 as std::ffi::c_ulong };
+pub const UINTPTR_MAX: uintptr_t = unsafe { 18446744073709551615 as uintptr_t };
 pub const true_0: std::ffi::c_int = unsafe { 1 as std::ffi::c_int };
 pub const LITERAL_INT: std::ffi::c_int = unsafe { 0xffff as std::ffi::c_int };
 pub const LITERAL_BOOL: std::ffi::c_int = unsafe { true_0 };
@@ -416,7 +416,7 @@ pub unsafe extern "C" fn use_local_value() -> std::ffi::c_int {
 }
 #[no_mangle]
 pub unsafe extern "C" fn use_portable_type(mut len: uintptr_t) -> bool {
-    return len <= (UINTPTR_MAX as uintptr_t).wrapping_div(2 as uintptr_t);
+    return len <= UINTPTR_MAX.wrapping_div(2 as uintptr_t);
 }
 unsafe extern "C" fn run_static_initializers() {
     global_static_const_ptr_arithmetic = PTR_ARITHMETIC;