Centralize logic for use statement stuff

Author: Raytwo

cli/src/imports.rs

@@ -199,14 +199,14 @@ fn classify_use(tree: &UseTree, manifest: &Manifest) -> UseShape {
                 let mut full = prefix.clone();
                 full.push(name.clone());
                 let path = full.join("::");
-                let Some(feature) = manifest.paths.get(&path) else {
+                let Some((full_path, feature)) = manifest.resolve_path(&path) else {
                     return UseShape::Other;
                 };
                 return UseShape::Single {
                     leaf: EngageLeaf {
-                        full_path: path,
+                        full_path: full_path.to_string(),
                         local_name: name,
-                        feature: feature.clone(),
+                        feature: feature.to_string(),
                     },
                 };
             }
@@ -216,14 +216,14 @@ fn classify_use(tree: &UseTree, manifest: &Manifest) -> UseShape {
                 let mut full = prefix.clone();
                 full.push(name.clone());
                 let path = full.join("::");
-                let Some(feature) = manifest.paths.get(&path) else {
+                let Some((full_path, feature)) = manifest.resolve_path(&path) else {
                     return UseShape::Other;
                 };
                 return UseShape::Single {
                     leaf: EngageLeaf {
-                        full_path: path,
+                        full_path: full_path.to_string(),
                         local_name: local,
-                        feature: feature.clone(),
+                        feature: feature.to_string(),
                     },
                 };
             }
@@ -236,12 +236,12 @@ fn classify_use(tree: &UseTree, manifest: &Manifest) -> UseShape {
                             let mut full = prefix.clone();
                             full.push(name.clone());
                             let path = full.join("::");
-                            let kind = if let Some(feature) = manifest.paths.get(&path) {
+                            let kind = if let Some((full_path, feature)) = manifest.resolve_path(&path) {
                                 MemberKind::Engage {
                                     leaf: EngageLeaf {
-                                        full_path: path,
+                                        full_path: full_path.to_string(),
                                         local_name: name.clone(),
-                                        feature: feature.clone(),
+                                        feature: feature.to_string(),
                                     },
                                 }
                             } else {
@@ -258,12 +258,12 @@ fn classify_use(tree: &UseTree, manifest: &Manifest) -> UseShape {
                             let mut full = prefix.clone();
                             full.push(name.clone());
                             let path = full.join("::");
-                            let kind = if let Some(feature) = manifest.paths.get(&path) {
+                            let kind = if let Some((full_path, feature)) = manifest.resolve_path(&path) {
                                 MemberKind::Engage {
                                     leaf: EngageLeaf {
-                                        full_path: path,
+                                        full_path: full_path.to_string(),
                                         local_name: local.clone(),
-                                        feature: feature.clone(),
+                                        feature: feature.to_string(),
                                     },
                                 }
                             } else {
@@ -336,6 +336,27 @@ impl<'ast> Visit<'ast> for BodyRefVisitor {
     fn visit_ident(&mut self, ident: &'ast proc_macro2::Ident) {
         self.out.insert(strip_raw(&ident.to_string()));
     }
+
+    // syn keeps a macro's contents as raw tokens and never parses them, so a type
+    // used only inside something like `vec![Fade::black_out(...)]` is invisible to
+    // the normal walk. Pull every identifier out of the macro tokens so we don't
+    // call a still-used import dead and delete it.
+    fn visit_macro(&mut self, mac: &'ast syn::Macro) {
+        collect_idents_from_tokens(mac.tokens.clone(), &mut self.out);
+        syn::visit::visit_macro(self, mac);
+    }
+}
+
+fn collect_idents_from_tokens(tokens: proc_macro2::TokenStream, out: &mut BTreeSet<String>) {
+    for tt in tokens {
+        match tt {
+            proc_macro2::TokenTree::Ident(id) => {
+                out.insert(strip_raw(&id.to_string()));
+            }
+            proc_macro2::TokenTree::Group(g) => collect_idents_from_tokens(g.stream(), out),
+            _ => {}
+        }
+    }
 }
 
 pub fn apply_use_edits(file: &Path, edits: &[UseEdit]) -> Result<()> {

cli/src/manifest.rs

@@ -57,6 +57,23 @@ impl Manifest {
         self.paths.iter().filter(|(path, _)| path.split("::").last() == Some(leaf)).collect()
     }
 
+    /// Resolve a path as written in code to its (canonical path, gating feature).
+    /// Accepts the canonical path itself (engage_il2cpp::app::fade::Fade) or the
+    /// short re-export form code usually writes (engage_il2cpp::app::Fade), and
+    /// always hands back the canonical one so callers agree on a single key.
+    /// Returns None if the path names no known engage type. This is the one place
+    /// that knows about re-exports, so both the scanner and the prune import check
+    /// go through it instead of each reimplementing the lookup.
+    pub fn resolve_path(&self, path: &str) -> Option<(&str, &str)> {
+        if let Some((canonical, feature)) = self.paths.get_key_value(path) {
+            return Some((canonical.as_str(), feature.as_str()));
+        }
+
+        let canonical = self.reexports.get(path)?;
+        let feature = self.paths.get(canonical)?;
+        Some((canonical.as_str(), feature.as_str()))
+    }
+
     pub fn closure(&self, feature: &str) -> BTreeSet<String> {
         let mut out = BTreeSet::new();
         let mut stack = vec![feature.to_string()];

cli/src/scan.rs

@@ -110,16 +110,12 @@ impl<'a> PathVisitor<'a> {
         for n in (2..=segments.len()).rev() {
             let candidate: String = segments[..n].join("::");
 
-            if self.manifest.paths.contains_key(&candidate) {
-                self.out.insert(candidate);
-                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());
+            // Matches either the canonical path or the short re-export form code
+            // usually writes (engage_il2cpp::app::Fade). Record the canonical so it
+            // maps to a feature downstream.
+            if let Some((canonical, _)) = self.manifest.resolve_path(&candidate) {
+                let canonical = canonical.to_string();
+                self.out.insert(canonical);
                 return;
             }