Add is_va_arg attribute in IR

Author: lucic71

rule-preprocessor/src/ir.rs

@@ -123,10 +123,21 @@ pub struct TypeIr {
 #[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(untagged)]
 pub enum BodyFragment {
-    Text { text: String },
-    Placeholder { placeholder: PlaceholderInner },
-    Generic { generic: i32 },
-    MethodCall { method_call: MethodCallInner },
+    Text {
+        text: String,
+    },
+    Placeholder {
+        placeholder: PlaceholderInner,
+    },
+    Generic {
+        generic: i32,
+    },
+    MethodCall {
+        method_call: MethodCallInner,
+    },
+    VaArgs {
+        va_args: std::marker::PhantomData<()>,
+    },
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]

rule-preprocessor/src/syntactic.rs

@@ -40,6 +40,20 @@ fn pointer_flags(ty: &ast::Type) -> (bool, bool) {
     flags
 }
 
+fn is_va_args_type(ty: &ast::Type) -> bool {
+    if let ast::Type::RefType(r) = ty
+        && let Some(ast::Type::SliceType(slice)) = r.ty()
+    {
+        return matches!(slice.ty(), Some(ast::Type::PathType(path))
+                if path
+                    .path()
+                    .and_then(|p| p.segment())
+                    .and_then(|s| s.name_ref())
+                    .is_some_and(|name| name.text() == "VaArg"));
+    }
+    false
+}
+
 fn cfg_matches_host(fn_item: &ast::Fn) -> bool {
     for attr in fn_item.attrs() {
         let Some(meta) = attr.meta() else { continue };
@@ -205,6 +219,13 @@ impl<'a> FragmentCtx<'a> {
         }
         if token.kind() == SyntaxKind::IDENT {
             if let Some(param) = self.params.iter().find(|p| p.name == token.text()) {
+                if param.is_va_args {
+                    self.flush_text();
+                    self.fragments.push(BodyFragment::VaArgs {
+                        va_args: std::marker::PhantomData,
+                    });
+                    return;
+                }
                 let mut access = self.builder.classify_access(token);
                 if param.is_mut_ref && self.text_buf.ends_with('*') {
                     self.text_buf.pop();
@@ -272,6 +293,7 @@ struct ParamInfo {
     is_refcount_pointer: bool,
     is_unsafe_pointer: bool,
     is_mut_ref: bool,
+    is_va_args: bool,
 }
 
 struct FnIrBuilder<'a> {
@@ -297,15 +319,22 @@ impl<'a> FnIrBuilder<'a> {
             };
 
             let (is_refcount_pointer, is_unsafe_pointer) = pointer_flags(&ty);
+            let name = ident
+                .name()
+                .map(|n| n.text().to_string())
+                .unwrap_or_default();
+            let is_va_args = is_va_args_type(&ty);
+            assert!(
+                !is_va_args || name == "va",
+                "variadic argument parameter must be named `va`, found `{name}`"
+            );
             params.push(ParamInfo {
-                name: ident
-                    .name()
-                    .map(|n| n.text().to_string())
-                    .unwrap_or_default(),
+                name,
                 ty: ty.syntax().text().to_string(),
                 is_refcount_pointer,
                 is_unsafe_pointer,
                 is_mut_ref: matches!(&ty, ast::Type::RefType(r) if r.mut_token().is_some()),
+                is_va_args,
             });
         }
         params
@@ -482,6 +511,7 @@ impl<'a> FnIrBuilder<'a> {
 
         let params_map: BTreeMap<String, TypeInfo> = params
             .iter()
+            .filter(|p| !p.is_va_args)
             .map(|p| {
                 (
                     p.name.clone(),