fix(resolver): attribute new ClassName() calls to the constructor method

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

@@ -986,6 +986,12 @@ fn resolve_exact_global_match<'a>(
 /// `caller_name` is the enclosing function/method name (e.g. `"Shape.describe"`) used to scope
 /// `this`/`self`/`super` dispatch to the caller's own class before falling back to a broader scan.
 /// Mirrors `resolveCallTargets` / `resolveByMethodOrGlobal` in call-resolver.ts.
+///
+/// Thin wrapper around `resolve_call_targets_core`: additionally attaches
+/// constructor-call attribution (#1892) for bare (no-receiver) calls — see
+/// `attach_constructor_targets`. Split out because the core resolver has many
+/// early-return tiers, so a single post-processing pass at the call site is
+/// simpler than threading the augmentation through every tier.
 fn resolve_call_targets<'a>(
     ctx: &EdgeContext<'a>,
     call: &CallInfo,
@@ -994,6 +1000,30 @@ fn resolve_call_targets<'a>(
     type_map: &HashMap<&str, (&str, f64)>,
     caller_name: &str,
     imported_original_names: &HashMap<&str, &str>,
+) -> Vec<&'a NodeInfo> {
+    let targets = resolve_call_targets_core(
+        ctx, call, rel_path, imported_from, type_map, caller_name, imported_original_names,
+    );
+    if call.receiver.is_some() {
+        return targets;
+    }
+    let class_name = imported_original_names
+        .get(call.name.as_str())
+        .copied()
+        .unwrap_or(call.name.as_str());
+    attach_constructor_targets(ctx, targets, class_name)
+}
+
+/// Core multi-strategy call target resolution — see `resolve_call_targets` for
+/// the public entry point (which additionally applies constructor attribution).
+fn resolve_call_targets_core<'a>(
+    ctx: &EdgeContext<'a>,
+    call: &CallInfo,
+    rel_path: &str,
+    imported_from: Option<&str>,
+    type_map: &HashMap<&str, (&str, f64)>,
+    caller_name: &str,
+    imported_original_names: &HashMap<&str, &str>,
 ) -> Vec<&'a NodeInfo> {
     // Flagged dynamic calls use synthetic names like "<dynamic:eval>". Short-circuit
     // so they never accidentally match a real symbol via name lookup.
@@ -1306,6 +1336,82 @@ fn resolve_call_targets<'a>(
     Vec::new()
 }
 
+// ── Constructor-call attribution (#1892) ──────────────────────────────────
+
+/// Per-language constructor method identifier, keyed by file extension. Used
+/// to build the qualified `ClassName.<ctorLocalName>` lookup key that
+/// attributes a `new ClassName()` (or bare `ClassName()`, for the keyword-less
+/// languages below) call site to the class's own constructor **method**,
+/// rather than only the class declaration node it already resolves to.
+/// Returns `None` when the extension is unrecognised (or has no extension at
+/// all). For Java/C#/Dart/Groovy the constructor's own identifier equals the
+/// class name (`class Foo { Foo(...) {} }`), so those arms return
+/// `class_name` itself rather than a fixed keyword. Mirrors
+/// `CONSTRUCTOR_LOCAL_NAME_BY_EXTENSION` in strategy.ts.
+///
+/// Deliberately excludes languages whose extractor does not emit an explicit
+/// constructor definition at all (Kotlin, Swift, Scala) or does not track
+/// object-construction call sites at all (C++) — for those, the class-node
+/// edge already produced by `resolve_call_targets_core` is the only
+/// attribution possible.
+fn constructor_local_name<'b>(file: &str, class_name: &'b str) -> Option<&'b str> {
+    let ext = file.rsplit_once('.').map(|(_, e)| e)?;
+    match ext {
+        "js" | "mjs" | "cjs" | "jsx" | "ts" | "tsx" | "mts" | "cts" => Some("constructor"),
+        "py" | "pyi" => Some("__init__"),
+        "php" | "phtml" => Some("__construct"),
+        "java" | "cs" | "dart" | "groovy" | "gvy" => Some(class_name),
+        _ => None,
+    }
+}
+
+/// Resolve the constructor **method** node for a class target, if the class
+/// declares one explicitly. Scoped to the class's own file (`file`) so an
+/// unrelated same-named constructor elsewhere can never match.
+fn resolve_constructor_target<'a>(
+    ctx: &EdgeContext<'a>,
+    file: &str,
+    class_name: &str,
+) -> Option<&'a NodeInfo> {
+    let local_name = constructor_local_name(file, class_name)?;
+    let qualified = format!("{}.{}", class_name, local_name);
+    ctx.nodes_by_name_and_file
+        .get(&(qualified.as_str(), file))
+        .and_then(|v| v.iter().find(|n| n.kind == "method"))
+        .copied()
+}
+
+/// Additive constructor-call attribution: for every `class`-kind target in
+/// `targets`, also resolve that class's own constructor method (if one is
+/// explicitly declared) and append it. Mirrors `attachConstructorTargets` in
+/// strategy.ts.
+///
+/// Additive, not a replacement: the class-node target is always left standing
+/// — the DB-driven RTA fallback (incremental rebuilds, see `cha.ts`'s
+/// `buildChaContextFromDb`) reads instantiation evidence from `calls` edges
+/// targeting class-kind nodes, and a class with no explicit constructor
+/// legitimately has nothing else to attribute the call to.
+fn attach_constructor_targets<'a>(
+    ctx: &EdgeContext<'a>,
+    mut targets: Vec<&'a NodeInfo>,
+    class_name: &str,
+) -> Vec<&'a NodeInfo> {
+    let mut seen_ids: HashSet<u32> = targets.iter().map(|t| t.id).collect();
+    let mut extra = Vec::new();
+    for target in &targets {
+        if target.kind != "class" {
+            continue;
+        }
+        if let Some(ctor) = resolve_constructor_target(ctx, target.file.as_str(), class_name) {
+            if seen_ids.insert(ctor.id) {
+                extra.push(ctor);
+            }
+        }
+    }
+    targets.extend(extra);
+    targets
+}
+
 /// Languages where bare `foo()` calls inside a class method are lexically scoped
 /// to the module, not the class — there is no implicit this/class binding.
 /// Mirrors `MODULE_SCOPED_BARE_CALL_EXTENSIONS` in call-resolver.ts.

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

@@ -279,8 +279,20 @@ fn handle_dart_import(node: &Node, source: &[u8], symbols: &mut FileSymbols) {
 }
 
 fn handle_dart_constructor_call(node: &Node, source: &[u8], symbols: &mut FileSymbols) {
+    // tree-sitter-dart crate versions structure the type name differently:
+    // 0.2 (crates.io, current) nests it under an intermediate `type` field —
+    // `new_expression type: (type (type_identifier)) arguments: (...)` —
+    // while npm's tree-sitter-dart 1.x (used by the WASM engine, see
+    // check-grammar-versions.mjs's tracked exception for this crate) puts it
+    // directly under `new_expression` — `(new_expression (type_identifier)
+    // (arguments))`. Try the direct shape first, then unwrap one `type` level.
     let name_node = find_child(node, "type_identifier")
-        .or_else(|| find_child(node, "identifier"));
+        .or_else(|| find_child(node, "identifier"))
+        .or_else(|| {
+            node.child_by_field_name("type").or_else(|| find_child(node, "type")).and_then(|t| {
+                find_child(&t, "type_identifier").or_else(|| find_child(&t, "identifier"))
+            })
+        });
     if let Some(name) = name_node {
         symbols.calls.push(Call {
             name: node_text(&name, source).to_string(),

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

@@ -12,6 +12,7 @@
 import { CALLABLE_SYMBOL_KINDS } from '../../../shared/kinds.js';
 import { computeConfidence, isSameLanguageFamily } from '../resolve.js';
 import {
+  attachConstructorTargets,
   isModuleScopedLanguage,
   resolveByGlobal,
   resolveByReceiver,
@@ -268,7 +269,10 @@ export function resolveCallTargets(
   typeMap: Map<string, unknown>,
   callerName?: string | null,
   importedOriginalNames?: ReadonlyMap<string, string>,
-): { targets: Array<{ id: number; file: string }>; importedFrom: string | undefined } {
+): {
+  targets: Array<{ id: number; file: string; kind?: string }>;
+  importedFrom: string | undefined;
+} {
   // Flagged dynamic calls use synthetic names like '<dynamic:eval>'. Short-circuit
   // so they never accidentally match a real symbol via lookup.byName.
   if (call.name.startsWith('<dynamic:')) {
@@ -280,14 +284,22 @@ export function resolveCallTargets(
   // the imported file's actual symbol is declared under the *original* name
   // (X) — look that up instead of the local alias the call site wrote (#1730).
   const targetName = importedOriginalNames?.get(call.name) ?? call.name;
-  let targets: ReadonlyArray<{ id: number; file: string }> | undefined;
+  // Tracks the name actually used to find `targets`. Usually equal to
+  // `targetName`, but a barrel hop that itself renames the export
+  // (`export { Foo as Bar } from './foo'`, resolved below) reports the name
+  // truly declared in the origin file — the constructor-attribution lookup
+  // must key on that name, not the call site's (possibly barrel-aliased)
+  // `targetName`, or it builds a qualified name that doesn't exist (#1892).
+  let resolvedClassName = targetName;
+  let targets: ReadonlyArray<{ id: number; file: string; kind?: string }> | undefined;
 
   if (importedFrom) {
     targets = lookup.byNameAndFile(targetName, importedFrom);
     if (targets.length === 0 && lookup.isBarrel(importedFrom)) {
-      const resolved = lookup.resolveBarrel(importedFrom, targetName);
-      if (resolved) {
-        targets = lookup.byNameAndFile(resolved.name, resolved.file);
+      const barrelResolved = lookup.resolveBarrel(importedFrom, targetName);
+      if (barrelResolved) {
+        targets = lookup.byNameAndFile(barrelResolved.name, barrelResolved.file);
+        resolvedClassName = barrelResolved.name;
       }
     }
   }
@@ -322,7 +334,15 @@ export function resolveCallTargets(
     }
   }
 
-  const resolved = [...(targets ?? [])];
+  let resolved = [...(targets ?? [])];
+  // #1892: `new ClassName()` / bare `ClassName()` (keyword-less languages)
+  // always resolves as a bare (no-receiver) call — augment any class-kind
+  // match with the class's own constructor method, if it declares one.
+  // Uses `resolvedClassName` (not `targetName`) so a barrel rename doesn't
+  // make the qualified constructor lookup miss (see comment above).
+  if (!call.receiver) {
+    resolved = attachConstructorTargets(lookup, resolved, resolvedClassName);
+  }
   if (resolved.length > 1) {
     resolved.sort((a, b) => {
       const confA = computeConfidence(relPath, a.file, importedFrom ?? null);

src/domain/graph/builder/helpers.ts

@@ -19,6 +19,7 @@ import type {
   PathAliases,
   SqliteStatement,
 } from '../../../types.js';
+import { isConstructorMethodSuffix } from '../resolver/strategy.js';
 
 export const BUILTIN_RECEIVERS: Set<string> = new Set([
   'console',
@@ -670,6 +671,14 @@ export function runChaPostPass(db: BetterSqlite3Database): number {
     if (dotIdx === -1) continue;
     const typeName = method_name.slice(0, dotIdx);
     const methodSuffix = method_name.slice(dotIdx + 1);
+    // #1892: a constructor call is never polymorphically dispatched — `new
+    // Circle()` always constructs exactly a Circle, never an Ellipse, even
+    // though Ellipse extends Circle and is separately instantiated
+    // elsewhere. Without this guard, a constructor-attribution edge
+    // (`caller -> Circle.constructor`) looks identical to a regular
+    // qualified-method call edge here, and CHA fabricates edges from the
+    // *original* caller to unrelated subclasses' constructors.
+    if (isConstructorMethodSuffix(typeName, methodSuffix)) continue;
     expandChaCall(
       source_id,
       typeName,

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

@@ -1349,14 +1349,7 @@ function resolveFallbackTargets(
   // either idiom commonly names a class. Applied once here, after every
   // fallback tier above, so it covers whichever tier produced the match.
   if (call.dynamicKind === 'value-ref') {
-    // `targets` is typed without `kind` when it flows straight through from
-    // resolveCallTargets (call-resolver.ts's declared return type omits it),
-    // but every underlying CallNodeLookup method actually populates it — the
-    // same gap the preQualifiedTargets cast above already works around. Kept
-    // as its own step (not folded into the filter callback) so the type-gap
-    // workaround and the actual filtering decision stay visually distinct.
-    const typedTargets = targets as ReadonlyArray<{ id: number; file: string; kind?: string }>;
-    targets = typedTargets.filter(
+    targets = targets.filter(
       (t) => t.kind === 'function' || t.kind === 'method' || t.kind === 'class',
     );
   }

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

@@ -44,6 +44,7 @@ import {
   patchDataflowResult,
 } from '../../../parser.js';
 import { computeConfidence } from '../../resolve.js';
+import { isConstructorMethodSuffix } from '../../resolver/strategy.js';
 import type { CallNodeLookup } from '../call-resolver.js';
 import { resolveDefinePropertyAccessorTarget } from '../call-resolver.js';
 import type { ChaContext } from '../cha.js';
@@ -880,6 +881,15 @@ function expandChaEdges(
     if (dotIdx === -1) continue;
     const typeName = method_name.slice(0, dotIdx);
     const methodSuffix = method_name.slice(dotIdx + 1);
+    // #1892: a constructor call is never polymorphically dispatched — `new
+    // Circle()` always constructs exactly a Circle, never an Ellipse, even
+    // though Ellipse extends Circle and is separately instantiated
+    // elsewhere. Without this guard, a constructor-attribution edge
+    // (`caller -> Circle.constructor`) looks identical to a regular
+    // qualified-method call edge here, and CHA fabricates edges from the
+    // *original* caller to unrelated subclasses' constructors. Mirrors the
+    // equivalent guard in builder/helpers.ts's runChaPostPass.
+    if (isConstructorMethodSuffix(typeName, methodSuffix)) continue;
 
     // BFS over the implementors map — handles multi-level hierarchies where
     // abstract/non-instantiated classes sit between the call-site type and