transpile: Add MacroInvocationInfo

Author: Rua

c2rust-transpile/src/c_ast/conversion.rs

@@ -543,12 +543,14 @@ impl ConversionContext {
 
         // Invert the macro invocations to get a list of macro expansion expressions
         for (expr_id, macro_ids) in &self.typed_context.macro_invocations {
-            for mac_id in macro_ids {
-                self.typed_context
-                    .macro_expansions
-                    .entry(*mac_id)
-                    .or_default()
-                    .push(*expr_id);
+            for info in macro_ids {
+                if info.parameter.is_none() {
+                    self.typed_context
+                        .macro_expansions
+                        .entry(info.macro_id)
+                        .or_default()
+                        .push(*expr_id);
+                }
             }
         }
 
@@ -1025,12 +1027,15 @@ impl ConversionContext {
 
             if expected_ty & EXPR != 0 {
                 for info in &node.macro_invocations {
-                    let mac = CDeclId(self.visit_node_type(info.macro_id, MACRO_DECL));
+                    let info = MacroInvocationInfo {
+                        macro_id: CDeclId(self.visit_node_type(info.macro_id, MACRO_DECL)),
+                        parameter: info.parameter.clone(),
+                    };
                     self.typed_context
                         .macro_invocations
                         .entry(CExprId(new_id))
                         .or_default()
-                        .push(mac);
+                        .push(info);
                 }
             }
 

c2rust-transpile/src/c_ast/mod.rs

@@ -103,7 +103,7 @@ pub struct TypedAstContext {
     pub label_names: IndexMap<CLabelId, Rc<str>>,
 
     /// map expressions to the stack of macros they were expanded from
-    pub macro_invocations: IndexMap<CExprId, Vec<CDeclId>>,
+    pub macro_invocations: IndexMap<CExprId, Vec<MacroInvocationInfo>>,
 
     /// map macro decls to the expressions they expand to
     pub macro_expansions: IndexMap<CDeclId, Vec<CExprId>>,
@@ -122,6 +122,12 @@ pub struct TypedAstContext {
     pub target: String,
 }
 
+#[derive(Debug, Clone)]
+pub struct MacroInvocationInfo {
+    pub macro_id: CDeclId,
+    pub parameter: Option<String>,
+}
+
 /// Comments associated with a typed AST context
 #[derive(Debug, Clone)]
 pub struct CommentContext {
@@ -1176,9 +1182,9 @@ impl TypedAstContext {
                     Expr(expr_id) => {
                         let expr = self.index(expr_id);
                         if let Some(macs) = self.macro_invocations.get(&expr_id) {
-                            for mac_id in macs {
-                                if wanted.insert(*mac_id) {
-                                    to_walk.push(*mac_id);
+                            for info in macs {
+                                if wanted.insert(info.macro_id) {
+                                    to_walk.push(info.macro_id);
                                 }
                             }
                         }

c2rust-transpile/src/translator/macros.rs

@@ -157,18 +157,22 @@ impl<'c> Translation<'c> {
 
         // Find the first macro after the macro we're currently expanding, if any.
         let first_macro = macros
-            .splitn(2, |macro_id| ctx.expanding_macro(macro_id))
+            .splitn(2, |info| {
+                info.parameter.is_none() && ctx.expanding_macro(&info.macro_id)
+            })
             .last()
             .unwrap()
-            .first();
+            .iter()
+            .filter(|info| info.parameter.is_none())
+            .next();
         let macro_id = match first_macro {
-            Some(macro_id) => macro_id,
+            Some(info) => info.macro_id,
             None => return Ok(None),
         };
 
         trace!("  found macro expansion: {macro_id:?}");
         // Ensure that we've converted this macro and that it has a valid definition.
-        let expansion = self.macro_expansions.borrow().get(macro_id).cloned();
+        let expansion = self.macro_expansions.borrow().get(&macro_id).cloned();
         let macro_ty = match expansion {
             // Expansion exists.
             Some(Some(expansion)) => expansion.ty,
@@ -178,8 +182,8 @@ impl<'c> Translation<'c> {
 
             // We haven't tried to expand it yet.
             None => {
-                self.convert_decl(ctx, *macro_id)?;
-                if let Some(Some(expansion)) = self.macro_expansions.borrow().get(macro_id) {
+                self.convert_decl(ctx, macro_id)?;
+                if let Some(Some(expansion)) = self.macro_expansions.borrow().get(&macro_id) {
                     expansion.ty
                 } else {
                     return Ok(None);
@@ -189,10 +193,10 @@ impl<'c> Translation<'c> {
         let rust_name = self
             .renamer
             .borrow_mut()
-            .get(macro_id)
+            .get(&macro_id)
             .ok_or_else(|| format_err!("Macro name not declared"))?;
 
-        self.add_import(*macro_id, &rust_name);
+        self.add_import(macro_id, &rust_name);
 
         let val = WithStmts::new_val(mk().path_expr(vec![rust_name]));