Add support for platform specific rules

Author: lucic71

cpp2rust/converter/translation_rule.cpp

@@ -130,6 +130,16 @@ TypeRule ParseTypeRuleJSON(const llvm::json::Object &obj) {
   return rule;
 }
 
+bool CfgMatchesHost(llvm::StringRef cfg) {
+#if defined(__linux__)
+  return cfg == "linux";
+#elif defined(__APPLE__)
+  return cfg == "macos";
+#else
+  return false;
+#endif
+}
+
 void LoadTgtFromIR(ExprRules &exprs, TypeRules &types,
                    const std::filesystem::path &json_path) {
   auto buf = llvm::MemoryBuffer::getFile(json_path.string());
@@ -153,6 +163,10 @@ void LoadTgtFromIR(ExprRules &exprs, TypeRules &types,
     if (!obj)
       continue;
 
+    if (auto cfg = obj->getString("cfg"); cfg && !CfgMatchesHost(*cfg)) {
+      continue;
+    }
+
     auto name = entry_name.str();
     if (name[0] == 'f') {
       exprs[std::move(name)] = ParseExprRuleJSON(*obj);

rule-preprocessor/Cargo.toml

@@ -9,3 +9,4 @@ rules = { path = "../rules" }
 ra_ap_syntax = "0.0.266"
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
+syn = "2"

rule-preprocessor/src/ir.rs

@@ -48,9 +48,10 @@ pub struct TypeInfo {
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct FnIr {
-    // Fields ordered alphabetically to match the old serde_json::Map output
     pub body: Vec<BodyFragment>,
     #[serde(skip_serializing_if = "Option::is_none")]
+    pub cfg: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub generics: Option<BTreeMap<String, Vec<String>>>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub multi_statement: Option<bool>,

rule-preprocessor/src/syntactic.rs

@@ -258,6 +258,31 @@ impl<'a> FnIrBuilder<'a> {
         Self { fn_item }
     }
 
+    fn cfg_target_os(&self) -> Option<String> {
+        use ast::HasAttrs;
+        for attr in self.fn_item.attrs() {
+            let meta_text = attr.meta()?.syntax().text().to_string();
+            let syn::Meta::List(list) = syn::parse_str(&meta_text).ok()? else {
+                continue;
+            };
+            if !list.path.is_ident("cfg") {
+                continue;
+            }
+            let mut found = None;
+            let _ = list.parse_nested_meta(|nested| {
+                if nested.path.is_ident("target_os") {
+                    let lit: syn::LitStr = nested.value()?.parse()?;
+                    found = Some(lit.value());
+                }
+                Ok(())
+            });
+            if found.is_some() {
+                return found;
+            }
+        }
+        None
+    }
+
     fn params(&self) -> Vec<ParamInfo> {
         let mut params = Vec::new();
         let Some(param_list) = self.fn_item.param_list() else {
@@ -499,6 +524,7 @@ impl<'a> FnIrBuilder<'a> {
             },
             multi_statement,
             body,
+            cfg: self.cfg_target_os(),
         };
         ir.validate(&format!("{}:{}", path.display(), fn_name));
         ir

rules/socket/ir_unsafe.json

@@ -35,6 +35,7 @@
         "text": "libc::SOCK_CLOEXEC"
       }
     ],
+    "cfg": "linux",
     "return_type": {
       "type": "i32"
     }
@@ -45,6 +46,7 @@
         "text": "libc::SOCK_NONBLOCK"
       }
     ],
+    "cfg": "linux",
     "return_type": {
       "type": "i32"
     }

rules/socket/src.cpp

@@ -13,10 +13,12 @@ int f3() {
   return SOCK_DGRAM;
 }
 
+#ifdef __linux__
 int f4() {
   return SOCK_CLOEXEC;
 }
 
 int f5() {
   return SOCK_NONBLOCK;
 }
+#endif

rules/socket/tgt_unsafe.rs

@@ -10,10 +10,12 @@ unsafe fn f3() -> i32 {
     libc::SOCK_DGRAM
 }
 
+#[cfg(target_os = "linux")]
 unsafe fn f4() -> i32 {
     libc::SOCK_CLOEXEC
 }
 
+#[cfg(target_os = "linux")]
 unsafe fn f5() -> i32 {
     libc::SOCK_NONBLOCK
 }

tests/unit/socket_type_constants.c

@@ -6,13 +6,15 @@ int main() {
   assert(SOCK_STREAM == 1);
   assert(SOCK_DGRAM == 2);
 
+#ifdef __linux__
   int x = SOCK_STREAM | SOCK_CLOEXEC;
   assert((x & SOCK_STREAM) == SOCK_STREAM);
   assert((x & SOCK_CLOEXEC) == SOCK_CLOEXEC);
 
   int y = SOCK_DGRAM | SOCK_NONBLOCK;
   assert((y & SOCK_DGRAM) == SOCK_DGRAM);
   assert((y & SOCK_NONBLOCK) == SOCK_NONBLOCK);
+#endif
 
   return 0;
 }