Merge remote-tracking branch 'origin/main' into fix/csharp-static-receiver-parity

Author: carlos-alm

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

@@ -116,12 +116,15 @@ export function resolveByMethodOrGlobal(
         : (typeEntry as { type?: string }).type
       : null;
 
-    // Handle inline new-expression receivers: `(new Foo).bar()` or `(new Foo()).bar()`.
-    // extractReceiverName returns the raw node text for non-identifier nodes, so `(new A).t()`
-    // produces receiver='(new A)'. Extract the constructor name directly.
-    // The regex intentionally restricts to uppercase-initial names ([A-Z_$]) as a heuristic
-    // to distinguish constructors (PascalCase) from regular functions — avoiding false positives
-    // on `(new xmlParser()).parse()` style calls which are rare in practice.
+    // Belt-and-suspenders fallback for inline new-expression receivers that
+    // extractReceiverName did not normalise (e.g. raw text leaked from an
+    // unhandled AST node type).  extractReceiverName already handles the common
+    // `new_expression` / `parenthesized_expression(new_expression)` shapes by
+    // returning the constructor name directly, so this branch is exercised only
+    // by future node types or constructs that fall through to the raw-text path.
+    // The uppercase-initial restriction ([A-Z_$]) is a heuristic to distinguish
+    // constructors (PascalCase) from regular functions and avoids false positives
+    // on `(new xmlParser()).parse()` style calls.
     if (!typeName && call.receiver) {
       const m = /^\(?\s*new\s+([A-Z_$][A-Za-z0-9_$]*)/.exec(call.receiver);
       if (m?.[1]) typeName = m[1];

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

@@ -852,6 +852,10 @@ function buildObjectRestParamPostPass(
               typeMap.set(orpb.restName, { type: pb.argName, confidence: 0.65 });
             }
           }
+          // restNames tracks every rest-parameter name found, regardless of whether the
+          // scoped key was already in typeMap.  This ensures the post-pass (below) processes
+          // all calls whose receiver matches a known rest binding — not just those whose
+          // typeMap entry was seeded in this iteration.
           restNames.add(orpb.restName);
         }
       }

src/extractors/javascript.ts

@@ -2676,6 +2676,25 @@ function extractReceiverName(objNode: TreeSitterNode | null): string | undefined
   if (!objNode) return undefined;
   const t = objNode.type;
   if (t === 'identifier' || t === 'this' || t === 'super') return objNode.text;
+  // `(new Foo(...)).method()` — extract the constructor name so the resolver can
+  // look up `Foo.method` directly without relying on a text-based regex heuristic.
+  if (t === 'new_expression') {
+    const name = extractNewExprTypeName(objNode);
+    if (name) return name;
+  }
+  if (t === 'parenthesized_expression') {
+    // Only one level of parentheses is unwrapped here. Doubly-nested parens
+    // (e.g. `((new Dog())).bark()`) and cast expressions inside parens
+    // (e.g. `(new Dog() as Animal).bark()`) fall through to raw-text handling
+    // below and are caught by the regex fallback in call-resolver.ts.
+    for (let i = 0; i < objNode.childCount; i++) {
+      const child = objNode.child(i);
+      if (child?.type === 'new_expression') {
+        const name = extractNewExprTypeName(child);
+        if (name) return name;
+      }
+    }
+  }
   return objNode.text;
 }
 

tests/benchmarks/regression-guard.test.ts

@@ -72,21 +72,22 @@ const NOISY_METRICS = new Set<string>(['No-op rebuild', '1-file rebuild', 'fnDep
  * than native and dominated by interpreter + GC overhead. The same ±10–20ms
  * of shared-runner jitter therefore lands as a much larger *percentage* swing
  * than on native. Empirically, WASM timing metrics on the publish runner swing
- * run-to-run by +27–67% on byte-identical code (No-op rebuild 15→25 = +67%,
+ * run-to-run by +27–71% on byte-identical code (No-op rebuild 15→25 = +67%,
  * Query time 32.5→44.2 = +36%, fnDeps depth 3/5 ~+31%, Full build 7664→9833
- * = +28%), which previously required a per-version KNOWN_REGRESSIONS entry for
- * each metric on every release — an endless whack-a-mole.
+ * = +28%, Build ms/file 18.7→32 = +71%), which previously required a
+ * per-version KNOWN_REGRESSIONS entry for each metric on every release — an
+ * endless whack-a-mole.
  *
  * Why this is safe: the native engine shares all extraction, resolution, and
  * query logic with WASM (the WASM path only swaps the parser/runtime), so any
  * *real* algorithmic regression shows up on the native numbers too — and native
  * keeps the strict 25% / 50% thresholds. Native is the canary. WASM timing only
  * needs to catch gross WASM-specific catastrophes (the 100–220% blowups seen in
- * v3.0.1–3.4.0), which 70% still flags, while absorbing the ≤67% shared-runner
+ * v3.0.1–3.4.0), which 75% still flags, while absorbing the ≤71% shared-runner
  * jitter. Size metrics (DB bytes/file) are engine-independent and excluded from
  * this widening via SIZE_METRICS below — they keep the strict threshold.
  */
-const WASM_TIMING_THRESHOLD = 0.7;
+const WASM_TIMING_THRESHOLD = 0.75;
 
 /**
  * Metric labels that measure size/count rather than wall-clock time. These are

tests/benchmarks/resolution/jelly-micro.test.ts

@@ -54,8 +54,53 @@ function discoverTests(): string[] {
     .sort();
 }
 
+/**
+ * Per-fixture minimum recall floors based on the baseline measured on origin/main
+ * (commit 784951d, June 2026).  Fixtures not listed here default to 0 — they
+ * produce 0% recall and can only improve, never regress below zero.
+ *
+ * Format: fixture-name → minimum recall fraction in [0, 1].
+ * Exact fractions shown in comments; stored as the corresponding percentage
+ * value so a single lost TP triggers a failure.
+ *
+ * Note: more1 was moved to the pts-javascript fixture set in #1383 and is
+ * no longer part of jelly-micro.
+ */
+const RECALL_FLOORS: Record<string, number> = {
+  accessors3: 1.0, // 1/1
+  arguments: 1.0, // 1/1
+  classes: 0.19, // 6/31
+  defineProperty: 0.5, // 3/6
+  fun: 1.0, // 4/4
+  generators: 1.0, // 9/9
+  'receiver-callee-mixup': 1.0, // 1/1
+  rest: 1.0, // 1/1
+  spread: 1.0, // 4/4
+  super: 0.38, // 5/13
+  super2: 0.4, // 2/5
+  super3: 1.0, // 3/3
+  this: 1.0, // 1/1
+};
+
 const tests = discoverTests();
 
+// Sanity-check: every RECALL_FLOORS key must match a discovered fixture name.
+// A mismatch means either a fixture was renamed or the key was mistyped, and
+// the regression floor would silently degrade to 0 without this guard.
+// Only enforce when the fixture directory is present (CI skips the whole suite
+// when fixtures are absent).
+if (tests.length > 0) {
+  const testSet = new Set(tests);
+  for (const key of Object.keys(RECALL_FLOORS)) {
+    if (!testSet.has(key)) {
+      throw new Error(
+        `RECALL_FLOORS key "${key}" does not match any discovered fixture in ${FIXTURES_DIR}. ` +
+          'Update the key or remove the stale entry.',
+      );
+    }
+  }
+}
+
 // Per-test results collected for summary
 const allResults: Record<
   string,
@@ -194,8 +239,8 @@ describe.skipIf(tests.length === 0)('Jelly Micro-Test Benchmark', () => {
           for (const e of fn) console.log(`    FN: ${e}`);
         }
 
-        // Soft gate: recall must be ≥ 0% (we don't gate yet — this benchmark is diagnostic)
-        expect(recall).toBeGreaterThanOrEqual(0);
+        const floor = RECALL_FLOORS[testName] ?? 0;
+        expect(recall).toBeGreaterThanOrEqual(floor);
       });
     });
   }

tests/benchmarks/resolution/resolution-benchmark.test.ts

@@ -97,6 +97,7 @@ const TECHNIQUE_MAP: Record<string, string> = {
   'pts-set': 'points-to',
   'pts-array-from': 'points-to',
   'pts-spread': 'points-to',
+  'pts-param': 'points-to',
   'define-property': 'ts-native',
 };
 
@@ -147,7 +148,9 @@ const THRESHOLDS: Record<string, { precision: number; recall: number }> = {
   python: { precision: 0.7, recall: 0.3 },
   go: { precision: 0.7, recall: 0.3 },
   java: { precision: 0.7, recall: 0.3 },
-  csharp: { precision: 1.0, recall: 0.8 },
+  // csharp 1.0/0.9: static receiver fix (#1395) ensures precision; var-declared instance typeMap
+  //   (implicit_type) lifts receiver-typed recall from 0/4 → 4/4 (#1396).
+  csharp: { precision: 1.0, recall: 0.9 },
   kotlin: { precision: 0.6, recall: 0.2 },
   // Lower bars — resolution still maturing
   rust: { precision: 0.6, recall: 0.2 },

tests/parsers/csharp.test.ts

@@ -151,4 +151,26 @@ public class Service : BaseService, IDisposable {
       expect.objectContaining({ name: 'User.Name', kind: 'property' }),
     );
   });
+
+  it('populates typeMap for var-declared instances (implicit type)', () => {
+    const symbols = parseCSharp(`public class Program {
+  void Run() {
+    var service = new UserService();
+    var repo = new UserRepository();
+    service.AddUser(null);
+  }
+}`);
+    expect(symbols.typeMap.get('service')).toEqual({ type: 'UserService', confidence: 0.9 });
+    expect(symbols.typeMap.get('repo')).toEqual({ type: 'UserRepository', confidence: 0.9 });
+  });
+
+  it('populates typeMap for explicitly-typed local variables', () => {
+    const symbols = parseCSharp(`public class Foo {
+  void Bar() {
+    UserService svc = new UserService();
+    svc.DoWork();
+  }
+}`);
+    expect(symbols.typeMap.get('svc')).toEqual({ type: 'UserService', confidence: 0.9 });
+  });
 });

tests/search/embedding-regression.test.ts

@@ -68,12 +68,23 @@ describe.skipIf(!hasTransformers)('embedding regression (real model)', () => {
     dbPath = path.join(tmpDir, '.codegraph', 'graph.db');
 
     // Build embeddings with the smallest/fastest model.
-    // Skip gracefully when HuggingFace rate-limits the model download (HTTP 429).
+    // Skip gracefully when HuggingFace rate-limits the model download (HTTP 429)
+    // or when the network is unavailable (ECONNRESET, ETIMEDOUT, ENOTFOUND,
+    // ECONNREFUSED, ERR_HTTP2_STREAM_CANCEL, ERR_HTTP2_SESSION_ERROR).
     try {
       await buildEmbeddings(tmpDir, 'minilm', dbPath);
     } catch (err: unknown) {
       const msg = err instanceof Error ? err.message : String(err);
-      if (msg.includes('429')) {
+      const code = (err as NodeJS.ErrnoException).code ?? '';
+      const isNetworkError =
+        msg.includes('429') ||
+        code === 'ECONNRESET' ||
+        code === 'ETIMEDOUT' ||
+        code === 'ENOTFOUND' ||
+        code === 'ECONNREFUSED' ||
+        code === 'ERR_HTTP2_STREAM_CANCEL' ||
+        code === 'ERR_HTTP2_SESSION_ERROR';
+      if (isNetworkError) {
         rateLimited = true;
         return;
       }