11 commits

Author	SHA1	Message	Date
Abhigyan Patwari	36e16434ea	fix(php): type locals from namespaced-function factory calls (#3498) (#3662) ... * fix(php): type locals from namespaced-function factory calls `namespace App; use App\Mod as rp; $x = rp\make(); $x->m()` left `$x` untyped although `make` is declared `: C` in `namespace App\Mod`, and the inline `rp\make()->m()` recorded a drop. The query matched only an unqualified callee (`function: (name)`), so a `qualified_name` callee minted neither a call site nor a result binding; `\App\Mod\make()`, `Mod\make()` and `namespace\make()` failed the same way, and nothing could have expanded the path anyway: functions were never indexed by fully qualified name. - A `qualified_name` / `relative_name` callee is captured as a free call (tail name, written path as `@reference.qualified-name`) and as a call-result binding that keeps the whole path, leading `\` included. - New `php/qualified-function.ts` expands that path by PHP's name rules: `\` is absolute, `namespace\` is the file's namespace, and a qualified head goes through the file's class/namespace `use` table, else the file's namespace. It indexes every `Function` def by lower-cased FQN per pass and answers only when exactly one def declares the name. - PHP implements `resolveQualifiedCallee` and `resolveQualifiedFreeCall` with that one resolution, so a call's type and its CALLS edge agree. `Qff\Decoy\make` in the fixture is never picked. - A receiver bound to an in-program namespaced function with no return type (`$x = rp\untyped()`) now records a `receiver-unresolved` drop. A full lang-resolution A/B against the parent removes no CALLS/ACCESSES edge and no drop. It adds 20 edges, all inside the new php-qualified-function-factory fixture, and 2 drops (its two untyped sites). The PHP capture golden gains the new fixture only. Existing fixtures' digests are byte-identical. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * fix(php): bind use-function imports outside PSR-4 by fully qualified name `use function App\Mod\make; $x = make(); $x->m()` typed nothing, and the call itself had no CALLS edge, when `make` is declared outside any PSR-4 path: loaded through composer `autoload.files`, or in a project with no composer.json. Import resolution finds a function only through a PSR-4 directory or a file named after it, so the import bound nothing (or, with a PSR-4 directory that holds other files, resolved to one that declares no `make`). In the new fixture, `namedCall` even picked up another `make`'s return type, mirrored by name from a sibling file, and emitted a wrong `QffGadget.ping` edge. After namespaces are known, a `use function A\f` whose module scope binds nothing for its local name is bound to the one workspace function named `A\f`, through the same per-pass FQN index as qualified callees. The fully qualified name is the function's identity, so this guesses nothing; a resolved import or a local declaration is left alone, and two declarations of one name bind nothing. The IMPORTS edge is unchanged: finalize has no namespaces yet. Lang-resolution A/B against the parent: one wrong edge removed (`namedCall -> QffGadget.ping`), two correct fixture edges added (`namedCall -> make`, `namedCall -> QffWidget.ping`), and four correct edges the combined corpus lacked because its merged composer configs map `App\` to many fixtures: php-calls `create_user -> write_audit`, php-overload-dispatch `run -> format_text` and `run -> format_text_padded`, php-use-function-const `Calculator.process -> formatName`. Each FQN is declared once in the corpus. Drops are unchanged. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * test(bench): rebaseline php captures and receiver counts - receiver-resolution: the new php-qualified-function-factory fixture's two untyped sites (`$x = rp\untyped(); $x->ping()` and inline `rp\untyped()->ping()`) are each one call drop: call drops 154 -> 156, all kinds 224 -> 226. No other drop moves in a same-corpus A/B, and shape-arm cells are unchanged. - scope-capture (php): corpus growth only. The query now captures qualified function callees, but no existing fixture has one: parking the new fixture reproduces the prior fingerprint byte-for-byte. It adds 96 capture groups and 9 fixture entries. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * fix(php): fail closed on qualified calls the path cannot resolve A qualified call site was named by its tail (`count` for `\count($x)`), so when `resolveQualifiedFreeCall` refused the path, the free-call pass fell through to its simple-name tiers and could bind a same-named function in the caller's namespace: `\count($x)` -> a user `Qff\Ext\count`, `\Vendor\Pkg\make()` -> `Qff\Ext\make`, and a twice-declared `\Qff\Dup\make()` the same way. Before this branch such calls minted no site at all, so these were new wrong edges. The site is now named by its whole written path, the same text it carries as `@reference.qualified-name`. The provider hook still resolves it by PHP's name rules. Every simple-name tier (scope chain, implicit `this`, global unique-name fallback) looks up a name with a `\` in it and finds nothing, so a refused path (builtin, uninstalled package, ambiguous name, multi-namespace file) leaves the call unresolved. This change is PHP-only. Lang-resolution A/B against the parent: no edge or drop removed. Added edges: the three new fixture functions' `new QffWidget()` calls. No edge from builtinCall, vendorCall or ambiguousCall. Versus the pre-branch base: 29 edges added (25 in the fixture, plus the 4 `use function` edges from 4781ace51), 0 removed, 2 drops added. Receiver counts unchanged. The PHP golden changes only the new fixture's files. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * test(bench): rebaseline php captures for fail-closed qualified calls scope-capture (php): a qualified function call site is now named by its whole path, and the php-qualified-function-factory fixture gains four files (src/Ext/Calls.php, src/Ext/Shadows.php, lib/dup-a.php, lib/dup-b.php). Only that fixture moves. Parking it reproduces the pre-branch fingerprint byte-for-byte. fixture_count 152 -> 156, capture_groups_fp 2338 -> 2381. receiver-resolution is unchanged. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> * fix(php): preserve qualified identifier bytes Keep PHP labels and ASCII-only name matching through qualified factories. Decline names shortened by native non-ASCII whitespace parsing. Correct fixture comments and give parameterized cases unique audit IDs. * fix(php): preserve reviewed merge resolutions * test(php): align golden with fixture comment The corrected factory annotation comment is included in captured function text; keep its fine golden digest aligned with the reviewed fixture. --------- Co-authored-by: Gergo Magyar <gergomagyar0@gmail.com> Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-22 18:55:04 +00:00
Gergő Magyar	8fa8e64388	fix(rename): extend safe refactoring and flow coverage across languages (#3557)	2026-10-13 08:38:17 +03:00
Gergő Magyar	999cc9f913	fix(deps): upgrade native tree-sitter to 0.25.1 (#3531) ... * fix(deps): upgrade native tree-sitter to 0.25.1 * fix(tree-sitter): preserve sync loading and update verified capture baselines Route C# scope queries through the synchronous native grammar loader so the compiled analyze module remains require-compatible on Node 22.18. Refresh only the audited empty-Python-module and renamed-PHP-fixture captures, and pin the runtime assertion to 0.25.1. Validated 479 targeted tests, all 16 scope-capture benchmark cases, Python capture/import guards, compiled C# worker parsing, build, typecheck and formatting. Performance budgets are unchanged. * fix(tree-sitter): refresh upstream vendors and preserve parser semantics * fix(ci): refresh prebuilds and support Windows ARM Refresh macOS, Linux ARM, and Windows x64 grammar binaries from the successful native CI builds. Pin node-gyp 12.4.0 so the Windows ARM jobs recognize Visual Studio 2026. Use local Git filtering for E2E to avoid PR-files API timeouts on generated parser diffs. Validation: 143 focused tests, Actionlint, and all 16 scope-capture benchmark checks passed. Full npm test run started; native database suites still running. * fix(ci): refresh Windows ARM grammar prebuilds Import all seven Windows ARM grammar artifacts from successful native build run 37965761760. Artifact filenames and SHA-256 hashes verified; all 42 native build jobs passed. Validation: 31 prebuild coverage tests passed. * fix(bench): stabilize scope capture timing guard Warm each input size seven times and use 21 median samples while retaining isolated timing blocks. Yield between languages so native finalizers release allocations outside the measured sections. Keep all fixture sizes, fingerprints, scaling formulas, and budgets unchanged. Validation: all 16 language guards passed with a 2 GB heap limit (1.38 deep-chain ratio; 1518 MB peak RSS). Linear and quadratic controls passed their expected guard outcomes. Formatting and graph change analysis passed. Full npm test is running without failures so far. * fix(parser): reduce TypeScript capture traversal cost * fix(test): await parser worker readiness before teardown * fix(parser): load C# synchronously in workers * fix(grpc): resolve native proto detections against their own file With the native proto grammar active, sibling .proto files that declare the same short service name under different packages tied in the directory-based resolveProtoConflict heuristic and both providers were dropped. A proto-origin detection already knows its defining file, so use that file's entry before falling back to the heuristic. Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com> * ci(packaging): assert native grammars load from the installed tarball The packaged-install smoke only ran `gitnexus --version`, so a grammar that failed to load from the published package (bundled runtime, patched peer manifests, vendored prebuilds, C# sync loader, Protobuf wrapper) would ship silently; the dev-tree ABI smoke also accepts vendored grammars that report unavailable. Parse a sample for every registered grammar plus the native Protobuf plugin from the installed package, on the main thread and in a worker thread. Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com> * ci(tree-sitter): track compatibility workarounds instead of 0.25 readiness The daily readiness report still targeted tree-sitter@0.25.0, so after the upgrade it would keep reporting "Blocked" and never close its tracking issue. Repurpose it to track what we carry for the bundled runtime: derive the target from the package.json pin, list each pack-time peer patch from prepare-tree-sitter-bundle.cjs with its drop condition (bump, wait for an upstream release, transitive, or intentionally pinned), and reword the buckets. The workflow adopts the issue opened under the old title. Also update the grammar-update-monitor header and auto-PR text, which still described the 0.21.1 runtime and a tree-sitter-c hold. Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com> * test(dart): assert both nested labels target the loop; fix Zig call-shape doc The nested-label CFG test only jumped to `outer` and checked reachability, which still passes when a jump is retargeted to the inner loop (its exit reaches the outer header). Jump to both labels and assert the exact `continue` edges; dropping the inner label now fails the test. Update the Zig callable-flow comment: call_expression now wraps actuals in a required `arguments:` field. Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com> --------- Co-authored-by: Codex <codex@openai.com> Co-authored-by: Gergo Magyar <gergomagyar0@gmail.com> Co-authored-by: Claude Opus 5.5 (1M context) <noreply@anthropic.com>	2026-10-10 13:07:59 +03:00
Parafee41	4ccba12004	fix(scope): keep nested declarations out of module bindings (#3502)	2026-10-08 11:05:41 +03:00
Gergő Magyar	911151e230	fix(resolution): resolve Go pointer-receiver calls, and report the program boundary instead of hedging (#2766) (#2782)	2026-08-01 22:42:18 +01:00
Gergő Magyar	27ab37c432	feat(resolution): type receiver chains from AST structure across all 14 languages (#2708) + epistemic lower-bound (#2744) (#2747)	2026-07-31 07:12:57 +01:00
Gergő Magyar	ed8ab1c246	fix(scope-resolution): resolve callable reference flows (#2437) (#2522) ... * docs(plans): add provider-hook value-refs plan (#2437) Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * docs(plans): deepen #2437 plan to USES + property-dispatch design Design revised after prior-art research (Kythe ref vs ref/call, Joern METHOD_REF, Feldthaus field-based call graphs, CodeQL impliedReceiverStep): registration sites emit reference-class USES, invocation is recovered by a field-based property-dispatch pass synthesizing CALLS at member-call sites. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * feat(scope-resolution): model provider-hook value references (#2437) Functions referenced as object-literal property values (provider hooks like emitScopeCaptures: emitCppScopeCaptures) previously produced no edge at all, so impact/context reported a false-safe 0 upstream dependents. Two coordinated halves, per prior art (Kythe ref vs ref/call, Joern METHOD_REF, Feldthaus ICSE'13 field-based call graphs, CodeQL impliedReceiverStep): - Registration -> USES: new ReferenceKind 'value-ref'; TS/JS queries capture pair values and shorthand properties (with @reference.property-key); emitted as a reference-class USES edge, reason 'scope-resolution: value-ref'. Resolution is callable-gated so plain values emit nothing. - Dispatch -> CALLS: new shared pass emitPropertyDispatchCalls synthesizes CALLS (reason 'property-dispatch', confidence 0.7, per-key fan-out cap 32 calibrated on this repo's 16-provider hook tables) from member-call sites to every function registered under the same property key. Deviation from plan: the pass owns value-ref resolution entirely via the post-finalize findCallableBindingInScope walker — the shared registries only see pre-finalize local bindings, so imported hooks (the c-cpp.ts case) were unresolvable through lookupForSite; Reference.propertyKey passthrough dropped as unnecessary. SCHEMA_BUMP 13 -> 14: ParsedFile gains value-ref sites + propertyKey. Verified end-to-end: impact(emitCppScopeCaptures, upstream) now reports 8 impacted / HIGH with extractParsedFile (true dispatch caller) at d=1 via property-dispatch and the c-cpp.ts registration via USES. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * test(scope-resolution): cover value-ref registration and property dispatch (#2437) Integration: same-file/cross-file/aliased/shorthand registrations emit USES; non-callable and destructuring values emit nothing; dispatch sites gain property-dispatch CALLS (incl. JS twins and per-language partitioning); fan-out-capped keys are dropped entirely; factory-call values unchanged. Unit: capture-shape pins for @reference.value-ref + @reference.property-key. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * fix(scope-resolution): surface dropped property-dispatch keys in stats (#2437) Review finding: skippedKeys was returned but discarded — a hook table larger than the fan-out cap silently reopened the #2437 gap for those keys. Log dropped keys and fold value-ref USES + dispatch CALLS into referenceEdgesEmitted. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * docs(plans): add callable reference-flow implementation plan * fix(scope-resolution): close property-dispatch review gaps * feat(scope-resolution): add callable flow facts * feat(scope-resolution): resolve callable value flow * feat(scope-resolution): resolve callable references across providers * fix: harden callable reference flow resolution * fix(scope-resolution): preserve callable binding semantics * docs(plans): add pr-2522-review-fixes plan Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * fix(storage): bump INCREMENTAL_SCHEMA_VERSION for callable-value-flow edges Callable-value-flow CALLS/USES edges (#2437) can connect two files whose content did not change, but the incremental write set only covers changed files — a top-up against a pre-v7 index would silently omit the new edges for every unchanged file pair, indefinitely. Force the one-time full re-analyze (review finding 1, #2522). Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * fix(storage): sanitize callable-flow sites per-site at load, log drops The load-time validator rejected the WHOLE ParsedFile when one site was malformed or over-bound, with no logging — and C++ legitimately emits empty-string parameterTypes entries ('' = unknown, the ReferenceSite.argumentTypes convention) for cv-only/ERROR-recovered types, so real repos fell into a permanent, silent warm-cache-miss reparse loop through the #1983-sensitive main-thread path (review finding 7, #2522). Now: '' entries are valid in type arrays; a malformed/over-bound site drops only itself (counted, warned once per load); only non-array garbage — evidence the serialization itself is untrustworthy — rejects the file. Deviation from plan §6 wording: validator-side tolerance replaces emit-side clamps — smaller diff, same asymmetry closed at the single chokepoint. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * fix(scope-resolution): keep declarations in the union for reassigned callable cells The binding-lookup suppression for fact-constrained cells was wholesale: reassigning a declared function through its own name (greet = other; greet()) deferred the call to the solver, which then refused the lexical lookup that resolves the declaration — an unresolvable RHS yielded zero CALLS for a call that resolved pre-flow (review finding 8, #2522). Suppression now applies only to cells bound by FORMAL facts — its actual purpose (a parameter whose grammar emits no declaration binding must not adopt a same-named outer function). Copy/alias/store/load destinations keep their declaration as an inclusion seed (Andersen-style union). Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * fix(scope-resolution): count forfeited deferred sites in the budget-bailout warning On work-budget exhaustion the deferred invoke sites end the run with zero CALLS — free-call fallback and reference emission already skipped them — but the warning said 'ordinary graph emission remains untouched', which is false for exactly those sites. The warning context now carries the unresolved deferred-site count and the comment states the real cost (review finding: budget-bailout honesty, #2522). Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * feat(scope-resolution): surface dropped property-dispatch keys in stats and warn payload The over-cap warning carried only a count; the dropped key NAMES were discarded and RunScopeResolutionStats had no field, so the PR-body claim 'includes them in resolver statistics' was unimplemented (review finding, #2522; reviewer ask on the fan-out cap). The warn payload now names up to 20 dropped keys and the stats carry propertyDispatchSkippedKeys. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * refactor(scope-resolution): drop producer-less ownerQualifiedName from formal sites No capture emitter anywhere produces @callable-flow.owner-qualified-name — the solver branch consuming it was unreachable in production, yet the field was typed, parsed, validated, and unit-tested with hand-built input (review finding 16, #2522; YAGNI). Re-add with a real producer if C++ qualified member declarators ever need it. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * refactor(scope-resolution): drop dead callable-flow knobs CallableFlowPassingMode 'callable-object' had no producer and no consumer distinguishing it, and CallableFlowCaptureOptions.extractCallArguments had no language providing it (unlike its live sibling extractCallCallee) — review finding 17, #2522 (YAGNI). The invocation-kind 'callable-object' is a different, live concept and stays. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * fix(ingestion): bind subscripted callable cells to the container, not the index terminalIdentifier iterates children in reverse, so tbl[i] = handler seeded the INDEX variable's cell (polluting a same-named formal) and tbl[i](7) looked up the callee under i in a different scope — no join, no CALLS edge for the classic function-pointer-array dispatch (review finding 12, #2522). Subscript nodes now recurse into their container field only, in both bindingIdentifier and terminalIdentifier, across the fielded grammars (C/C++/JS/TS/Python/Go/Java). Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * fix(ingestion): make cross-function file-scope callable bindings resolvable Two stacked gaps killed the canonical C callback-registration pattern (fp assigned in init(), called in run()) — the exact #2437 false-safe this PR exists to fix (review finding H1, #2522): 1. isVisibleValueBinding only consulted assignment regions and formals, so a call in a function OTHER than the assigning one emitted no invoke fact. A declared callable-typed binding is now a value binding wherever its declaration is visible (visibleCallableSignature). 2. The C scope query had no @declaration.variable pattern for function- pointer declarators — void (*fp)(int); created no scope-tree binding, so the seed (init) and invoke (run) cells canonicalized to different keys and never joined. Both bare and initialized forms now bind. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * fix(c): detect variadic parameters via the named variadic_parameter node tree-sitter-c materializes '...' as a named variadic_parameter node; the anonymous-token checks never matched, so variadic function-pointer signatures were emitted with a wrong fixed arity and no '...' sentinel (review finding, #2522). C++ is unaffected ('...' stays an anonymous token there); the token checks remain for such grammars. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * fix(ingestion): emit invoke facts for field-stored callable member calls The C ops-vtable pattern (o->run = handler; o->run(1)) captured the store but never the call — the member path in emitCallFacts bailed for languages without protocol methods, and the value-binding index recorded the member store under the OBJECT's name ('o'), not the member's ('run') (review finding 11/M3, #2522). Member destinations now also record their terminal member name, and a member call whose name-cell has a visible store emits an indirect invoke — gated on the store so plain accessor calls (map.get) stay inert. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * fix(cpp): disambiguate (obj->*ptr)() ERROR recovery by token order tree-sitter-cpp groups the recovered '->*' two ways depending on error-recovery cost (identifier lengths): [identifier, ERROR '->*m'] or [ERROR 'obj->*', identifier]. The recovery assumed the first shape, so the second silently swapped receiver/member and dropped the call site — the committed test passed only by name luck (review finding H2, #2522). The identifier's position relative to '->*' inside the ERROR now decides roles. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * fix(cpp): class members are never file-local in hasFileLocalCallableLinkage The name-keyed file-local set is populated from every static declaration, so an in-class 'static void make();' (external linkage — in-class static means no-instance) and any member sharing a name with a static free function were over-marked, refusing legitimate cross-file declaration/definition joins (review finding 13/M2, #2522). Method and Constructor defs now bypass the name-set, per the hook's own linkage-only contract. Deviation from plan step 13: the regression is a unit-level contract pin rather than an end-to-end join test — C++ merges out-of-line member definitions onto the member node by qualified identity, so the graph shape cannot discriminate the join refusal for members. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * fix(cpp): classify parameter passing mode from the declarator chain only A whole-subtree scan for reference_declarator inverted copy vs alias: void reg(void (*cb)(int& out)) marked the by-value pointer cb as 'reference' because of the NESTED parameter's int&, making the solver back-propagate formal targets into every caller's argument cell — alias semantics for a copy (review finding 14/M5, #2522). The chain walk never descends into nested parameter lists; a reference anywhere ON the chain (int& x, void (*&cb)(int)) still aliases. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * fix(ruby): bare identifiers are calls, not callable references Ruby parses a receiver-less zero-arg method call identically to a variable read, so 'action = process' — which CALLS process and stores its return — seeded action with the callable and minted a wrong CALLS edge from any dispatch through it, confirmed end-to-end (review finding 15/HIGH, #2522). New provider knob bareNamesAreCalls: a bare name that is not a provably local value binding and not an explicit reference form (method(:x), lambda/proc) emits no flow fact, on both the assignment and argument paths. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * fix(go): pair multi-value := positionally instead of cross-wiring The shared field fallback took the FIRST LHS identifier and the LAST RHS identifier of Go's expression_list pair, cross-wiring 'a, b := f, g' and synthesizing a garbage comma-joined qualified name — the real relationships were silently dropped (review finding 16, #2522). extractAssignment may now return multiple pairs; Go pairs list entries positionally and emits nothing for a length mismatch (multi-return call RHS). Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * fix(java): drop get/test from callableProtocolMethods 'get' and 'test' collide with ubiquitous non-functional-interface APIs (Map/List/Optional/Future.get), so every ordinary container access emitted a spurious callable-object invoke fact — high-volume misleading graph facts with a cross-wiring risk on receiver-name reuse (review finding 17, #2522). Supplier.get/Predicate.test dispatch is deliberately traded away until the check can gate on the receiver's declared type. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * fix(rust): pin the qualified-name no-degrade guard as a hard invariant Rust's scoped_identifier callable-reference capture over-includes unit enum variants and associated constants (Shape::Square seeds as if callable); they stay edge-free only because resolveSeedCandidates refuses to degrade an unresolved qualified name to a simple-name lookup (review finding 18, #2522). Capture-side type filtering would false-negative on tuple-variant constructors, so the guard IS the contract: documented as a hard invariant (Go's mis-shaped multi-value forms also rely on it) and pinned end-to-end. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * fix(php): remove nonexistent optional_parameter node type tree-sitter-php has no 'optional_parameter' — defaults ride on simple_parameter — so the entry was dead weight the #1920 literal gate does not cover for capture-option Sets (review finding 19, #2522). Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * fix(cobol): detect procedure pointers on fixed-format sources Two stacked defects made the feature a no-op on classic sequence-numbered fixed format (review finding 20/H3, #2522): 1. parseDataItemClauses' USAGE alternation knew POINTER but not PROCEDURE-POINTER/FUNCTION-POINTER, so the dataItems filter was dead. 2. The raw-line fallback scanned UNCLEANED text, where the sequence number satisfied the leading digits and the LEVEL NUMBER got captured as the pointer name. It now scans preprocessed lines and requires a letter- initial name (COBOL data names must contain a letter). 161 COBOL preprocessor/copy-expander tests stay green; free-format matrix case unchanged. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * fix(cobol): skip comment lines in SET seed/copy scans A commented-out SET (indicator-column '*'/'/' or free-format '*>') produced a live seed and a false CALLS edge from dead code (review finding 21/M1, #2522). The scan now skips indicator-column comment lines and strips inline '*>' tails before matching. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * docs(architecture): document callable-flow-only mode and skipped-key reporting The Callable-value flow section omitted scopeResolutionEdgeMode: 'callable-flow-only' — a real emit-pipeline branch that suppresses all ordinary emission for standalone providers (review finding 22, #2522) — and predated the skipped-key names/stats surfacing. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * docs(scope-resolution): correct value-ref resolution attribution and stale pdg-gating comments The value-ref contract comment claimed MethodRegistry resolution — the mechanism is the post-finalize findCallableBindingInScope walker owned by emitPropertyDispatchCalls (resolveReferenceSites skips these sites). Three 'only under --pdg' calleeIdSink comments were falsified by the #2437 gating change (callee-id-sink.ts's header was updated; these copies were missed). Review finding 23, #2522. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * test(ingestion): direct unit coverage for synthesizeCallableFlowCaptures The 1,100-line shared synthesizer had no test naming it — only downstream consumers were covered (review finding 24, #2522). Pins seed/invoke/ formal/argument emission, subscript container binding, store-gated member invokes, produced-value guards, and the bareNamesAreCalls knob over a minimal options object so assertions target the synthesizer's own semantics. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * test(resolvers): deepen shallow-language coverage; fix Kotlin/Swift reassignment gaps it exposed Adds the COBOL SET x TO y copy-branch scenario and conditional-assignment scenarios for Kotlin, C#, Swift, and Dart (10 languages previously had one generic case each — review finding 25, #2522). The new scenarios exposed two real capture gaps, fixed here: - tree-sitter-kotlin's 'assignment' node is fieldless, so nested reassignments (chosen = ::target inside a block) produced no flow facts; Kotlin's extractAssignment now decomposes it positionally. - tree-sitter-swift fields its assignment as target:/result:, neither in the shared fallback's field lists; both added. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * test(infra): literal-validation gate for callable-capture option Sets The #1920 gate validates query literals and exported configs but not the module-private *_CALLABLE_CAPTURE_OPTIONS Sets consumed by the shared synthesizer — a typo'd node type silently captures nothing (PHP shipped a dead 'optional_parameter'; review finding 26, #2522). Every <key>NodeTypes Set literal is now validated against its language's grammar; name-carrying sets (callableProtocolMethods, memberPointerOperators) are deliberately outside the contract. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * test(storage): centralize corrupt-fixture casts into makeStoreEntry The callable-flow store tests scattered 'as unknown as' double-casts per fixture (review finding 27, #2522; standing no-as-any rule). One typed helper now owns the single controlled escape hatch for building malformed serialization-boundary payloads. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * chore(bench): refresh capture fingerprints after review fixes python-scope: the committed baseline (8d5c3699) never matched this branch's code — CI's benchmarks arm was red on the PR head (review finding 2/HIGH, #2522); regenerated (a99e69ab), scaling 1.04 in budget. scope-capture: ruby/cpp/swift/java/kotlin drifted from the review-fix commits (bare-name suppression, passing modes + ->* recovery, assignment fields, protocol narrowing, positional assignment); all 14 languages re-verified PASS with ratios <= 1.18 against the 1.5 budget. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * chore(docs): untrack docs/plans working documents docs/ is gitignored (local working docs); the plan files were force-added past the ignore. Untracked from the index only — they stay on disk. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * test(golden): regenerate captures goldens after callable-flow review fixes The per-language digest guards (csharp/go/php/python/ruby/rust/swift) locked the pre-fix capture output; the review-fix series intentionally changed it — store-gated member invokes, subscript container binding, Ruby bare-name suppression, Swift assignment fields, positional pairing. Regenerated with UPDATE_GOLDEN=1; clean verification run 59/59; all other parity/golden guards (pipeline-graph, spring-route, python parity) pass untouched at 33/33. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * fix(ingestion): prototypes are callees, not callable value cells The cross-function visibility fix indexed EVERY signature-bearing declaration as a value binding — including plain function/method prototypes (void f(int);). Every call to a declared function then became an indirect invoke, and with emitCanonicalInvokeReference (C/C++) minted a free-call reference that resolved through the registry, bypassing the precise passes' two-phase/ambiguity/subobject suppression — eight phantom CALLS edges in the cpp resolver suite on CI. Only declarations whose binding identifier sits under a pointer/ parenthesized declarator (callable-typed variables like void (*fp)(int);) create value cells now. cpp resolver suite 331/331; callable-value-flow + C/C++ suites 181/181 (the cross-function fp regression still passes); cpp fingerprint rebaselined, both bench gates PASS. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> --------- Co-authored-by: Claude Fable 5 <noreply@anthropic.com>	2026-07-17 17:20:02 +01:00
Eva	34955b57f6	fix(php): resolve symbol-named PSR-4 imports	2026-07-14 13:12:33 +07:00
Sparsh	7cbc544299	fix(php): import decomposition, enum cases, anonymous class scope — F53,F54,F55 (#1931) (#1989) ... * fix(php): import decomposition, enum cases, anonymous class scope — F53,F54,F55 (#1931) * chore: fix unused imports, format, rebuild gitnexus-shared for macro type * chore(bench): update PHP scope-capture baseline to CI-computed hash * fix(php): reviewer fixes — grouped prefix, dead code removal, test precision * feat: add F55 anonymous class pipeline test * chore: fix format and benchmark baseline * chore: regen PHP golden after F53/F54/F55 query changes * chore: remove pipeline test, add grouped-prefix test, update fingerprint * chore: remove unused beforeAll and path imports --------- Co-authored-by: Gergő Magyar <gergomagyar@icloud.com>	2026-06-04 12:57:38 +01:00
Gergő Magyar	0fc0211d26	fix(ingestion): migrate all languages' inheritance to scope-resolution on the worker path (#1951) (#1956)	2026-06-01 17:04:27 +01:00
Gergő Magyar	d1d2a64d0f	perf(ingestion): linearize scope-capture across all languages + Python import resolution (O(n²)→O(n)) (#1918) ... * bench(python-scope): build-free measure harness + baseline fingerprint for emitPythonScopeCaptures ce-optimize scaffolding for the python-scope-capture run. Mirrors the Go scope-capture harness (#1848): imports the .ts hotpath via tsx, times emitPythonScopeCaptures on a synthetic DAO source at 250/800 entities, and pins an order-independent sha256 capture fingerprint over the whole lang-resolution/python-* corpus + a fixed 20-entity DAO as the correctness gate. Baseline (current code) is O(n^2): 250->800 entities (3.2x) -> 10.7x time (1062->11343ms), scaling_ratio 3.34. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> * optimize(python-scope-capture): thread captured nodes to kill O(n^2) findNodeAtRange re-walks emitPythonScopeCaptures re-derived each tree-sitter match's AST node via findNodeAtRange(tree.rootNode, ...) on every match, scanning all of root's named children per call -> O(matches x rootChildren) ~ O(n^2). The same #1848 bug Go had (fixed in eaf0a305), mirrored in Python's captures.ts. Thread the query-captured SyntaxNode (c.node) through a parallel tag->node map and use it directly for all three sites (import / @scope.function / @declaration.function). The Python scope query captures the full statement/definition node, so the captured node IS the one the old code re-derived by range — no ancestor walk needed (simpler than Go's import case). Output is byte-identical: an order-independent sha256 capture fingerprint over all 188 lang-resolution/python-* fixtures + a 20-entity DAO is unchanged. 800 entities: 11343ms -> 319ms (35.5x); 250: 1063ms -> 95ms (11.2x); scaling_ratio 3.34 -> 1.05 (quadratic -> linear). tsc clean; 291 python scope-resolution + resolver tests pass. Adds a golden capture-parity test (forward-drift guard across the python-* corpus + DAO shape) and a non-gated O(n^2) regression tripwire (400-entity source, 346ms vs a 10s budget). Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> * optimize(python-scope-capture): index Python import resolution to kill O(imports x files) scans resolvePythonImportTarget's fallback path scanned the entire repo file set on every unresolved/external dotted import — once in hasRepoCandidate (package gate) and once in resolveAbsoluteFromFiles (suffix match) — giving O(imports x files) ~ O(n^2) in the resolution phase (audit follow-up to the capture-phase #1848 mirror). Add a per-file-set index (byBasename buckets + .py dir-prefix set + normalized path set), memoized on the allFilePaths Set via a WeakMap so it is built once per run and reused across every import. The two O(files) scans become O(1)/O(bucket) lookups. The shared buildSuffixIndex is deliberately NOT reused: it keeps only a single path per suffix (longest wins) and cannot reproduce Python's exact fewest-segments-then-lexicographic tie-break across all candidates (see the import-target.ts:72 rationale) — so a purpose-built index is used instead. Output is identical: a resolver-output fingerprint over 10,021 cases (exhaustive branch matrix — tie-breaks, gating, collisions, windows paths — plus a 400-repo deterministic fuzz) is byte-for-byte unchanged (e6ec1a59...). Worst-case scaling (k imports x k files): 500/1000/2000/4000 went 25/62/231/899ms -> 1.2/2.9/6.7/10.7ms (84x at 4000, quadratic -> linear). tsc clean; 303 python scope-resolution + resolver tests pass; adds a 10-case parity guard pinning the tie-break / gating / collision semantics the index must preserve. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> * fix(python): land the import-index reuse on the registry-primary path (PR #1918 P1) The PythonFileIndex WeakMap is keyed on allFilePaths Set identity, but pythonScopeResolver.resolveImportTarget wrapped the orchestrator's stable run-level set in `new Set(allFilePaths)` per import, handing a fresh key to every import — so the index rebuilt on every import and the O(imports x files) cost this index removed persisted on the production path (PR #1918 review P1). Thread ReadonlySet<string> through the resolver chain (PythonResolveContext, getPythonFileIndex, the WeakMap key, resolveAbsoluteFromFiles, hasRepoCandidate, resolvePythonImportInternal, tryResolveWithExtensions — all read-only) and drop the per-import copy so the stable set reaches the WeakMap key. Mirrors the C# counterpart (csharp/import-target.ts), which already keys on ReadonlySet. Guard it deterministically: an ungated index-build counter (index-stats.ts) + a production-path integration test that drives pythonScopeResolver over 300 imports on a stable set and asserts the index is built ONCE (was 300 pre-fix). tsc clean; resolver-output fingerprint unchanged (e6ec1a59); 369 python scope-resolution + resolver tests pass. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> * perf(python): index only .py files in the import-resolution index (PR #1918 P3b) getPythonFileIndex pushed every workspace file into byBasename (and normSet), but Python import resolution only ever queries .py paths — module <seg>.py, package <seg>/__init__.py, and .py directory prefixes. Non-.py files (.ts, .go, …) could never match any lookup, so they were pure dead weight in the index on polyglot monorepos. Skip non-.py files at the top of the index builder. dirPrefixes was already .py-gated; this extends the same guard to byBasename and normSet (both also .py-only consumers), so it is behavior-preserving. Resolver fingerprint unchanged (e6ec1a59); adds a polyglot parity case proving .ts/.go siblings never affect resolution. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> * perf(python): parent-key the __init__ bucket to kill package-count skew (PR #1918 P2b) The suffix fallback's package form looked up byBasename.get('__init__.py'), which holds every __init__.py in the repo — so every multi-segment package import (pkg.sub) iterated all N packages to find the one ending /sub/__init__.py. Add byInitParent: __init__.py files keyed by their last two components (<parentDir>/__init__.py). The package lookup now targets only same-named package dirs (typically O(1)) and confirms the full suffix, so the final candidate set and tie-break are unchanged. __init__.py files stay in byBasename too, so the rarer explicit "pkg.__init__" import still resolves via the module (<lastSeg>.py) lookup. Resolver fingerprint unchanged (e6ec1a59); adds parity cases for a nested package (same-parent noise filtered by the suffix confirm) and an explicit pkg.__init__ import. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> * fix(python): reproduce old startsWith gating for absolute paths + re-baseline (PR #1918 P3a) getPythonFileIndex built dirPrefixes by split('/')+filter(Boolean), which drops the leading empty component of an absolute path: "/repo/svc/x.py" yielded {repo/, repo/svc/}. The old full-scan gate compared the whole normalized path, where "/repo/svc/x.py".startsWith("repo/svc/") is false — so the index gate PASSED where the old gate BLOCKED, an absolute-path-only divergence (production paths are repo-relative, so this never fired in production). Build dirPrefixes from every slash-terminated prefix of the full path instead (including the leading "/" for absolute paths), so dirPrefixes.has(X) matches exactly when the old f.startsWith(X) did. For repo-relative paths the prefix set is identical, so production behavior is unchanged. This is NOT cosmetic. Extending the fingerprint harness with absolute-path file sets surfaced 12 fuzz cases (out of ~4000 new absolute cases) where the pre-fix index resolved an import the old code left unresolved — e.g. `pkg.thing` over {/repo/pkg/__init__.py, /repo/vendor/pkg/thing.py} from /repo/app/main.py resolved to /repo/vendor/pkg/thing.py under the buggy gate but is null (old and fixed). The fix removes those absolute-path false positives. Re-baseline justification: the committed resolver fingerprint moves e6ec1a59 -> d51ea9ed because the harness now adds ~4000 absolute-path cases (branch matrix incl. the reviewer's exact case + a 200-repo absolute fuzz). The relative-path subset is unchanged: the original 10,021-case relative corpus still hashes to e6ec1a59 after the dirPrefixes fix (the fix only alters absolute-path prefixes). The new baseline encodes the old-startsWith-equivalent (correct) behavior, verified by diffing the fixed vs. pre-fix harness output. Adds parity cases pinning the absolute false-positive (now null) and a repo-relative control of the same shape (still resolves). tsc clean. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> * test(python-bench): add --check mode + REPS=7 to the scope-capture harnesses (PR #1918 P2a) The bench harnesses were dev-only — nothing compared the committed fingerprints or guarded the scaling, so an O(n^2) regression (or a P1-style cache miss) could land silently. Add a --check mode to both: - measure.mjs: assert the capture fingerprint == baseline-fingerprint.txt AND scaling_ratio < 1.5 (linear), exit non-zero on either. REPS bumped 3 -> 7 to stabilize the median on shared CI runners. - import-target-fingerprint.mjs: assert the resolver fingerprint == baseline-import-target-fingerprint.txt, exit non-zero on drift. Without --check both still print JSON for dev use / deliberate re-baselining. Verified: --check passes on the current tree (capture f2b4376f / scaling 1.04; resolver d51ea9ed) and exits 1 with a clear message on a corrupted baseline. Wired into CI by the dedicated benchmark job (next commit). Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> * ci(bench): add a dedicated benchmark job wiring in the gated cross-language suites The cobol/csharp/rust/php/ruby *-pipeline-benchmark.test.ts suites are gated behind GITNEXUS_BENCH, so the main coverage job skips them — their O(n^2) scaling guards never actually ran in CI. Add a dedicated "benchmarks" job to the Tests reusable workflow that runs them with GITNEXUS_BENCH=1, plus the Python scope-capture and import-resolution fingerprint + scaling guards (measure.mjs --check, import-target-fingerprint.mjs --check) from PR #1918. Runs with --no-file-parallelism: the suites measure wall-clock and peak heap, so parallel forks both skew the timings and OOM the worker pool (reproduced locally: the parallel run crashes a worker; serial passes 5/5 in ~80s). The job is part of the Tests workflow, so it gates the existing CI Gate required check. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> * ci(bench): exclude go-pipeline-benchmark from the gated job (fork-pool instability) Validation surfaced that go-pipeline-benchmark.test.ts's worker-pool (#1848) suite spins a real worker pool that exits unexpectedly under vitest's fork pool, crashing the run (1 of 3 tests, repeated). Including it would make the new benchmark gate flaky. The other five language pipeline benchmarks (cobol/csharp/rust/php/ruby) run clean serially (5/5, ~84s). Go is already guarded by its non-gated O(n^2) tripwire (main coverage job) + golden parity test, so coverage is preserved. Documented inline. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> * ci(security): set persist-credentials false on all ci-tests checkouts (zizmor artipacked) The new benchmarks job (and the pre-existing tests / cross-platform jobs) used actions/checkout with the default persist-credentials, leaving the token in .git/config. The tests job uploads a test-reports artifact, so that is the literal credential-persistence-through-artifacts case zizmor's artipacked audit flags; the others persist creds needlessly. None of these jobs push — they run npm + vitest only — so persist-credentials: false is safe (the packaged-install-smoke job already runs setup-gitnexus this way). All four ci-tests.yml checkouts are now consistent. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> * bench(scope-capture): unified build-free measure harness for all benchmarked languages Adds a single tsx harness that measures emit<Lang>ScopeCaptures for every language with a pipeline benchmark (go, csharp, rust, php, ruby, cobol): per-language synthetic-DAO scaling (250/800 entities) + an order-independent sha256 fingerprint over each <lang>-* fixture corpus, with a --check mode gating both against baselines.json. It immediately surfaced that csharp, rust, php and ruby still carry the O(matches x rootChildren) findNodeAtRange(tree.rootNode,...) root-walk that was fixed for go (#1915) and python (#1918): scaling ratios 3.13 / 3.31 / 3.04 / 3.07 (vs ~1.0 for the fixed go and cobol). They are flagged known_quadratic in baselines.json so CI guards drift + worsening until each gets the threaded-node fix (following commits). Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> * perf(ruby): linearize scope-capture (thread captured nodes + dedup set) emitRubyScopeCaptures re-derived each match's node via findNodeAtRange(tree. rootNode,...) per match (import / scope.function / declaration.function / heritage / attr / call-arity), and the constructor-return pass ran out.some(...) once per method over the growing output array — two O(n^2) shapes (measured scaling 3.07). Thread the query's captured node (c.node) through a nodeMap and resolve each anchor with a type-guarded lookup (nodeIfType), and precompute the YARD-return dedup keys into a Set. Output byte-identical (capture fingerprint over the ruby-* fixture corpus + DAO unchanged); scaling 3.07 -> 1.11 (linear). 127 ruby resolver tests pass; tsc clean. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> * perf(php): linearize scope-capture (thread captured nodes) emitPhpScopeCaptures re-derived each match's node via findNodeAtRange(tree. rootNode,...) per match (import / scope.function / declaration / call-arity), giving O(matches x rootChildren) ~ O(n^2) (measured scaling 3.04). Thread the query's captured node (c.node) through a nodeMap and resolve each anchor with a type-guarded lookup (nodeIfType), mirroring go #1915 / python #1918. Output byte-identical (capture fingerprint over the php-* fixture corpus + DAO unchanged); scaling 3.04 -> 1.03 (linear). 205 php resolver tests pass; tsc clean. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> * perf(rust): linearize scope-capture (thread captured nodes) emitRustScopeCaptures re-derived each match's node via findNodeAtRange(tree. rootNode,...) per match (import / scope.function / declaration / type-binding return-hoist / call-arity), giving O(matches x rootChildren) ~ O(n^2) (measured scaling 3.31 — the worst of the four). Thread the query's captured node (c.node) through a nodeMap and resolve each anchor with a type-guarded lookup (nodeIfType), mirroring go #1915 / python #1918. Output byte-identical (capture fingerprint over the rust-* fixture corpus + DAO unchanged, incl. the impl-block return-type hoist path); scaling 3.31 -> 1.05 (linear). Rust resolver tests pass; tsc clean. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> * perf(csharp): linearize scope-capture (thread captured nodes) emitCsharpScopeCaptures re-derived each match's node via findNodeAtRange(tree. rootNode,...) per match at 7 sites (import / read.member / scope.function / declaration / call-arity / primary-constructor class+record), giving O(matches x rootChildren) ~ O(n^2) (measured scaling 3.13). Thread the query's captured node (c.node) through a nodeMap and resolve each anchor with a type-guarded lookup (nodeIfType), mirroring go #1915 / python #1918. Output byte-identical (capture fingerprint over the csharp-* fixture corpus + DAO unchanged); scaling 3.13 -> 0.99 (linear). C# resolver tests pass; tsc clean. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> * ci(bench): tighten scope-capture budgets to linear + gate all 6 languages in CI All six benchmarked languages now thread the captured node, so update baselines.json: drop known_quadratic and set scaling_budget 1.5 (linear) for csharp/rust/php/ruby (go/cobol already linear). Fingerprints are unchanged — every fix was byte-identical. Wire the unified build-free guard into the benchmarks job: 'node --import tsx bench/scope-capture/measure.mjs --check' asserts the capture fingerprint and linear scaling for go/csharp/rust/php/ruby/cobol on every run. Build-free (no worker pool), so unlike the go pipeline benchmark it is stable in CI. measure --check passes locally for all six (scaling 0.86-1.10). Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> * refactor(ingestion): address PR #1918 tri-review — shared nodeIfType, duck-typed guard, docs Tri-review follow-ups (no behavior change — all capture fingerprints + the resolver fingerprint are byte-identical, verified via the bench --check gates): - maintainability (M1): extract the `nodeIfType` helper (copy-pasted into 4 captures.ts files) to ast-helpers.ts as a generic `nodeIfType<T extends SyntaxNode>`. csharp/php keep their local SyntaxNode aliases (used elsewhere); the generic signature accepts them. - P2 (latent): duck-type the `resolvePythonImportTarget` shape-guard instead of `instanceof Set`. The context type was widened to ReadonlySet<string>; an `instanceof Set` check would reject a legitimate non-Set ReadonlySet and silently drop all Python import edges. Now checks `.has` + `[Symbol.iterator]`. - P3 (ruby dedup): document the snapshot-vs-live `out.some`→Set behavior — the one narrow corner (two same-named methods one row apart, both ending in Const.new) where output differs from the pre-PR code, and why the new behavior (emit both) is intended. - harness cross-ref: note in python-scope/measure.mjs that Python's capture scaling is guarded there (not the unified scope-capture harness) so neither is removed assuming the other covers Python. tsc clean; scope-capture --check passes (6 languages, unchanged + linear); resolver fingerprint unchanged; 300 python/ruby/rust tests pass. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> * test(ingestion): golden + O(n^2) tripwire tests for ruby/rust/php/csharp scope-capture Addresses the PR #1918 tri-review test-gap consensus (testing + adversarial + maintainability): the four newly-linearized languages had no committed correctness/scaling lock in the standard unit-test job — only the bench/scope-capture/measure.mjs --check fingerprint, which runs in the separate benchmarks CI job. Per language, mirroring the existing go/python tests: - test/unit/scope-resolution/<lang>/<lang>-captures-golden.test.ts — ORDER- SENSITIVE golden (modeled on go-captures-golden.test.ts; catches emission reordering the order-independent bench fingerprint misses) over the whole lang-resolution/<lang>-* corpus + a 20-entity synthetic DAO, with UPDATE_GOLDEN regeneration. Runs in the normal unit-test job (fast-fail). - test/integration/<lang>-scope-capture-tripwire.test.ts — non-gated O(n^2) regression tripwire (400-entity source, <10s budget), like python's. The ruby golden also pins the snapshot-dedup behavior (two same-named methods both ending in Const.new emit BOTH @type-binding.return bindings — PR #1918 P3), and the rust golden exercises the impl-block return-type hoist path. 41 tests pass; tsc clean. Goldens generated against the (byte-identical) current output. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> --------- Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-05-30 19:44:22 +01:00