Don't prune features used by ext.rs

Author: Raytwo

cli/src/manifest.rs

@@ -13,14 +13,16 @@ pub struct Manifest {
     pub version: String,
     pub paths: BTreeMap<String, String>,
     pub dependencies: BTreeMap<String, Vec<String>>,
+    #[serde(skip)]
+    pub ext_wrappers: BTreeMap<String, Vec<String>>,
 }
 
 const SCHEMA_VERSION: u32 = 1;
 
 impl Manifest {
     pub fn load(path: &Path) -> Result<Self> {
         let raw = std::fs::read_to_string(path).with_context(|| format!("reading manifest at {}", path.display()))?;
-        let m: Manifest = serde_json::from_str(&raw).with_context(|| format!("parsing manifest at {}", path.display()))?;
+        let mut m: Manifest = serde_json::from_str(&raw).with_context(|| format!("parsing manifest at {}", path.display()))?;
 
         if m.schema_version != SCHEMA_VERSION {
             return Err(anyhow!(
@@ -31,6 +33,10 @@ impl Manifest {
             ));
         }
 
+        if let Some(bindings_root) = path.parent() {
+            m.ext_wrappers = load_ext_wrappers(bindings_root).unwrap_or_default();
+        }
+
         Ok(m)
     }
 
@@ -63,3 +69,81 @@ impl Manifest {
         out
     }
 }
+
+fn load_ext_wrappers(bindings_root: &Path) -> Option<BTreeMap<String, Vec<String>>> {
+    let ext_path = bindings_root.join("src").join("ext.rs");
+    let text = std::fs::read_to_string(&ext_path).ok()?;
+    let file = syn::parse_file(&text).ok()?;
+
+    let mut out: BTreeMap<String, Vec<String>> = BTreeMap::new();
+
+    for item in &file.items {
+        let syn::Item::Mod(m) = item else { continue };
+        let features = extract_cfg_features(&m.attrs);
+        if features.is_empty() {
+            continue;
+        }
+
+        let Some((_, inner_items)) = m.content.as_ref() else { continue };
+
+        for inner in inner_items {
+            let (name, is_pub) = match inner {
+                syn::Item::Struct(s) => (s.ident.to_string(), is_public(&s.vis)),
+                syn::Item::Trait(t) => (t.ident.to_string(), is_public(&t.vis)),
+                syn::Item::Fn(f) => (f.sig.ident.to_string(), is_public(&f.vis)),
+                _ => continue,
+            };
+
+            if !is_pub {
+                continue;
+            }
+
+            out.insert(name, features.clone());
+        }
+    }
+
+    Some(out)
+}
+
+fn is_public(vis: &syn::Visibility) -> bool {
+    matches!(vis, syn::Visibility::Public(_))
+}
+
+fn extract_cfg_features(attrs: &[syn::Attribute]) -> Vec<String> {
+    for attr in attrs {
+        if !attr.path().is_ident("cfg") {
+            continue;
+        }
+        if let Ok(meta) = attr.parse_args::<syn::Meta>() {
+            return collect_features(&meta);
+        }
+    }
+    Vec::new()
+}
+
+fn collect_features(meta: &syn::Meta) -> Vec<String> {
+    match meta {
+        syn::Meta::NameValue(nv) if nv.path.is_ident("feature") => {
+            if let syn::Expr::Lit(syn::ExprLit {
+                lit: syn::Lit::Str(s),
+                ..
+            }) = &nv.value
+            {
+                vec![s.value()]
+            } else {
+                Vec::new()
+            }
+        }
+        syn::Meta::List(list) if list.path.is_ident("all") => {
+            let parsed: syn::punctuated::Punctuated<syn::Meta, syn::Token![,]> = list
+                .parse_args_with(syn::punctuated::Punctuated::parse_terminated)
+                .unwrap_or_default();
+            let mut out = Vec::new();
+            for inner in parsed {
+                out.extend(collect_features(&inner));
+            }
+            out
+        }
+        _ => Vec::new(),
+    }
+}

cli/src/scan.rs

@@ -46,7 +46,20 @@ pub fn collect_paths(
 }
 
 pub fn paths_to_features(paths: &BTreeSet<String>, manifest: &Manifest) -> BTreeSet<String> {
-    paths.iter().filter_map(|p| manifest.paths.get(p)).cloned().collect()
+    let mut out: BTreeSet<String> = paths
+        .iter()
+        .filter_map(|p| manifest.paths.get(p))
+        .cloned()
+        .collect();
+
+    for p in paths {
+        let leaf = p.rsplit("::").next().unwrap_or(p);
+        if let Some(feats) = manifest.ext_wrappers.get(leaf) {
+            out.extend(feats.iter().cloned());
+        }
+    }
+
+    out
 }
 
 struct PathVisitor<'a> {
@@ -102,6 +115,13 @@ impl<'a> PathVisitor<'a> {
                 return;
             }
 
+            if let Some(leaf) = segments.get(n - 1) {
+                if self.manifest.ext_wrappers.contains_key(leaf) {
+                    self.out.insert(candidate);
+                    return;
+                }
+            }
+
             for rewritten in rewrite_synthetic_trait(&segments[..n]) {
                 if self.manifest.paths.contains_key(&rewritten) {
                     self.out.insert(rewritten);

vscode/package.json

@@ -2,7 +2,7 @@
   "name": "engage-vscode",
   "displayName": "engage",
   "description": "Manage engage-il2cpp Cargo features from VS Code",
-  "version": "0.2.1",
+  "version": "0.2.2",
   "publisher": "DivineDragonFanClub",
   "repository": {
     "type": "git",