fix: align enclosing-caller attribution for variable bindings (haskell, zig)

Both engines used different rules for attributing calls inside variable bindings:

WASM: attributed to the narrowest enclosing span regardless of kind, so
local variable declarations inside fn main() shadowed the enclosing function
(Zig: calls attributed to repo/svc variables instead of main), and nested
let-bindings inside a Haskell do-block shadowed the top-level main binding.

Native: loaded allNodes from a query that excluded 'variable' kind, so
top-level Haskell bind nodes (main = do …, kind='variable') never matched
in defs_with_ids, causing all calls to fall back to the file node.

Unified rule implemented in findCaller (TS) and find_enclosing_caller (Rust):
- Function/method definitions are preferred over any variable/constant binding
  as the enclosing caller scope — local var declarations inside a function
  body never shadow the enclosing function (fixes Zig repo/svc attribution).
- When no function/method encloses the call, fall back to the WIDEST
  (outermost) variable/constant binding — this handles Haskell where main
  is a top-level bind node with kind 'variable'. Widest span is used so that
  nested let-bindings do not shadow the outer main binding.
- File node remains the absolute last resort.

Also adds 'variable' to NODE_KIND_FILTER_SQL (JS) and EDGE_NODE_KIND_FILTER
(Rust pipeline.rs) so top-level variable bindings are included in the allNodes
set available for caller matching.

parity-compare.mjs --langs haskell,zig --hybrid: PARITY OK — 2/2 fixtures.

Author: carlos-alm

crates/codegraph-core/src/domain/graph/builder/pipeline.rs

@@ -1115,7 +1115,7 @@ fn builtin_call_receivers() -> Vec<String> {
     .collect()
 }
 
-const EDGE_NODE_KIND_FILTER: &str = "kind IN ('function','method','class','interface','struct','type','module','enum','trait','record','constant')";
+const EDGE_NODE_KIND_FILTER: &str = "kind IN ('function','method','class','interface','struct','type','module','enum','trait','record','constant','variable')";
 
 /// For the scoped (incremental, small-batch) path of the edge builder,
 /// compute the set of files that must be loaded: changed/reverse-dep files

crates/codegraph-core/src/domain/graph/builder/stages/build_edges.rs

@@ -127,6 +127,7 @@ pub struct ComputedEdge {
 /// Internal struct for caller resolution (def line range → node ID).
 struct DefWithId<'a> {
     name: &'a str,
+    kind: &'a str,
     line: u32,
     end_line: u32,
     node_id: Option<u32>,
@@ -473,7 +474,7 @@ fn process_file<'a>(
         let node_id = file_nodes.iter()
             .find(|n| n.name == d.name && n.kind == d.kind && n.line == d.line)
             .map(|n| n.id);
-        DefWithId { name: &d.name, line: d.line, end_line: d.end_line.unwrap_or(u32::MAX), node_id }
+        DefWithId { name: &d.name, kind: &d.kind, line: d.line, end_line: d.end_line.unwrap_or(u32::MAX), node_id }
     }).collect();
 
     // Phase 8.3: build pts map for alias resolution — mirrors buildPointsToMapForFile.
@@ -654,25 +655,76 @@ fn process_file<'a>(
     emit_hierarchy_edges(ctx, file_input, rel_path, edges);
 }
 
+/// Callable definition kinds — only function/method bodies act as enclosing
+/// caller scopes.  Variable/constant bindings are a lower-priority fallback
+/// tier for top-level bindings like Haskell `main = do …` (kind `variable`).
+/// Mirrors `CALLABLE_KINDS` / `TOP_LEVEL_BINDING_KINDS` in call-resolver.ts.
+fn is_callable_kind(kind: &str) -> bool {
+    kind == "function" || kind == "method"
+}
+
+fn is_top_level_binding_kind(kind: &str) -> bool {
+    kind == "variable" || kind == "constant"
+}
+
 /// Find the narrowest enclosing definition for a call at the given line.
-/// Returns `(caller_id, caller_name)` — `caller_name` is `""` when the call is at file scope.
+///
+/// Two-pass strategy (mirrors the updated `findCaller` in call-resolver.ts):
+///   Pass 1 — narrowest enclosing function/method.  Local variable declarations
+///             inside a function body must not shadow the enclosing function.
+///   Pass 2 — narrowest enclosing variable/constant binding.  Used as fallback
+///             when no function/method encloses the call (e.g. Haskell top-level
+///             `main = do …` is a `bind` node with kind `variable`).
+///
+/// Returns `(caller_id, caller_name)` — `caller_name` is `""` when the call
+/// falls back to file scope.
 fn find_enclosing_caller<'a>(defs: &[DefWithId<'a>], call_line: u32, file_node_id: u32) -> (u32, &'a str) {
-    let mut caller_id = file_node_id;
-    let mut caller_name = "";
-    let mut caller_span = u32::MAX;
+    let mut fn_caller_id: Option<u32> = None;
+    let mut fn_caller_name = "";
+    let mut fn_caller_span = u32::MAX;
+
+    // For variable/constant bindings we pick the WIDEST span (outermost binding),
+    // not the narrowest, so that nested `let` bindings inside `main`'s do-block
+    // do not shadow `main` itself.  The outermost enclosing variable is the
+    // "function-like" top-level binding (e.g. Haskell `main = do …`).
+    // var_caller_span starts at 0 — any real spanning binding has span >= 0
+    // and we overwrite only when span is strictly greater.
+    let mut var_caller_id: Option<u32> = None;
+    let mut var_caller_name = "";
+    // Using i64 so the initial sentinel (-1) is always beaten by a real span (>= 0).
+    let mut var_caller_span: i64 = -1;
+
     for def in defs {
         if def.line <= call_line && call_line <= def.end_line {
-            let span = def.end_line - def.line;
-            if span < caller_span {
-                if let Some(id) = def.node_id {
-                    caller_id = id;
-                    caller_name = def.name;
-                    caller_span = span;
+            let span = def.end_line.saturating_sub(def.line);
+            if is_callable_kind(def.kind) {
+                if span < fn_caller_span {
+                    if let Some(id) = def.node_id {
+                        fn_caller_id = Some(id);
+                        fn_caller_name = def.name;
+                        fn_caller_span = span;
+                    }
+                }
+            } else if is_top_level_binding_kind(def.kind) {
+                if (span as i64) > var_caller_span {
+                    if let Some(id) = def.node_id {
+                        var_caller_id = Some(id);
+                        var_caller_name = def.name;
+                        var_caller_span = span as i64;
+                    }
                 }
             }
         }
     }
-    (caller_id, caller_name)
+
+    // Prefer function/method over variable/constant binding.
+    if let Some(id) = fn_caller_id {
+        return (id, fn_caller_name);
+    }
+    if let Some(id) = var_caller_id {
+        return (id, var_caller_name);
+    }
+    (file_node_id, "")
 }
 
 /// Multi-strategy call target resolution: import-aware → same-file → type-aware → scoped.

src/domain/graph/builder/call-resolver.ts

@@ -47,6 +47,22 @@ export function isModuleScopedLanguage(relPath: string): boolean {
 
 // ── Shared resolution functions ──────────────────────────────────────────
 
+/**
+ * Callable definition kinds — variable/constant bindings are NOT callable
+ * in the function-as-enclosing-scope sense (they are local declarations, not
+ * function bodies). Top-level variable bindings (e.g. Haskell `main = do …`)
+ * are handled separately as a fallback tier.
+ */
+const CALLABLE_KINDS = new Set(['function', 'method']);
+
+/**
+ * Variable-like binding kinds that may act as top-level callers when no
+ * enclosing function/method exists (e.g. Haskell top-level `main` is a
+ * `bind` node → kind `variable`).  Local variable declarations inside a
+ * function body must NOT win over the enclosing function.
+ */
+const TOP_LEVEL_BINDING_KINDS = new Set(['variable', 'constant']);
+
 export function findCaller(
   lookup: CallNodeLookup,
   call: { line: number },
@@ -59,26 +75,63 @@ export function findCaller(
   relPath: string,
   fileNodeRow: { id: number },
 ): { id: number; callerName: string | null } {
-  let caller: { id: number } | null = null;
-  let callerName: string | null = null;
-  let callerSpan = Infinity;
+  // Pass 1: find the narrowest enclosing function/method.
+  let fnCaller: { id: number } | null = null;
+  let fnCallerName: string | null = null;
+  let fnCallerSpan = Infinity;
+
+  // Pass 2: find the widest (outermost) enclosing variable/constant binding.
+  // Used as fallback when no function/method encloses the call site
+  // (e.g. Haskell `main = do …` is a `bind` node with kind `variable`).
+  // We pick the WIDEST span (outermost binding), not the narrowest, so that
+  // nested `let` bindings inside `main`'s do-block do not shadow `main`
+  // itself as the attributing caller.  The outermost enclosing variable is
+  // the "function-like" top-level binding.
+  let varCaller: { id: number } | null = null;
+  let varCallerName: string | null = null;
+  let varCallerSpan = -1; // looking for WIDEST span, so start at -1
+
   for (const def of definitions) {
     if (def.line <= call.line) {
       const end = def.endLine || Infinity;
       if (call.line <= end) {
-        const span = end - def.line;
-        if (span < callerSpan) {
-          const row = lookup.nodeId(def.name, def.kind, relPath, def.line);
-          if (row) {
-            caller = row;
-            callerName = def.name;
-            callerSpan = span;
+        const span = end === Infinity ? Infinity : end - def.line;
+        if (CALLABLE_KINDS.has(def.kind)) {
+          if (span < fnCallerSpan) {
+            const row = lookup.nodeId(def.name, def.kind, relPath, def.line);
+            if (row) {
+              fnCaller = row;
+              fnCallerName = def.name;
+              fnCallerSpan = span;
+            }
+          }
+        } else if (TOP_LEVEL_BINDING_KINDS.has(def.kind)) {
+          if (span > varCallerSpan) {
+            const row = lookup.nodeId(def.name, def.kind, relPath, def.line);
+            if (row) {
+              varCaller = row;
+              varCallerName = def.name;
+              varCallerSpan = span;
+            }
           }
         }
       }
     }
   }
-  return { ...(caller ?? fileNodeRow), callerName };
+
+  // Prefer function/method enclosing scope over variable binding.
+  // If a function/method encloses the call, use it — local variable
+  // declarations inside the function body must not shadow it.
+  // Only fall back to a variable/constant binding when the call is at
+  // top-level scope (no enclosing function/method found), which handles
+  // languages like Haskell where `main` is a top-level `bind` node.
+  if (fnCaller) {
+    return { ...fnCaller, callerName: fnCallerName };
+  }
+  if (varCaller) {
+    return { ...varCaller, callerName: varCallerName };
+  }
+  return { ...fileNodeRow, callerName: null };
 }
 
 export function resolveByMethodOrGlobal(

src/domain/graph/builder/stages/build-edges.ts

@@ -1471,7 +1471,7 @@ function reconnectReverseDepEdges(ctx: PipelineContext): void {
  * their import targets. Falls back to loading ALL nodes for full builds or
  * larger incremental changes.
  */
-const NODE_KIND_FILTER_SQL = `kind IN ('function','method','class','interface','struct','type','module','enum','trait','record','constant')`;
+const NODE_KIND_FILTER_SQL = `kind IN ('function','method','class','interface','struct','type','module','enum','trait','record','constant','variable')`;
 
 function loadNodes(ctx: PipelineContext): { rows: QueryNodeRow[]; scoped: boolean } {
   const { db, fileSymbols, isFullBuild, batchResolved } = ctx;