Some fix with the prune feature

Author: Raytwo

cli/src/commands.rs

@@ -44,29 +44,52 @@ fn scan_layout(layout: &workspace::Layout, use_cargo_check_fallback: bool) -> Re
     let manifest = Manifest::load(&layout.bindings_root.join("features.json"))?;
 
     let listed = toml_writer::read_features(&layout.features_manifest).unwrap_or_default();
+
+    // Seed the enabled set from whatever Cargo.toml already lists.
     let mut enabled: BTreeSet<String> = BTreeSet::new();
     for f in &listed {
         enabled.extend(manifest.closure(f));
     }
 
-    let mut referenced_paths = BTreeSet::new();
+    // Finding references is a fixpoint, not one pass. The hand-written wrappers
+    // in the bindings (ext.rs) hide their references behind #[cfg(feature = "...")],
+    // so a wrapper's references only become visible once that wrapper's feature is
+    // on. Each pass turns on the features we found last pass, which can uncover
+    // more, so we loop until the enabled set stops growing. Without this a single
+    // `apply` only peels off the first layer and the build still reports the next
+    // layer as missing (you'd have to run apply again).
+    let bindings_src = layout.bindings_root.join("src");
+    let mut referenced_paths;
 
-    for root in &layout.scan_roots {
-        let found = scan::collect_paths(root, &manifest, &[], &[], &enabled)?;
-        referenced_paths.extend(found);
-    }
+    loop {
+        let mut found = BTreeSet::new();
 
-    let bindings_src = layout.bindings_root.join("src");
+        for root in &layout.scan_roots {
+            found.extend(scan::collect_paths(root, &manifest, &[], &[], &enabled)?);
+        }
+
+        if bindings_src.exists() {
+            found.extend(scan::collect_paths(
+                &bindings_src,
+                &manifest,
+                &["crate"],
+                &["generated"],
+                &enabled,
+            )?);
+        }
+
+        // Turn on whatever this pass referenced and see if that grew the set. If it
+        // didn't, this pass already saw everything reachable, so we're converged.
+        let before = enabled.len();
+        for f in scan::paths_to_features(&found, &manifest) {
+            enabled.extend(manifest.closure(&f));
+        }
 
-    if bindings_src.exists() {
-        let found = scan::collect_paths(
-            &bindings_src,
-            &manifest,
-            &["crate"],
-            &["generated"],
-            &enabled,
-        )?;
-        referenced_paths.extend(found);
+        referenced_paths = found;
+
+        if enabled.len() == before {
+            break;
+        }
     }
 
     if use_cargo_check_fallback {

cli/src/manifest.rs

@@ -15,6 +15,13 @@ pub struct Manifest {
     pub dependencies: BTreeMap<String, Vec<String>>,
     #[serde(skip)]
     pub ext_wrappers: BTreeMap<String, Vec<String>>,
+    /// Short re-export path -> canonical path. Types live at
+    /// `engage_il2cpp::<ns>::<module>::<Type>` but the generated `<ns>` module
+    /// re-exports them one level up (the `pub use <module>::{Type}` lines in
+    /// app.rs etc), so code usually imports the short `engage_il2cpp::<ns>::<Type>`.
+    /// This maps that short form back so the scanner recognizes it.
+    #[serde(skip)]
+    pub reexports: BTreeMap<String, String>,
 }
 
 const SCHEMA_VERSION: u32 = 1;
@@ -37,6 +44,8 @@ impl Manifest {
             m.ext_wrappers = load_ext_wrappers(bindings_root).unwrap_or_default();
         }
 
+        m.reexports = build_reexports(&m.paths);
+
         Ok(m)
     }
 
@@ -70,6 +79,41 @@ impl Manifest {
     }
 }
 
+/// Invert the namespace-root re-exports: for each canonical
+/// `engage_il2cpp::<ns>::<module>::<Type>`, the `<ns>` module re-exports it as
+/// `engage_il2cpp::<ns>::<Type>`, so drop the module segment (second to last) to
+/// get the short form code actually imports. A real `pub use` at one level can't
+/// name two types the same way, so if two canonicals ever collapse to the same
+/// short form we drop it rather than guess.
+fn build_reexports(paths: &BTreeMap<String, String>) -> BTreeMap<String, String> {
+    let mut grouped: BTreeMap<String, Vec<&String>> = BTreeMap::new();
+
+    for canonical in paths.keys() {
+        let segs: Vec<&str> = canonical.split("::").collect();
+
+        // Need at least crate::ns::module::Type for there to be a module to drop.
+        if segs.len() < 4 {
+            continue;
+        }
+
+        let mut short_segs = segs.clone();
+        short_segs.remove(segs.len() - 2);
+        let short = short_segs.join("::");
+
+        if short != *canonical {
+            grouped.entry(short).or_default().push(canonical);
+        }
+    }
+
+    grouped
+        .into_iter()
+        .filter_map(|(short, canonicals)| match canonicals.as_slice() {
+            [only] => Some((short, (*only).clone())),
+            _ => None,
+        })
+        .collect()
+}
+
 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()?;

cli/src/scan.rs

@@ -115,6 +115,14 @@ impl<'a> PathVisitor<'a> {
                 return;
             }
 
+            // Code usually imports the short re-export path (engage_il2cpp::app::Fade)
+            // rather than the canonical one (engage_il2cpp::app::fade::Fade). Record the
+            // canonical so it maps to a feature downstream.
+            if let Some(canonical) = self.manifest.reexports.get(&candidate) {
+                self.out.insert(canonical.clone());
+                return;
+            }
+
             if let Some(leaf) = segments.get(n - 1) {
                 if self.manifest.ext_wrappers.contains_key(leaf) {
                     self.out.insert(candidate);

vscode/package-lock.json

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