Replace manual cfg parsing with cfg-expr crate

Author: lucic71

rule-preprocessor/Cargo.toml

@@ -4,6 +4,7 @@ version = "0.1.0"
 edition = "2024"
 
 [dependencies]
+cfg-expr = "0.17"
 libcc2rs = { path = "../libcc2rs" }
 rules = { path = "../rules" }
 ra_ap_syntax = "0.0.266"

rule-preprocessor/src/syntactic.rs

@@ -103,10 +103,11 @@ impl SyntacticAnalysis {
                     file_ir.insert(name, RuleIr::Type(ir));
                 }
             } else if fn_name.starts_with('f') {
-                file_ir.insert(
-                    fn_name.clone(),
-                    RuleIr::Fn(FnIrBuilder::new(&fn_item).build(path)),
-                );
+                let builder = FnIrBuilder::new(&fn_item);
+                if !builder.matches_host_arch() {
+                    continue;
+                }
+                file_ir.insert(fn_name.clone(), RuleIr::Fn(builder.build(path)));
             }
         }
 
@@ -253,29 +254,37 @@ impl<'a> FnIrBuilder<'a> {
         Self { fn_item }
     }
 
-    fn get_target_os(&self) -> Option<String> {
+    fn get_cfg(&self) -> Option<cfg_expr::Expression> {
         use ast::HasAttrs;
-        for attr in self.fn_item.attrs() {
+        self.fn_item.attrs().find_map(|attr| {
             let meta_text = attr.meta()?.syntax().text().to_string();
-            let syn::Meta::List(list) = syn::parse_str(&meta_text).ok()? else {
-                continue;
+            let syn::Meta::List(list) = syn::parse_str::<syn::Meta>(&meta_text).ok()? else {
+                return None;
             };
             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;
+                return None;
             }
-        }
-        None
+            cfg_expr::Expression::parse(&list.tokens.to_string()).ok()
+        })
+    }
+
+    fn matches_host_arch(&self) -> bool {
+        use cfg_expr::expr::{Predicate, TargetPredicate};
+        let Some(expr) = self.get_cfg() else {
+            return true;
+        };
+        expr.eval(|pred| match pred {
+            Predicate::Target(TargetPredicate::Arch(a)) => a.as_str() == std::env::consts::ARCH,
+            _ => true,
+        })
+    }
+
+    fn get_target_os(&self) -> Option<String> {
+        use cfg_expr::expr::{Predicate, TargetPredicate};
+        self.get_cfg()?.predicates().find_map(|p| match p {
+            Predicate::Target(TargetPredicate::Os(o)) => Some(o.as_str().to_string()),
+            _ => None,
+        })
     }
 
     fn params(&self) -> Vec<ParamInfo> {