fix(query,extract,merge): improve cross-project analysis accuracy

Four fixes addressing gaps in cross-project analysis:

1. Type queries now include member edges. `symbol context`/`impact` on a
   type (Struct/Class/Enum/Protocol/Trait) now count edges targeting its
   direct members as callers/read_by/implementors of the type itself, with
   dedup. Previously `impact FeedList` returned 0 because edges target
   `FeedList::init`/`::content`, not the parent struct.

2. Generic constructor calls now emit edges. `Mutex<Bool>(false)` parses
   as `GenericSpecializationExprSyntax` in SwiftSyntax and
   `constructor_expression` in tree-sitter-swift — neither was handled.
   SwiftSyntax now unwraps the specialization; tree-sitter extracts the
   type name from `user_type > type_identifier`.

3. Swift test targets get proper module names. `Tests/FrameBaseTests/`
   now registers as module `FrameBaseTests` (was landing in unnamed `/`).
   Falls back to `<Package>Tests` when `Tests/` has no subdirectories.

4. Candidate cap prevents edge explosion for common names. When a name
   resolves to candidates in >3 distinct files, drop the edge rather
   than emit N false-positive duplicates (e.g., `horizontal`, `top`).
   Counting unique files — not raw candidates — preserves legitimate
   edges to types with multiple extensions in the same file.

Verified on lama-ludo-ios + FrameUI/FrameBase externals: edges reduced
453k → 267k (41% noise drop), test files now attributed correctly,
cross-module `impact Mutex` returns 23 dependents across FrameUI and
FrameBaseTests (was 0).

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

Author: ahavili

grapha-core/src/merge.rs

@@ -6,6 +6,7 @@ use crate::graph::{EdgeKind, Graph, NodeKind};
 struct NameEntry {
     id: String,
     module: Option<String>,
+    file: String,
 }
 
 struct ResolveContext<'a> {
@@ -105,6 +106,7 @@ pub fn merge(results: Vec<ExtractionResult>) -> Graph {
             .push(NameEntry {
                 id: node.id.clone(),
                 module: node.module.clone(),
+                file: node.file.to_string_lossy().to_string(),
             });
     }
 
@@ -449,6 +451,18 @@ fn resolve_candidates(
             }
         }
 
+        // Cap ambiguous resolution: if too many distinct files contain
+        // candidates after disambiguation, drop the edge entirely. A missing
+        // edge is better than N false positives (e.g., "horizontal", "top").
+        // Count unique files, not raw candidates, so a type with extensions
+        // in the same file isn't penalized.
+        let unique_files: HashSet<&str> = same_module
+            .iter()
+            .map(|c| c.file.as_str())
+            .collect();
+        if unique_files.len() > 3 {
+            return Vec::new();
+        }
         return same_module
             .iter()
             .map(|candidate| (candidate.id.clone(), 0.4))
@@ -469,6 +483,13 @@ fn resolve_candidates(
             return vec![(imported[0].id.clone(), 0.8)];
         }
         if imported.len() > 1 {
+            let unique_files: HashSet<&str> = imported
+                .iter()
+                .map(|c| c.file.as_str())
+                .collect();
+            if unique_files.len() > 3 {
+                return Vec::new();
+            }
             return imported
                 .iter()
                 .map(|candidate| (candidate.id.clone(), 0.3))

grapha-swift/src/module_discovery.rs

@@ -27,6 +27,42 @@ fn discover_swift_packages_recursive(dir: &Path, modules: &mut ModuleMap) {
             .entry(module_name)
             .or_default()
             .push(source_dir);
+
+        // Register test targets: each subdirectory under Tests/ becomes a module.
+        // If Tests/ has no subdirectories, register it as "<PackageName>Tests".
+        let tests_dir = dir.join("Tests");
+        if tests_dir.is_dir() {
+            let mut found_subdirs = false;
+            if let Ok(entries) = std::fs::read_dir(&tests_dir) {
+                for entry in entries.flatten() {
+                    let path = entry.path();
+                    if path.is_dir() {
+                        let name = entry.file_name();
+                        let name = name.to_string_lossy();
+                        if !name.starts_with('.') {
+                            modules
+                                .modules
+                                .entry(name.to_string())
+                                .or_default()
+                                .push(path);
+                            found_subdirs = true;
+                        }
+                    }
+                }
+            }
+            if !found_subdirs {
+                let pkg_name = dir
+                    .file_name()
+                    .and_then(|n| n.to_str())
+                    .unwrap_or("unknown");
+                modules
+                    .modules
+                    .entry(format!("{pkg_name}Tests"))
+                    .or_default()
+                    .push(tests_dir);
+            }
+        }
+
         return;
     }
 
@@ -70,4 +106,42 @@ mod tests {
         let modules = discover_swift_modules(dir.path());
         assert!(modules.modules.contains_key("MyPackage"));
     }
+
+    #[test]
+    fn discovers_test_targets_as_modules() {
+        let dir = tempfile::tempdir().unwrap();
+        let pkg_dir = dir.path().join("FrameBase");
+        let sources_dir = pkg_dir.join("Sources");
+        let tests_dir = pkg_dir.join("Tests").join("FrameBaseTests");
+        fs::create_dir_all(&sources_dir).unwrap();
+        fs::create_dir_all(&tests_dir).unwrap();
+        fs::write(pkg_dir.join("Package.swift"), "// swift-tools-version:5.5").unwrap();
+
+        let modules = discover_swift_modules(dir.path());
+        assert!(modules.modules.contains_key("FrameBase"));
+        assert!(
+            modules.modules.contains_key("FrameBaseTests"),
+            "test subdirectory should be registered as a module"
+        );
+    }
+
+    #[test]
+    fn discovers_test_fallback_when_no_subdirs() {
+        let dir = tempfile::tempdir().unwrap();
+        let pkg_dir = dir.path().join("MyPkg");
+        let sources_dir = pkg_dir.join("Sources");
+        let tests_dir = pkg_dir.join("Tests");
+        fs::create_dir_all(&sources_dir).unwrap();
+        fs::create_dir_all(&tests_dir).unwrap();
+        // Put a file directly in Tests/ with no subdirs
+        fs::write(tests_dir.join("MyPkgTests.swift"), "import XCTest").unwrap();
+        fs::write(pkg_dir.join("Package.swift"), "// swift-tools-version:5.5").unwrap();
+
+        let modules = discover_swift_modules(dir.path());
+        assert!(modules.modules.contains_key("MyPkg"));
+        assert!(
+            modules.modules.contains_key("MyPkgTests"),
+            "Tests/ with no subdirs should fallback to <Package>Tests"
+        );
+    }
 }

grapha-swift/src/treesitter/extract.rs

@@ -1199,6 +1199,32 @@ fn extract_calls(
         });
     }
 
+    // Generic constructor calls: `Type<Generic>(args)` produces a
+    // `constructor_expression` node with the type name in `user_type > type_identifier`.
+    if node.kind() == "constructor_expression" {
+        let mut ctor_cursor = node.walk();
+        let type_name = node
+            .named_children(&mut ctor_cursor)
+            .find(|c| c.kind() == "user_type")
+            .and_then(|ut| type_identifier_text(ut, source));
+        if let Some(name) = type_name {
+            let target_id = make_id(file, module_path, &name);
+            let condition = find_enclosing_swift_condition(node, source);
+            let async_boundary = detect_swift_async_boundary(node, source);
+            result.edges.push(Edge {
+                source: caller_id.to_string(),
+                target: target_id,
+                kind: EdgeKind::Calls,
+                confidence: 0.8,
+                direction: None,
+                operation: None,
+                condition,
+                async_boundary,
+                provenance: node_edge_provenance(file, node, caller_id),
+            });
+        }
+    }
+
     // Property access: `foo.bar` generates a navigation_expression.
     // Emit a Reads edge so dependency queries can trace through the access
     // without polluting call lists with field-like symbols.

grapha-swift/swift-bridge/Sources/GraphaSwiftBridge/SwiftSyntaxExtractor.swift

@@ -227,6 +227,12 @@ private final class CallCollector: SyntaxVisitor {
             return (name, operation)
         }
 
+        // Generic specialization: `Type<Generic>(args)` wraps the base in
+        // GenericSpecializationExprSyntax. Unwrap to extract the type name.
+        if let generic = expression.as(GenericSpecializationExprSyntax.self) {
+            return callTarget(from: generic.expression)
+        }
+
         return nil
     }
 }