fix: resolve merge conflicts with main

Author: carlos-alm

crates/codegraph-core/src/edge_builder.rs

@@ -503,28 +503,31 @@ fn resolve_call_targets<'a>(
             .unwrap_or_default();
         if !exact.is_empty() { return exact; }
 
-        // 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).
-        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; }
-            }
+        // 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; }
+        }
 
-            // 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.)
+        // 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() {
             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();

package-lock.json

@@ -192,10 +192,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/call-resolver.ts

@@ -584,7 +584,11 @@ function buildCallEdges(
           }
         }
         if (targets.length === 0) {
-          const sameFile = lookup.byNameAndFile(call.name, relPath);
+          // Narrow to function/method kinds only to avoid matching unrelated
+          // variables or classes that share a name in the same file.
+          const sameFile = lookup
+            .byNameAndFile(call.name, relPath)
+            .filter((n) => n.kind === 'function' || n.kind === 'method');
           if (sameFile.length > 0) {
             targets = [...sameFile];
           }

src/domain/graph/builder/incremental.ts

@@ -17,6 +17,7 @@ import type {
   ClassRelation,
   Definition,
   ExtractorOutput,
+  FnRefBinding,
   Import,
   NativeAddon,
   NodeRow,
@@ -709,6 +710,78 @@ function buildFnRefBindingsPtsPostPass(
   }
 }
 
+/**
+ * this-rebinding post-pass for the native call-edge path.
+ *
+ * When `fn.call(namedCtx, ...)` or `fn.apply(namedCtx, ...)` is extracted by the
+ * WASM layer, `thisCallBindings` records `{ callee: 'fn', thisArg: 'namedCtx' }`.
+ * The native Rust engine has no knowledge of these bindings, so `this()` calls
+ * inside `fn` remain unresolved. This JS post-pass adds the missing edges by
+ * resolving `this()` calls inside each `fn` that has a thisCallBinding.
+ */
+function buildThisCallBindingsPtsPostPass(
+  ctx: PipelineContext,
+  getNodeIdStmt: NodeIdStmt,
+  allEdgeRows: EdgeRowTuple[],
+  sharedLookup?: CallNodeLookup,
+): void {
+  const filesWithBindings = [...ctx.fileSymbols].filter(
+    ([, symbols]) => symbols.thisCallBindings && symbols.thisCallBindings.length > 0,
+  );
+  if (filesWithBindings.length === 0) return;
+
+  const seenByPair = new Set<string>();
+  for (const [srcId, tgtId] of allEdgeRows) {
+    seenByPair.add(`${srcId}|${tgtId}`);
+  }
+
+  const { barrelOnlyFiles, rootDir } = ctx;
+  const lookup = sharedLookup ?? makeContextLookup(ctx, getNodeIdStmt);
+
+  for (const [relPath, symbols] of filesWithBindings) {
+    if (barrelOnlyFiles.has(relPath)) continue;
+    const fileNodeRow = getNodeIdStmt.get(relPath, 'file', relPath, 0);
+    if (!fileNodeRow) continue;
+
+    const importedNames = buildImportedNamesMap(ctx, relPath, symbols, rootDir);
+    const typeMap: Map<string, TypeMapEntry | string> = symbols.typeMap || new Map();
+    const ptsMap = buildPointsToMapForFile(symbols, importedNames);
+    if (!ptsMap) continue;
+
+    // Only process calls named 'this' (callee-not-receiver usage)
+    for (const call of symbols.calls) {
+      if (call.name !== 'this' || call.receiver) continue;
+
+      const caller = findCaller(lookup, call, symbols.definitions, relPath, fileNodeRow);
+      if (caller.callerName == null) continue;
+
+      const scopedKey = `${caller.callerName}::this`;
+      if (!ptsMap.has(scopedKey)) continue;
+
+      for (const alias of resolveViaPointsTo(scopedKey, ptsMap)) {
+        const { targets: aliasTargets, importedFrom: aliasFrom } = resolveCallTargets(
+          lookup,
+          { name: alias },
+          relPath,
+          importedNames,
+          typeMap as Map<string, unknown>,
+        );
+        for (const t of aliasTargets) {
+          const edgeKey = `${caller.id}|${t.id}`;
+          if (t.id !== caller.id && !seenByPair.has(edgeKey)) {
+            const conf =
+              computeConfidence(relPath, t.file, aliasFrom ?? null) - PROPAGATION_HOP_PENALTY;
+            if (conf > 0) {
+              seenByPair.add(edgeKey);
+              allEdgeRows.push([caller.id, t.id, 'calls', conf, 0, 'points-to']);
+            }
+          }
+        }
+      }
+    }
+  }
+}
+
 /**
  * Phase 8.3f post-pass for the native call-edge path.
  *
@@ -1144,6 +1217,7 @@ function buildPointsToMapForFile(
   symbols: ExtractorOutput,
   importedNames: Map<string, string>,
 ): PointsToMap | null {
+  const hasThisCallBindings = !!symbols.thisCallBindings?.length;
   if (
     !symbols.fnRefBindings?.length &&
     !symbols.paramBindings?.length &&
@@ -1152,7 +1226,8 @@ function buildPointsToMapForFile(
     !symbols.forOfBindings?.length &&
     !symbols.arrayCallbackBindings?.length &&
     !symbols.objectRestParamBindings?.length &&
-    !symbols.objectPropBindings?.length
+    !symbols.objectPropBindings?.length &&
+    !hasThisCallBindings
   )
     return null;
   const defNames = new Set(
@@ -1161,8 +1236,21 @@ function buildPointsToMapForFile(
       .map((d) => d.name),
   );
   const definitionParams = buildDefinitionParamsMap(symbols.definitions);
+
+  // Convert thisCallBindings into scoped fnRefBindings: `fn::this → namedCtx`.
+  // The scoped key `fn::this` is looked up when `this()` calls are resolved inside
+  // function `fn` — caller.callerName='fn', call.name='this' → scopedPtsKey='fn::this'.
+  let allFnRefBindings: readonly FnRefBinding[] = symbols.fnRefBindings ?? [];
+  if (hasThisCallBindings) {
+    const extra: FnRefBinding[] = (symbols.thisCallBindings ?? []).map((b) => ({
+      lhs: `${b.callee}::this`,
+      rhs: b.thisArg,
+    }));
+    allFnRefBindings = [...allFnRefBindings, ...extra];
+  }
+
   return buildPointsToMap(
-    symbols.fnRefBindings ?? [],
+    allFnRefBindings,
     defNames,
     importedNames,
     symbols.paramBindings,
@@ -1816,6 +1904,9 @@ export async function buildEdges(ctx: PipelineContext): Promise<void> {
       // (e.g. `const f = fn.bind(ctx)`), so calls to bind-created aliases are
       // not resolved to their original function on the native path.
       buildFnRefBindingsPtsPostPass(ctx, getNodeIdStmt, allEdgeRows, sharedLookup);
+      // this-rebinding post-pass: resolve `this()` calls inside functions that
+      // were invoked via `.call(namedCtx, ...)` / `.apply(namedCtx, ...)`.
+      buildThisCallBindingsPtsPostPass(ctx, getNodeIdStmt, allEdgeRows, sharedLookup);
       // Phase 8.3f post-pass: augment native call edges with object rest-param
       // receiver resolution — typeMap[restName] → argName → typeMap[argName.method].
       buildObjectRestParamPostPass(ctx, getNodeIdStmt, allEdgeRows, sharedLookup);