fix(core): address Rust expert review — mod blocks, nested generics

W1: Remove source_file anchoring from functions query so functions
    inside mod blocks are captured. Filter impl methods by checking
    parent chain (declaration_list > impl_item), not just declaration_list.

W3: Fix greedy generic stripping — use split('<')[0] instead of
    regex replace. Handles nested generics like Wrapper<Option<T>>.

2 new tests: functions inside mod blocks (pub + private), nested
generic type param stripping.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: prosdev

packages/core/src/scanner/__fixtures__/rust-complex.rs

@@ -60,3 +60,25 @@ pub fn read_server_host(s: &Server) -> String {
     let _host = s.host.clone();
     s.host.to_uppercase()
 }
+
+// Tests mod block support — functions inside mod blocks must be captured
+mod handlers {
+    pub fn handle_request(data: &str) -> String {
+        data.to_uppercase()
+    }
+
+    fn internal_helper() -> bool {
+        true
+    }
+}
+
+// Tests nested generic stripping
+pub struct Wrapper<T> {
+    inner: Option<T>,
+}
+
+impl<T: fmt::Display> Wrapper<Option<T>> {
+    pub fn unwrap_display(&self) -> String {
+        format!("{:?}", self.inner)
+    }
+}

packages/core/src/scanner/__tests__/rust.test.ts

@@ -379,6 +379,27 @@ describe('RustScanner', () => {
       expect(calleeNames.some((n) => n.includes('transform'))).toBe(true);
     });
 
+    it('should extract functions inside mod blocks', () => {
+      const handleReq = docs.find(
+        (d) => d.metadata.name === 'handle_request' && d.type === 'function'
+      );
+      expect(handleReq).toBeDefined();
+      expect(handleReq!.metadata.exported).toBe(true);
+
+      const helper = docs.find((d) => d.metadata.name === 'internal_helper');
+      expect(helper).toBeDefined();
+      expect(helper!.metadata.exported).toBe(false);
+    });
+
+    it('should strip nested generic type params from impl', () => {
+      // impl<T: Display> Wrapper<Option<T>> → Wrapper, not Wrapper<Option<T>> or Wrapper>
+      const method = docs.find((d) => d.metadata.name === 'Wrapper.unwrap_display');
+      expect(method).toBeDefined();
+      expect(method!.metadata.name).toBe('Wrapper.unwrap_display');
+      expect(method!.metadata.name).not.toContain('<');
+      expect(method!.metadata.name).not.toContain('>');
+    });
+
     it('should NOT include macros in callees', () => {
       // process_request calls format!() — should NOT be in callees
       const processReq = docs.find((d) => d.metadata.name === 'Server.process_request');

packages/core/src/scanner/rust-queries.ts

@@ -7,11 +7,12 @@
  */
 
 export const RUST_QUERIES = {
-  // Free functions (top-level, not inside impl blocks)
+  // All function_item nodes at any depth (including inside mod blocks).
+  // Methods inside impl blocks are filtered out in the scanner code
+  // by checking if the parent is a declaration_list (impl body).
   functions: `
-    (source_file
-      (function_item
-        name: (identifier) @name) @definition)
+    (function_item
+      name: (identifier) @name) @definition
   `,
 
   // Struct definitions

packages/core/src/scanner/rust.ts

@@ -170,6 +170,11 @@ export class RustScanner implements Scanner {
       const defCapture = match.captures.find((c) => c.name === 'definition');
       if (!nameCapture || !defCapture) continue;
 
+      // Skip functions inside impl blocks — those are captured by extractMethods.
+      // Functions inside mod blocks (mod_item > declaration_list) should be kept.
+      const parent = defCapture.node.parent;
+      if (parent?.type === 'declaration_list' && parent.parent?.type === 'impl_item') continue;
+
       const name = nameCapture.node.text;
       const node = defCapture.node;
       const startLine = node.startPosition.row + 1;
@@ -327,8 +332,8 @@ export class RustScanner implements Scanner {
       const defCapture = match.captures.find((c) => c.name === 'definition');
       if (!receiverCapture || !nameCapture || !defCapture) continue;
 
-      // Strip generic type params: Container<T> → Container
-      const receiverType = receiverCapture.node.text.replace(/<.*>/, '');
+      // Strip generic type params: Container<T> → Container, HashMap<String, Vec<u8>> → HashMap
+      const receiverType = receiverCapture.node.text.split('<')[0];
       const methodName = nameCapture.node.text;
       const qualifiedName = `${receiverType}.${methodName}`;
       const node = defCapture.node;