fix: resolve merge conflicts with main

Author: carlos-alm

crates/codegraph-core/src/edge_builder.rs

@@ -503,48 +503,31 @@ fn resolve_call_targets<'a>(
             .unwrap_or_default();
         if !exact.is_empty() { return exact; }
 
-        // Bare-call same-class fallback: mirrors the WASM buildFileCallEdges same-class
-        // bare-call fallback. When a no-receiver call can't be resolved globally, try the
-        // caller's own class prefix: `IsValidEmail()` in `Validators.ValidateUser` →
-        // `Validators.IsValidEmail`. Safe: only fires after the global exact lookup fails,
-        // so module-level functions always take priority.
-        if call.receiver.is_none() {
-            if let Some(dot_pos) = caller_name.find('.') {
-                let class_prefix = &caller_name[..dot_pos];
-                let qualified = format!("{}.{}", class_prefix, call.name);
-                let class_scoped: Vec<&NodeInfo> = ctx.nodes_by_name
-                    .get(qualified.as_str())
-                    .map(|v| v.iter()
-                        .filter(|n| n.kind == "method" && n.file == rel_path)
-                        .copied()
-                        .collect())
-                    .unwrap_or_default();
-                if !class_scoped.is_empty() { return class_scoped; }
-            }
+        // Class-scoped exact lookup: prefer `ClassName.method` when the caller is a qualified
+        // method (e.g. `this.area()` or plain `area()` in `Shape.describe` → try `Shape.area`).
+        // Covers both this/self/super dispatch AND no-receiver static sibling calls (e.g.
+        // `IsValidEmail()` inside `Validators.ValidateUser` → `Validators.IsValidEmail`).
+        // This avoids false edges to unrelated classes that happen to have a method with the
+        // same name in the same file.
+        if let Some(dot_pos) = caller_name.find('.') {
+            let class_prefix = &caller_name[..dot_pos];
+            let qualified = format!("{}.{}", class_prefix, call.name);
+            let class_scoped: Vec<&NodeInfo> = ctx.nodes_by_name
+                .get(qualified.as_str())
+                .map(|v| v.iter()
+                    .filter(|n| n.kind == "method"
+                        && import_resolution::compute_confidence(rel_path, &n.file, None) >= 0.5)
+                    .copied().collect())
+                .unwrap_or_default();
+            if !class_scoped.is_empty() { return class_scoped; }
         }
 
-        // For this/self/super: prefer class-scoped exact lookup (e.g. `this.area()` in
-        // `Shape.describe` → try `Shape.area` first).  This avoids false edges to unrelated
-        // classes that happen to have a method with the same name in the same file.
-        // Fall back to the broader same-file suffix scan only when the class-scoped lookup
-        // finds nothing (e.g. when the caller is at module scope or the name is unknown).
+        // Broader fallback: same-file suffix scan.  Only for this/self/super (not no-receiver
+        // plain calls) to avoid false positives on global function calls inside class methods.
+        // Always restricts to the caller's own class prefix to avoid false edges to unrelated
+        // classes in the same file (e.g. this.area() inside Shape.describe must never yield
+        // Calculator.area, even when Calculator.area is the only method with that name).
         if call.receiver.is_some() {
-            // Extract the class prefix from the enclosing caller name (e.g. "Shape" from "Shape.describe").
-            if let Some(dot_pos) = caller_name.find('.') {
-                let class_prefix = &caller_name[..dot_pos];
-                let qualified = format!("{}.{}", class_prefix, call.name);
-                let class_scoped: Vec<&NodeInfo> = ctx.nodes_by_name
-                    .get(qualified.as_str())
-                    .map(|v| v.iter().filter(|n| n.kind == "method").copied().collect())
-                    .unwrap_or_default();
-                if !class_scoped.is_empty() { return class_scoped; }
-            }
-
-            // Broader fallback: same-file suffix scan.  Always restrict to the caller's
-            // own class prefix — regardless of how many matches are found — to avoid
-            // false-positive edges to unrelated classes in the same file.
-            // (e.g. this.area() inside Shape.describe must never yield Calculator.area,
-            // even when Calculator.area is the only method with that name in the file.)
             let suffix = format!(".{}", call.name);
             if let Some(file_nodes) = ctx.nodes_by_file.get(rel_path) {
                 let same_file_methods: Vec<&NodeInfo> = file_nodes.iter()

crates/codegraph-core/src/extractors/javascript.rs

@@ -763,10 +763,14 @@ fn match_js_call_assignments(node: &Node, source: &[u8], symbols: &mut FileSymbo
 fn match_js_node(node: &Node, source: &[u8], symbols: &mut FileSymbols, _depth: usize) {
     match node.kind() {
         "function_declaration" | "generator_function_declaration" => handle_function_decl(node, source, symbols),
-        "class_declaration" | "abstract_class_declaration" => {
+        "class_declaration" | "abstract_class_declaration"
+        // class expressions: `return class Foo extends Bar { ... }` or `const X = class Foo { ... }`
+        | "class" => {
             handle_class_decl(node, source, symbols)
         }
+        "class_static_block" => handle_static_block(node, source, symbols),
         "method_definition" => handle_method_def(node, source, symbols),
+        "field_definition" | "public_field_definition" => handle_field_def(node, source, symbols),
         "interface_declaration" => handle_interface_decl(node, source, symbols),
         "type_alias_declaration" => handle_type_alias(node, source, symbols),
         "enum_declaration" => handle_enum_decl(node, source, symbols),
@@ -776,11 +780,6 @@ fn match_js_node(node: &Node, source: &[u8], symbols: &mut FileSymbols, _depth:
         "import_statement" => handle_import_stmt(node, source, symbols),
         "export_statement" => handle_export_stmt(node, source, symbols),
         "expression_statement" => handle_expr_stmt(node, source, symbols),
-        // Synthetic definitions for class field initializers and static blocks.
-        // These give `findCaller` a narrower span with a kind that passes the SQL
-        // call-edge filter (`kind IN ('function','method')`), matching WASM behaviour.
-        "field_definition" | "public_field_definition" => handle_field_def(node, source, symbols),
-        "class_static_block" => handle_static_block(node, source, symbols),
         _ => {}
     }
 }
@@ -864,6 +863,29 @@ fn handle_method_def(node: &Node, source: &[u8], symbols: &mut FileSymbols) {
     }
 }
 
+/// Create a synthetic `ClassName.<static:L:C>` definition for a class static block
+/// so that calls inside the block are attributed to a method-kind node and
+/// `super.method()` dispatch can walk up to the parent class.
+///
+/// The start line and column are appended to the name to ensure uniqueness when a
+/// class has multiple `static { }` blocks (each has a distinct start position even
+/// if on the same line).
+fn handle_static_block(node: &Node, source: &[u8], symbols: &mut FileSymbols) {
+    let Some(class_name) = find_parent_class(node, source) else { return };
+    let line = start_line(node);
+    let col = node.start_position().column;
+    symbols.definitions.push(Definition {
+        name: format!("{}.<static:{}:{}>", class_name, line, col),
+        kind: "method".to_string(),
+        line,
+        end_line: Some(end_line(node)),
+        decorators: None,
+        complexity: None,
+        cfg: None,
+        children: None,
+    });
+}
+
 /// Emit a `ClassName.fieldName` synthetic definition for each `class { field = ... }` node.
 /// Only fired when a value node is present (skips bare `x;` declarations), mirroring the WASM
 /// `handleFieldDef` guard.  The synthetic definition has `kind = "method"` so that the SQL
@@ -881,7 +903,12 @@ fn handle_field_def(node: &Node, source: &[u8], symbols: &mut FileSymbols) {
         return;
     }
     // Skip uninitialised fields (`class C { x; }`) — must have a value node.
-    let Some(_value_node) = node.child_by_field_name("value") else { return };
+    let Some(value_node) = node.child_by_field_name("value") else { return };
+    // Only emit a callable definition when the initializer is a function/arrow expression.
+    // Scalar fields like `static x = 42` should not appear as method-kind nodes.
+    if !matches!(value_node.kind(), "arrow_function" | "function_expression" | "generator_function") {
+        return;
+    }
     let field_name = node_text(&name_node, source);
     if field_name.is_empty() { return; }
     let Some(class_name) = find_parent_class(node, source) else { return };
@@ -897,23 +924,6 @@ fn handle_field_def(node: &Node, source: &[u8], symbols: &mut FileSymbols) {
     });
 }
 
-/// Emit a `ClassName.<static>` synthetic definition for each `static { }` block.
-/// Enables `findCaller` to attribute calls inside static initializer blocks to this
-/// synthetic node rather than to the enclosing class node, matching WASM behaviour.
-fn handle_static_block(node: &Node, source: &[u8], symbols: &mut FileSymbols) {
-    let Some(class_name) = find_parent_class(node, source) else { return };
-    symbols.definitions.push(Definition {
-        name: format!("{}.<static>", class_name),
-        kind: "function".to_string(),
-        line: start_line(node),
-        end_line: Some(end_line(node)),
-        decorators: None,
-        complexity: None,
-        cfg: None,
-        children: None,
-    });
-}
-
 fn handle_interface_decl(node: &Node, source: &[u8], symbols: &mut FileSymbols) {
     let Some(name_node) = node.child_by_field_name("name") else { return };
     let iface_name = node_text(&name_node, source).to_string();

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

@@ -196,10 +196,12 @@ export function resolveByMethodOrGlobal(
       .filter((t) => computeConfidence(relPath, t.file, null) >= 0.5);
     if (exact.length > 0) return exact;
 
-    // For this/self/super receiver: try same-class method lookup via callerName.
+    // Try same-class method lookup via callerName.
     // e.g. `this.area()` inside `Shape.describe` → try `Shape.area`.
+    // Also covers no-receiver calls inside class methods, e.g. `IsValidEmail(x)` inside
+    // `Validators.ValidateUser` → try `Validators.IsValidEmail` (C#/Java static siblings).
     // This seeds the initial edge that runChaPostPass later expands to subclass overrides.
-    if (call.receiver && callerName) {
+    if (callerName) {
       const dotIdx = callerName.lastIndexOf('.');
       if (dotIdx > -1) {
         // Extract only the segment immediately before the method name so that

src/domain/graph/builder/stages/native-orchestrator.ts

@@ -402,16 +402,16 @@ async function runPostNativeAnalysis(
  * Note: `this`/`super` dispatch is handled separately by `runPostNativeThisDispatch`,
  * which WASM-re-parses JS/TS files to obtain raw call site receiver info.
  *
- * Returns the set of target node IDs for newly inserted CHA edges so the caller
- * can re-classify roles for the affected implementation files.  An empty set
- * means no edges were added and role re-classification is unnecessary.
+ * Returns the count of newly inserted CHA edges so the caller can determine
+ * whether a full role re-classification is needed.  Zero means no edges were
+ * added and role re-classification is unnecessary.
  */
-function runPostNativeCha(db: BetterSqlite3Database): Set<number> {
+function runPostNativeCha(db: BetterSqlite3Database): number {
   // Fast guard: no hierarchy edges → no CHA work
   const hasHierarchy = db
     .prepare(`SELECT 1 FROM edges WHERE kind IN ('extends', 'implements') LIMIT 1`)
     .get();
-  if (!hasHierarchy) return new Set();
+  if (!hasHierarchy) return 0;
 
   // Build implementors map: parent/interface name → [child/implementing class names]
   const hierarchyRows = db
@@ -433,7 +433,7 @@ function runPostNativeCha(db: BetterSqlite3Database): Set<number> {
     }
     if (!list.includes(row.child_name)) list.push(row.child_name);
   }
-  if (implementors.size === 0) return new Set();
+  if (implementors.size === 0) return 0;
 
   // RTA: collect class names that are actually instantiated via `new X()`.
   // Primary query targets `class`-kind nodes (the canonical schema).
@@ -506,7 +506,7 @@ function runPostNativeCha(db: BetterSqlite3Database): Set<number> {
     `SELECT id, file AS method_file FROM nodes WHERE name = ? AND kind = 'method'`,
   );
   const newEdges: Array<[number, number, string, number, number, string]> = [];
-  const newTargetIds = new Set<number>();
+  let newEdgeCount = 0;
 
   for (const { source_id, method_name, caller_file } of callToMethods) {
     const dotIdx = method_name.indexOf('.');
@@ -545,7 +545,7 @@ function runPostNativeCha(db: BetterSqlite3Database): Set<number> {
               CHA_DISPATCH_PENALTY;
             if (conf <= 0) continue;
             newEdges.push([source_id, methodNode.id, 'calls', conf, 0, 'cha']);
-            newTargetIds.add(methodNode.id);
+            newEdgeCount++;
           }
         }
 
@@ -558,7 +558,7 @@ function runPostNativeCha(db: BetterSqlite3Database): Set<number> {
   if (newEdges.length > 0) {
     db.transaction(() => batchInsertEdges(db, newEdges))();
   }
-  return newTargetIds;
+  return newEdgeCount;
 }
 
 /**
@@ -1607,9 +1607,9 @@ export async function tryNativeOrchestrator(
   }
 
   // Phase 8.5: expand CHA call edges (interface dispatch → concrete implementations).
-  // Returns the target node IDs of newly inserted edges; used to determine whether
+  // Returns the count of newly inserted edges; used to determine whether
   // a full role re-classification is needed after all edge-writing post-passes complete.
-  const chaTargetIds = runPostNativeCha(ctx.db as unknown as BetterSqlite3Database);
+  const chaEdgeCount = runPostNativeCha(ctx.db as unknown as BetterSqlite3Database);
 
   // Function-as-object-property post-pass: the Rust engine does not yet recognise
   // `fn.method = function() {}` patterns. Re-parse only those JS/TS files via
@@ -1636,7 +1636,7 @@ export async function tryNativeOrchestrator(
   // this-dispatch) add edges, so the Rust-computed roles and the cached
   // fan-out medians are stale. A full re-classification ensures the final
   // roles reflect the true fan-in/out with all edges in place.
-  if (chaTargetIds.size > 0 || thisDispatchTargetIds.size > 0) {
+  if (chaEdgeCount > 0 || thisDispatchTargetIds.size > 0) {
     try {
       const { classifyNodeRoles } = (await import('../../../../features/structure.js')) as {
         classifyNodeRoles: (

src/extractors/javascript.ts

@@ -738,6 +738,13 @@ function walkJavaScriptNode(node: TreeSitterNode, ctx: ExtractorOutput): void {
     case 'class':
       handleClassDecl(node, ctx);
       break;
+    case 'class_static_block':
+      handleStaticBlock(node, ctx.definitions);
+      break;
+    case 'field_definition':
+    case 'public_field_definition':
+      handleFieldDef(node, ctx.definitions);
+      break;
     case 'method_definition':
       handleMethodDef(node, ctx);
       break;
@@ -769,13 +776,6 @@ function walkJavaScriptNode(node: TreeSitterNode, ctx: ExtractorOutput): void {
     case 'expression_statement':
       handleExpressionStmt(node, ctx);
       break;
-    case 'field_definition':
-    case 'public_field_definition':
-      handleFieldDef(node, ctx.definitions);
-      break;
-    case 'class_static_block':
-      handleStaticBlock(node, ctx.definitions);
-      break;
   }
 
   for (let i = 0; i < node.childCount; i++) {
@@ -843,39 +843,63 @@ function handleMethodDef(node: TreeSitterNode, ctx: ExtractorOutput): void {
   }
 }
 
+/**
+ * Create a synthetic `ClassName.<static:L:C>` definition for a class static block
+ * so that calls inside the block can be attributed to a method-kind node and
+ * `resolveThisDispatch` can walk up to the parent class for `super.method()`.
+ *
+ * The start line and column are appended to the name to ensure uniqueness when a
+ * class has multiple `static { }` blocks (each has a distinct start position even
+ * if on the same line).
+ *
+ * Tree-sitter uses `class_static_block` (not `static_block`) for `static { ... }`.
+ */
+function handleStaticBlock(node: TreeSitterNode, definitions: Definition[]): void {
+  const parentClass = findParentClass(node);
+  if (!parentClass) return;
+  const line = nodeStartLine(node);
+  const col = node.startPosition.column;
+  definitions.push({
+    name: `${parentClass}.<static:${line}:${col}>`,
+    kind: 'method',
+    line,
+    endLine: nodeEndLine(node),
+  });
+}
+
 /**
  * Emit a `ClassName.fieldName` definition for class fields that have an initializer.
  * This lets `findCaller` attribute calls inside field initializers (e.g. static field
  * side-effects) to the field rather than the enclosing class.
+ *
+ * JS `field_definition` uses the `'property'` field name; TS
+ * `public_field_definition` uses `'name'`. As a third fallback (Rust/TS parity) we
+ * also check for a positional `property_identifier` child.
  */
+const CALLABLE_FIELD_TYPES = new Set([
+  'arrow_function',
+  'function_expression',
+  'generator_function',
+]);
+
 function handleFieldDef(node: TreeSitterNode, definitions: Definition[]): void {
   // JS field_definition uses 'property' field; TS public_field_definition uses 'name' field
-  const nameNode = node.childForFieldName('name') || node.childForFieldName('property');
+  const nameNode =
+    node.childForFieldName('name') ||
+    node.childForFieldName('property') ||
+    findChild(node, 'property_identifier');
   const valueNode = node.childForFieldName('value');
   if (!nameNode || !valueNode) return;
   if (nameNode.type === 'computed_property_name') return;
+  // Only emit a callable definition when the initializer is a function/arrow expression.
+  // Scalar fields like `static x = 42` should not appear as method-kind nodes.
+  if (!CALLABLE_FIELD_TYPES.has(valueNode.type)) return;
   const fieldName = nameNode.text;
   if (!fieldName) return;
-  const className = findParentClass(node);
-  if (!className) return;
-  definitions.push({
-    name: `${className}.${fieldName}`,
-    kind: 'method',
-    line: nodeStartLine(node),
-    endLine: nodeEndLine(node),
-  });
-}
-
-/**
- * Emit a `ClassName.<static>` definition for each `static { }` block.
- * Enables `findCaller` to attribute calls inside static initializer blocks to
- * this synthetic node rather than to the enclosing class node.
- */
-function handleStaticBlock(node: TreeSitterNode, definitions: Definition[]): void {
-  const className = findParentClass(node);
-  if (!className) return;
+  const parentClass = findParentClass(node);
+  if (!parentClass) return;
   definitions.push({
-    name: `${className}.<static>`,
+    name: `${parentClass}.${fieldName}`,
     kind: 'method',
     line: nodeStartLine(node),
     endLine: nodeEndLine(node),

tests/benchmarks/resolution/fixtures/jelly-micro/classes/expected-edges.json

@@ -366,7 +366,7 @@
     },
     {
       "source": {
-        "name": "C6.<static>",
+        "name": "C6.<static:75:2>",
         "file": "classes.js"
       },
       "target": {
@@ -378,7 +378,7 @@
     },
     {
       "source": {
-        "name": "C6.<static>",
+        "name": "C6.<static:78:2>",
         "file": "classes.js"
       },
       "target": {

tests/benchmarks/resolution/fixtures/jelly-micro/super/expected-edges.json

@@ -78,7 +78,7 @@
     },
     {
       "source": {
-        "name": "B.<static>",
+        "name": "B.<static:36:2>",
         "file": "super.js"
       },
       "target": {