fix(swift): harden symbol workflow accuracy

Author: ahavili

grapha-core/src/graph.rs

@@ -6,6 +6,7 @@ use std::path::PathBuf;
 #[serde(rename_all = "snake_case")]
 pub enum NodeKind {
     Function,
+    Class,
     Struct,
     Enum,
     Trait,
@@ -157,6 +158,9 @@ mod tests {
         let json = serde_json::to_string(&NodeKind::Function).unwrap();
         assert_eq!(json, "\"function\"");
 
+        let json = serde_json::to_string(&NodeKind::Class).unwrap();
+        assert_eq!(json, "\"class\"");
+
         let json = serde_json::to_string(&NodeKind::Struct).unwrap();
         assert_eq!(json, "\"struct\"");
     }

grapha-core/src/normalize.rs

@@ -1,6 +1,6 @@
 use std::collections::HashMap;
 
-use crate::graph::{Edge, EdgeKind, FlowDirection, Graph, Node, Visibility};
+use crate::graph::{Edge, EdgeKind, FlowDirection, Graph, Node, NodeKind, Visibility};
 
 pub fn normalize_graph(mut graph: Graph) -> Graph {
     fn visibility_rank(visibility: &Visibility) -> u8 {
@@ -11,7 +11,15 @@ pub fn normalize_graph(mut graph: Graph) -> Graph {
         }
     }
 
+    fn merged_kind(existing: NodeKind, incoming: NodeKind) -> NodeKind {
+        match (existing, incoming) {
+            (NodeKind::Struct, NodeKind::Class) => NodeKind::Class,
+            _ => existing,
+        }
+    }
+
     fn merge_node(existing: &mut Node, incoming: Node) {
+        existing.kind = merged_kind(existing.kind, incoming.kind);
         if visibility_rank(&incoming.visibility) > visibility_rank(&existing.visibility) {
             existing.visibility = incoming.visibility;
         }
@@ -268,6 +276,54 @@ mod tests {
         assert_eq!(normalized.nodes[0].module.as_deref(), Some("Room"));
     }
 
+    #[test]
+    fn normalize_graph_prefers_class_over_struct_for_same_symbol() {
+        let graph = Graph {
+            version: "0.1.0".to_string(),
+            nodes: vec![
+                Node {
+                    id: "AppDelegate".to_string(),
+                    kind: NodeKind::Struct,
+                    name: "AppDelegate".to_string(),
+                    file: PathBuf::from("AppDelegate.swift"),
+                    span: Span {
+                        start: [0, 0],
+                        end: [1, 0],
+                    },
+                    visibility: Visibility::Crate,
+                    metadata: HashMap::new(),
+                    role: None,
+                    signature: None,
+                    doc_comment: None,
+                    module: None,
+                    snippet: None,
+                },
+                Node {
+                    id: "AppDelegate".to_string(),
+                    kind: NodeKind::Class,
+                    name: "AppDelegate".to_string(),
+                    file: PathBuf::from("AppDelegate.swift"),
+                    span: Span {
+                        start: [0, 0],
+                        end: [1, 0],
+                    },
+                    visibility: Visibility::Crate,
+                    metadata: HashMap::new(),
+                    role: None,
+                    signature: None,
+                    doc_comment: None,
+                    module: None,
+                    snippet: None,
+                },
+            ],
+            edges: vec![],
+        };
+
+        let normalized = normalize_graph(graph);
+        assert_eq!(normalized.nodes.len(), 1);
+        assert_eq!(normalized.nodes[0].kind, NodeKind::Class);
+    }
+
     #[test]
     fn fingerprint_changes_when_effect_shape_changes() {
         let base = Edge {

grapha-swift/src/binary.rs

@@ -118,6 +118,7 @@ fn read_str(string_table: &[u8], offset: u32, len: u32) -> Option<&str> {
 fn decode_node_kind(v: u8) -> Option<NodeKind> {
     match v {
         0 => Some(NodeKind::Function),
+        9 => Some(NodeKind::Class),
         1 => Some(NodeKind::Struct),
         2 => Some(NodeKind::Enum),
         3 => Some(NodeKind::Protocol),

grapha-swift/src/swiftsyntax.rs

@@ -75,7 +75,7 @@ mod tests {
 
         let config = find_node(&result, "Config", NodeKind::Struct);
         let configurable = find_node(&result, "Configurable", NodeKind::Protocol);
-        let app_delegate = find_node(&result, "AppDelegate", NodeKind::Struct);
+        let app_delegate = find_node(&result, "AppDelegate", NodeKind::Class);
         let launch = find_node(&result, "launch", NodeKind::Function);
         let default_config = find_node(&result, "defaultConfig", NodeKind::Function);
         let theme = find_node(&result, "Theme", NodeKind::Enum);
@@ -122,7 +122,7 @@ mod tests {
         let result = extract_with_swiftsyntax(source.as_bytes(), fixture_path())
             .expect("SwiftSyntax extraction should succeed");
 
-        let worker = find_node(&result, "Worker", NodeKind::Struct);
+        let worker = find_node(&result, "Worker", NodeKind::Class);
         let extension_node = result
             .nodes
             .iter()

grapha-swift/src/treesitter.rs

@@ -298,7 +298,7 @@ fn walk_node(
                         file,
                         module_path,
                         parent_id,
-                        NodeKind::Struct,
+                        NodeKind::Class,
                         result,
                     );
                 }
@@ -1177,7 +1177,7 @@ fn extract_calls_from_text(
             result.edges.push(Edge {
                 source: caller_id.to_string(),
                 target: target_id,
-                kind: EdgeKind::Calls,
+                kind: EdgeKind::Reads,
                 confidence: 0.5,
                 direction: None,
                 operation: Some(prefix),
@@ -1777,7 +1777,7 @@ fn extract_nav_prefix(node: tree_sitter::Node, source: &[u8]) -> Option<String>
 }
 
 /// Recursively scan for `call_expression` and `navigation_expression` nodes,
-/// emitting Calls edges for function calls and TypeRef edges for property accesses.
+/// emitting Calls edges for function calls and Reads edges for property accesses.
 fn extract_calls(
     node: tree_sitter::Node,
     source: &[u8],
@@ -1806,8 +1806,8 @@ fn extract_calls(
     }
 
     // Property access: `foo.bar` generates a navigation_expression.
-    // Emit a Calls edge so that property reads appear in the graph
-    // and impact analysis can trace through them.
+    // Emit a Reads edge so dependency queries can trace through the access
+    // without polluting call lists with field-like symbols.
     // Skip if the parent is a call_expression (already handled above as the callee name).
     if node.kind() == "navigation_expression"
         && !matches!(node.parent().map(|p| p.kind()), Some("call_expression"))
@@ -1830,7 +1830,7 @@ fn extract_calls(
             result.edges.push(Edge {
                 source: caller_id.to_string(),
                 target: target_id,
-                kind: EdgeKind::Calls,
+                kind: EdgeKind::Reads,
                 confidence: 0.6,
                 direction: None,
                 operation: prefix,
@@ -1971,6 +1971,10 @@ fn dependency_read_name(
         return None;
     }
 
+    if is_syntactic_argument_label(node, source) {
+        return None;
+    }
+
     let name = node.utf8_text(source).ok()?.trim().to_string();
     if name.is_empty() || name == "_" || uppercase_identifier(&name) {
         return None;
@@ -1989,6 +1993,48 @@ fn dependency_read_name(
     Some(name)
 }
 
+fn is_syntactic_argument_label(node: tree_sitter::Node, source: &[u8]) -> bool {
+    let mut cursor = node.parent();
+    let mut inside_call_syntax = false;
+    while let Some(parent) = cursor {
+        if matches!(
+            parent.kind(),
+            "value_argument"
+                | "value_arguments"
+                | "call_suffix"
+                | "call_expression"
+                | "navigation_suffix"
+                | "navigation_expression"
+        ) {
+            inside_call_syntax = true;
+            break;
+        }
+        if matches!(
+            parent.kind(),
+            "function_declaration"
+                | "protocol_function_declaration"
+                | "init_declaration"
+                | "closure_parameter"
+                | "parameter"
+        ) {
+            break;
+        }
+        cursor = parent.parent();
+    }
+
+    if !inside_call_syntax {
+        return false;
+    }
+
+    let remaining = &source[node.end_byte()..];
+    let offset = remaining
+        .iter()
+        .position(|b| !b.is_ascii_whitespace())
+        .unwrap_or(remaining.len());
+
+    remaining.get(offset).copied() == Some(b':')
+}
+
 fn emit_dependency_read(
     node: tree_sitter::Node,
     source: &[u8],
@@ -3711,7 +3757,7 @@ mod tests {
     fn extracts_class() {
         let result = extract("public class AppDelegate { }");
         let node = find_node(&result, "AppDelegate");
-        assert_eq!(node.kind, NodeKind::Struct); // classes map to Struct in our model
+        assert_eq!(node.kind, NodeKind::Class);
         assert_eq!(node.visibility, Visibility::Public);
     }
 
@@ -3882,6 +3928,31 @@ mod tests {
         assert_eq!(call_edge.provenance[0].symbol_id, "test.swift::launch");
     }
 
+    #[test]
+    fn property_accesses_become_reads_not_calls() {
+        let result = extract(
+            r#"
+            struct Model { let value: Int }
+            func launch(model: Model) {
+                let current = model.value
+            }
+            "#,
+        );
+
+        assert!(has_edge(
+            &result,
+            "test.swift::launch",
+            "test.swift::value",
+            EdgeKind::Reads,
+        ));
+        assert!(!has_edge(
+            &result,
+            "test.swift::launch",
+            "test.swift::value",
+            EdgeKind::Calls,
+        ));
+    }
+
     #[test]
     fn extracts_condition_on_call_inside_if() {
         let result = extract(
@@ -4368,6 +4439,65 @@ mod tests {
         assert!(has_read("test.swift::RoomPage::minimizeGameRoom"));
     }
 
+    #[test]
+    fn skips_argument_labels_when_enriching_property_reads() {
+        let result = extract_with_localization(
+            r#"
+            import SwiftUI
+
+            struct GeneralButtonType {
+                let type: Int
+            }
+
+            struct AudioButton {
+                let label: String
+            }
+
+            struct LoginPage: View {
+                @State private var isNextValid = false
+
+                private var loginButton: some View {
+                    Button {
+                    } label: {
+                        Text("Login")
+                    }
+                    .buttonStyle(.app(type: .yellowH112))
+                    .disabled(isNextValid.negated)
+                }
+
+                var body: some View { loginButton }
+            }
+            "#,
+        );
+        let graph = grapha_core::merge(vec![result]);
+
+        let read_targets: Vec<_> = graph
+            .edges
+            .iter()
+            .filter(|edge| {
+                edge.source == "test.swift::LoginPage::loginButton" && edge.kind == EdgeKind::Reads
+            })
+            .map(|edge| edge.target.as_str())
+            .collect();
+
+        assert!(
+            read_targets.contains(&"test.swift::LoginPage::isNextValid"),
+            "real property reads should still be preserved"
+        );
+        assert!(
+            read_targets
+                .iter()
+                .all(|target| !target.ends_with("::label")),
+            "trailing closure labels should not become dependency reads: {read_targets:?}"
+        );
+        assert!(
+            read_targets
+                .iter()
+                .all(|target| !target.ends_with("::type")),
+            "named argument labels should not become dependency reads: {read_targets:?}"
+        );
+    }
+
     #[test]
     fn marks_swiftui_dynamic_properties_as_invalidation_sources() {
         let result = extract_with_localization(

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

@@ -380,7 +380,7 @@ private func mapSymbolKind(_ raw: UInt64) -> UInt8? {
     switch raw {
     case 5:  return 2   // enum
     case 6:  return 1   // struct
-    case 7:  return 1   // Class → struct in grapha
+    case 7:  return 9   // class
     case 8:  return 3   // protocol
     case 9:  return 4   // extension
     case 11: return 5   // type_alias

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

@@ -16,6 +16,7 @@ struct BridgeNodeRole: Encodable {
 
 enum BridgeNodeKind: String, Encodable {
     case function
+    case `class`
     case `struct`
     case `enum`
     case `protocol`
@@ -278,7 +279,7 @@ private final class SwiftSyntaxExtractor {
         if let node = decl.as(ClassDeclSyntax.self) {
             processNominal(
                 name: normalizeIdentifier(node.name.text),
-                kind: .struct,
+                kind: .class,
                 syntax: Syntax(node),
                 modifiers: node.modifiers,
                 attributes: node.attributes,

grapha/src/filter.rs

@@ -8,6 +8,7 @@ pub fn parse_filter(filter: &str) -> anyhow::Result<HashSet<NodeKind>> {
     for part in filter.split(',') {
         let kind = match part.trim() {
             "fn" | "function" => NodeKind::Function,
+            "class" => NodeKind::Class,
             "struct" => NodeKind::Struct,
             "enum" => NodeKind::Enum,
             "trait" => NodeKind::Trait,

grapha/src/query.rs

@@ -81,7 +81,8 @@ fn kind_preference(kind: NodeKind) -> usize {
         NodeKind::Function => 0,
         NodeKind::Property => 1,
         NodeKind::Variant | NodeKind::Field => 2,
-        NodeKind::Struct
+        NodeKind::Class
+        | NodeKind::Struct
         | NodeKind::Enum
         | NodeKind::Trait
         | NodeKind::Module

grapha/src/query/dataflow.rs

@@ -396,7 +396,11 @@ pub fn query_dataflow(
     // outgoing dataflow edges. Suggest its member functions instead.
     if matches!(
         entry_node.kind,
-        NodeKind::Struct | NodeKind::Enum | NodeKind::Protocol | NodeKind::Extension
+        NodeKind::Class
+            | NodeKind::Struct
+            | NodeKind::Enum
+            | NodeKind::Protocol
+            | NodeKind::Extension
     ) {
         let members: Vec<&str> = graph
             .edges