From eeacf305755fb6c1976a0617bb8b691d8b959f3a Mon Sep 17 00:00:00 2001 From: sunerpy Date: Fri, 23 Oct 2026 10:48:22 +0800 Subject: [PATCH] docs(upstream): audit b635dd46..e8ddc4e2 and record the v0.55.2 release A new dated audit file, docs/upstream-sync/POST_V1_6_2_MAIN_2026-10-22.md, classifies the 225 colby `main` commits after `b635dd46` (to `e8ddc4e2`, 2026-10-22; no new upstream tag) against v0.55.1: 147 PORT, 36 PARTIAL, 21 DEFER, 10 ALREADY-HAVE, 10 N/A and one KEEP-RUST, with the owner's decisions of 2026-10-22 (the follow-up pull request takes the DEFER rows; the older gaps become G18 to G25; the C lone-macro KEEP-RUST rule is reopened; W7-14 builds jsx-render on the tree-based JSX references). Two rows marked ALREADY-HAVE failed part of their upstream test's own fixture and are PARTIAL. UPSTREAM.md gains the audit entry, the #335 entry and the v0.55.2 release record with its black-box acceptance, and its Current alignment moves the discovery boundary to `e8ddc4e2`; docs-check follows the new boundary. --- .../POST_V1_6_2_MAIN_2026-10-22.md | 421 ++++++++++++++++++ docs/upstream-sync/UPSTREAM.md | 134 +++++- scripts/docs-check.py | 2 +- 3 files changed, 541 insertions(+), 16 deletions(-) create mode 100644 docs/upstream-sync/POST_V1_6_2_MAIN_2026-10-22.md diff --git a/docs/upstream-sync/POST_V1_6_2_MAIN_2026-10-22.md b/docs/upstream-sync/POST_V1_6_2_MAIN_2026-10-22.md new file mode 100644 index 00000000..4071c831 --- /dev/null +++ b/docs/upstream-sync/POST_V1_6_2_MAIN_2026-10-22.md @@ -0,0 +1,421 @@ +# Post-v1.6.2 upstream main audit — 2026-10-22 + +- **Range:** + `b635dd467f0578926a9c01a37b9d28d2b26689f1..e8ddc4e2be02578d735c350df55f1769b7d6978a` + (colby `main` of 2026-10-07 to colby `main` of 2026-10-22): 225 commits, none + of them merges. Upstream tagged nothing after `v1.6.2` in this range. +- **Baseline:** codegraph-rs `v0.55.1` (`4a7e158`), extraction version 22, + schema 10. Every probe ran on the released `v0.55.1` Linux x86_64 musl binary, + its archive checked against the release `SHA256SUMS`. +- **Kind of audit:** discovery only. Nothing below is planned yet. A `PORT` or + `PARTIAL` row is open work until a Rust pull request, a release and a check + of the released binaries are recorded in [`UPSTREAM.md`](UPSTREAM.md). A + `DEFER` row names the item of the follow-up program (W7, W8 or W9, OD-18 in + [`V1_6_2_AUDIT_2026-10-10.md`](V1_6_2_AUDIT_2026-10-10.md)) whose port has to + absorb it. +- **Tracked release:** stays `v1.6.2`. + +Dispositions use the ledger rubric: **PORT**, **PARTIAL** (part of the behavior +is already present; the row says which part is missing), **ALREADY-HAVE**, +**N/A**, **DEFER** and **KEEP-RUST** (a deliberate, documented divergence). + +Abbreviations: NM = `crates/codegraph-resolve/src/name_matcher.rs`, RS = +`resolver.rs`, IR = `import_resolver.rs`, WK = +`crates/codegraph-extract/src/walker.rs`, SY = `crates/codegraph-watch/src/sync.rs`, +EN = `crates/codegraph-mcp/src/engine.rs`, EV = extraction version. Line numbers +refer to `4a7e158`. + +## Method + +The range was read in two passes. Pass A took the 117 commits that change C, +C++, Objective-C, Swift, Pascal, Rust, Dart, VB.NET and Go extraction and +resolution, plus the Go standard-library table script. Pass B took the other +108: JS/TS and JSX, React and the routers, Vue, Express, Python, incremental +sync, general resolution and scan policy, explore and `codegraph context` +output, the installer and upgrade paths, daemon, database and MCP robustness, +and test hygiene. Each commit was read from its message and its source hunks +and compared with the Rust tree. Most rows were probed on the released binary +with a fixture modeled on the upstream test; a sync row was probed by indexing, +editing, syncing, and comparing with a fresh index of the final tree. The probe +names in the evidence column label those scratch fixtures, which were not kept; +each row states its probe's result. + +Verification of the classifications: + +- Every `ALREADY-HAVE` and `KEEP-RUST` row of pass A was run again with the + upstream commit's own test fixture. Both `ALREADY-HAVE` rows failed part of + their upstream test and are `PARTIAL` below; see + [Corrections during verification](#corrections-during-verification). +- Pass B's ten `ALREADY-HAVE` rows rest on probes of the shapes the row names, + not on every case of the upstream test. The program that ports this audit + runs each such commit's new upstream test cases against Rust first; a + failing case turns the row into `PORT`. + +## Summary + +| Disposition | Pass A | Pass B | Total | +| ------------ | -----: | -----: | ----: | +| PORT | 95 | 52 | 147 | +| PARTIAL | 16 | 20 | 36 | +| DEFER | 5 | 16 | 21 | +| ALREADY-HAVE | 0 | 10 | 10 | +| N/A | 0 | 10 | 10 | +| KEEP-RUST | 1 | 0 | 1 | +| **Total** | 117 | 108 | 225 | + +Most rows change the graph (EV), so porting them needs the extraction-version +move the follow-up program already plans (22 to 23). The largest families are +C++ receiver typing and overload choice, Go and Rust receiver typing, JS/TS +module and receiver resolution, and incremental-sync convergence. The `DEFER` +rows land in the follow-up program's W7 (React Router, the synthesis stage, the +jsx-render pass, Go implements synthesis, Express), W8 (VB.NET) and W9 +(`codegraph context`) items. + +## Owner decisions (2026-10-22) + +| Decision | Result | +| ----------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | +| OD-A1 scope | The follow-up pull request (W7, W8, W9 and OD-19 of the 2026-10-10 audit, extraction version 23) also carries this audit's 21 `DEFER` rows, which change the code those items port. The 183 `PORT` and `PARTIAL` rows wait for a later program, with its own extraction-version move | +| OD-A2 older gaps | Recorded below as G18 to G25. Each is ported in the program that ports the rows needing it, before those rows | +| OD-A3 C lone-macro rule | Reopened. Rust blanks a macro alone on its line only in C++ (`lang/cpp_preparse.rs:1544-1554`, KNOWN_DIFFS.md "C/C++ pre-parse"). In C that loses the first declaration after GLib's `G_BEGIN_DECLS`, and #2773's own fixture shows two more costs: a declaration after a lone macro line becomes a call from the header, and a function whose return type, attribute macro and name sit on separate lines gets no node. C will follow upstream (#2709 and the shapes #2773 pins) in the program that ports pass A row 78; KNOWN_DIFFS.md and the C goldens change with it. The Objective-C row #2691 needs a lone-macro pass either way | +| OD-A4 jsx-render | W7-14 builds the jsx-render pass on Rust's static JSX `references` edges, read from the syntax tree, not on upstream's text scanner. Upstream's scanner fixes that the tree already satisfies (pass B rows 5, 20 and 66) need no port; the different mechanism is recorded as a divergence when W7-14 lands | + +## Open questions for planning + +These need a check or a design choice when the rows are planned. + +1. **#2683 on Windows** (pass A row 58). Rust compiles the same + `1UL << FAKE_TRY_BANG` (tree-sitter-swift 0.7.3 `scanner.c:131`) into its + `*-pc-windows-msvc` builds. The fix is tree-sitter-swift 0.7.4, one of the + grammar updates dependabot holds in #334, which changes the swift golden. + It needs a check on Windows. +2. **#2795 on Windows** (pass B row 105). `read_daemon_hello` sets a read + timeout only on Unix (`crates/codegraph-mcp/src/session.rs:679-682`); a probe + on Windows decides between `PORT` and `PARTIAL`. +3. **The deferred Rust std gate.** Pass A rows 68, 72, 79, 85, 86 and 88 gate + calls whose receiver is a standard-library or dependency type. #2715's rule + (such a type reaches only a project trait impl in scope) covers the narrow + inferred-std-type gate the owner deferred to the next resolution change. +4. **`codegraph context`** (W9-01). Its contract was frozen against + `b635dd46`: entry points come from the Rust explore ranking. #2428's wording + for synthesized hops has to be absorbed; #2785 changes upstream's + dominant-file ranking, which the frozen contract does not use. +5. **Batches and sync lanes.** Some rows only work together (#2723 with + #2724; #2542's two halves; #2776 with #2658's local-binding gate; #2567, + #2568 and #2569 after #2493, #2532 and #2533; pass B row 7 with row 3, row 38 + after rows 37 and 74). Several read text across files and need a sync lane + or a sync-versus-fresh case: #2533, #2626 to #2628, #2538, #2675, #2684, + #2615, #2703, #2784, #2757 and #2692 in pass A; pass B rows 10, 24 and 42 hit + the same 500-per-key name-tail retry ceiling (`queries.rs:1486,1671`, + SY:2779). +6. **Golden and A/B impact.** #2743 (pass B row 84) likely changes the + `typescript` golden. Several shapes already reach the right target through a + weak name match (Go `memSeries` at 0.4, C++ `rocksdb::DB` and `arena_` at + 0.65, Objective-C `_archive` at 0.65); the A/B should count those as + confidence changes, not new edges. + +## Corrections during verification + +| Row | Pass's disposition | Verified disposition | Evidence | +| ------------------------- | ------------------ | -------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | +| A 109, #2769 (`6bd217a2`) | ALREADY-HAVE | PARTIAL | Upstream's `__tests__/operator-method-names.test.ts` fixture on `v0.55.1`: no crash, but `c.operator++()` and `c.operator++(0)` both link the postfix overload and both `operator+=` calls link `operator+=(int)`, where upstream reaches each overload | +| A 110, #2773 (`5a6917b4`) | ALREADY-HAVE | PARTIAL | Upstream's `__tests__/c-macro-return-types.test.ts` fixture on `v0.55.1`: no `usable_size` node for a return type, attribute macro and name on separate lines; `checked_sum` starts at its prototype line; a `calls` edge from `api.h` after the lone `GIT_BEGIN_DECL` line | + +## A. C, C++, Objective-C, Swift, Pascal, Rust, Dart, VB.NET and Go + +| # | Upstream | PR | Behavior (one line, Rust-neutral) | Disposition | Rust target / evidence | Graph impact | Depends on / overlaps | +| --- | ---------- | ----- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | +| 1 | `b8b3eb97` | #2439 | C++ receiver declared by a range-based `for (T* x : xs)` takes T when the call is inside the loop body | PORT | NM:3864-3891 `CppRebinding::rebinds` only marks the receiver shadowed; `infer_cpp_receiver_type` NM:4231 never reads the loop type. Probe `p01b-cpp-rangefor-guess`: `for (log::Writer* log : logs) log->file()` -> `BlobLogWriter::file` (upstream "before"), `x->file()` unresolved | EV | extends W4-CPP-06 (#2413 rebinding/`noteCppDeclaration`); base for #2492 | +| 2 | `c0f45c7d` | #2440 | C++ `->` on a receiver declared `std::unique_ptr`/`shared_ptr`/`optional` resolves on T (C++ name lookup of T, then T's bases); template param/library/alias-of-library gets no edge | PORT | NM:6167-6185 only stops `.`/raw-`->` on lowercase library types; no held-type step (no `unique_ptr`/`shared_ptr`/`optional` handling in resolve). Reusable lookup: `cpp_type_aliases::cpp_class_named` (cpp_type_aliases.rs:865), `cpp_supertypes::match_cpp_supertype` (cpp_supertypes.rs:77). Probe `p02-cpp-unique-ptr`: `std::unique_ptr iter; iter->Next()` -> `ArenaWrappedDBIter::Next` though `Iterator::Next` exists; `iter->Valid()` (inherited from `IteratorBase`) -> `ArenaWrappedDBIter::Valid` | EV | W4-CPP-05 (#2407), W4-CPP-06 (#2413); base for #2530, #2539, #2576, #2579, #2616, #2735 | +| 3 | `16bc05a2` | #2478 | Go local bound from a type assertion (`v := x.(T)`, `v, ok := x.(T)`, `var v, _ = x.(T)`) has the asserted type, found where Go finds it; outside/predeclared types link nothing; a std-package-named local is not a package call | PORT | `go_scope.rs` (decls carry only a written type and a `from` package, go_scope.rs:35-46; no assertion reading); `go_calls::go_asserted_type` (go_calls.rs:297) covers only the direct `x.(T).M()` shape. Probe `p03-go-assert-local`: `fi := s.kvindex.(*fakeIndex); fi.Action()` and `ri, ok := ...(*realIndex)` both unresolved | EV | extends W4-GO-03 (#2444 assertion call, #2448 scope reader) | +| 4 | `fa56256c` | #2479 | C++ receiver-less (or `this->`) call in a method resolves like a typed receiver: own class, then bases (extends edges), then enclosing classes, with arity-fitting overload; free function/param/local/dependent base/other-TU namesake/macro-declared member left to name strategies | PORT | No C++ implicit-`this` branch in NM::match_by_exact_name (NM:2838-3040 has Java/C#/Kotlin/Swift/Dart/PHP/ObjC/Go bare-call rules, none for C++). Probe `p04-cpp-implicit-this`: `this->GetArena()` / bare `GetArena()` inherited from `MessageBase` -> same-file `Arena::GetArena` (0.4 exact-match) | EV | uses #2440 `cppMethodOf`; W4-CPP-05 supertypes; base for #2537, #2548, #2551, #2708 | +| 5 | `1d3619d6` | #2484 | Test-path classifier counts a `unittests/` dir and a `foo_unittest/` / `foo-unittests/` dir (not a bare `unittest/`); the test-suite rule counts them as suites too | PORT | `codegraph-core/src/file_class.rs:54-91` `is_test_path` DIRS/ROOTS and `is_test_support_directory` (:181-210) know no `unittests`/`*_unittest(s)` dir; `is_test_suite_path` (:94-121) neither. Consumers: RS:1899-1900, RS:1961 (test-suite visibility rule), NM:6521, scoring.rs:504 (ranking) | EV (resolution via test-suite rule; ranking) | extends W3 #2209 test-suite rule / #2434 `_unittest.` marker | +| 6 | `8a5ba3d0` | #2489 | Go dotted call whose first segment is a std package name but is a param/local in scope (`func(context *Context)`, `log := log.G(ctx)`) is no longer dropped as built-in; resolved by its declaration only (written/asserted project type; project function's package; else a unique non-std method); scope reader also records `T{…}`/`new(T)` and own-package `:=` calls | PORT | RS:3472-3480 drops every Go ref whose first segment is in `go_stdlib_packages()` (RS:614) with no local/param check (nor #2478's asserted-local exemption); `go_scope.rs` records no `T{…}`/`new(T)` types | EV | needs #2478 (asserted local); extends W4-GO-03 (#2448 scope reader) | +| 7 | `01ab45d0` | #2492 | C++ range-for over `auto` elements types the variable as the range's element: range read from the header (caller's local/param, own-class data member, `auto` initializer, `*x`/`x.m`/`x->m`/`this`, declared-return calls), aliases followed with template args, element = std/abseil container's first arg, `RepeatedPtrField`/`autovector`, or a project `begin()`'s dereferenced return | PORT | Rust reads no range-for at all (see row 1; NM:3864-3891 marks shadowed only). No element-type table for containers in resolve (no `RepeatedPtrField`/`autovector`/`vector` element reading) | EV | needs #2439, #2440 (`cppStdHeldType`, `cppClassWritten`/`cppMethodOf`); W4-CPP-04 aliases; base for #2576, #2579 | +| 8 | `fc0da38f` | #2493 | C++ call on a caller-declared pointer/value/reference (with the operator it takes) resolves through C++ name lookup of the written type (caller scopes, file `using`s, aliases followed) then own method or base edges, not any class of that last name; class lacking the method gets no edge unless template/unlinked base | PORT | NM:6040-6060 `resolve_method_on_type(&inferred, …)` (NM:3569) matches by name/qualified tail. Probe `p05-cpp-declared-namesake`: `Iterator* iter; iter->Valid()` (inherited from `IteratorBase`) -> `MemTableRep::Iterator::Valid` at 0.9 | EV | needs #2440 (`cppClassWritten`/`cppMethodOf`), #2492; W4-CPP-04/05; base for #2530, #2532, #2567, #2569 | +| 9 | `85201e95` | #2530 | One verdict `cppLacksMethod` for held-type (`->` on smart pointer) and declared-type calls: a held/declared class lacking the method gets no edge only when it is no class template and every base on the way is linked or a library type (`cppBasesKnown`); else falls through as before | PORT | Neither path exists in Rust (rows 2, 8). Rust's nearest analog, the alias gate NM:6143-6165, keys on `class_template` only, not on unlinked bases | EV | needs #2440, #2493 | +| 10 | `c19f0284` | #2531 | C++ receiver scan blanks string/char literals and raw strings (`R"d( … )d"`, read file-wide with delimiters) before reading declarations, in the file and its header | PORT | `cpp_code_of` NM:3836-3858 blanks comments only; `infer_cpp_receiver_type` NM:4231 reads raw lines. Probe `p06-cpp-string-decl`: `Log("… WriteBatch handler;"); handler->Run()` with `Handler* handler` param -> `WriteBatch::Run` (0.9); raw-string `WriteBatch h2 = …;` above `h2.Run()` -> `WriteBatch::Run` | EV | W4-CPP-06 (#2413 `cppCodeOf`); refined by #2552 | +| 11 | `79cd737b` | #2532 | C++ `auto` local typed from its initializer as written (casts, written smart pointers, `new`/`make_unique`/construction, declared return of a function or `->`/`.` method, read across lines) and resolved by C++ lookup from that site; `a->b()->c()` resolved on b's written return type; std/abseil gate before last-name match; capitalized type under a project-free namespace (`absl::Status`) gets no project method | PARTIAL | Present: `infer_cpp_auto_initializer_type` NM:3906-3931 + `resolve_cpp_call_result_type` NM:3937-3982 (`new X`, `make_unique`, single-line `Call(…)`/`recv.method` return type, direct construction), last segment only. Missing: casts, written smart-pointer/`->` method initializers, multi-line initializers, C++ lookup of the result, written-return chain step. Probe `p07-cpp-auto-cast`: `auto* mu = static_cast(arg); mu->Lock()` and `auto m2 = txn->GetMutex(); m2->Lock()` unresolved; `absl::Status st; st.ok()` already unresolved (qualified tail, NM:3818-3821), so that half is ALREADY-HAVE | EV | needs #2493, #2440; base for #2556, #2579, #2616 | +| 12 | `df3ce972` | #2533 | C++ receiver not declared in the caller is looked up as a data member of the caller's class wherever the class is declared (any header, own TU first), then its bases' (skipping template-dependent bases); `TEST_F`/`TEST_P` body's class derives from the fixture; member declarations read outside parens, past nested functions/classes, block comments, strings | PORT | `infer_cpp_receiver_type` NM:4231-4396 reads the call's file and only the same-stem header (NM:4341-4395); `member_types::is_member_typed_language` (member_types.rs:26-31) excludes C++, so no member-surface lookup. Probe `p57-cpp-member-const-tulocal`: `versions_->GetColumnFamilySet()` in `db_impl_write.cc` (member `VersionSet* versions_` declared in `db_impl.h`) unresolved | EV | needs #2493, #2440; a sync lane is needed (class header edited, member types change for callers in other `.cc` files); base for #2537, #2551, #2626-#2628, #2731 | +| 13 | `fedda297` | #2536 | C++ declarator reads past cv-qualifiers/`__restrict`/nullability annotations around `*`/`&` (`T* const x`, `T const& x`, `T* PROTOBUF_NONNULL x`) and an ALL-CAPS annotation call after the name (`MemTable* imm_ GUARDED_BY(mu_);`) | PORT | `build_declarator_regex` NM:3729-3735 / ASCII twin :3742-3751 capture `const` as the type in `Iterator* const iter` (normalize drops it -> None, scan goes on, NM:4283-4330) and `declarator_terminator_ok` NM:3897-3902 rejects `imm_ GUARDED_BY(…)`. Probe `p57-cpp-member-const-tulocal`: `Iterator* const iter = nullptr; iter->Valid()` -> `MemIter::Valid` (0.65 guess) | EV | extends W4-CPP-06; read by #2533's member reader and #2439's range-for tail | +| 14 | `bb817d45` | #2540 | C++ structured-binding names typed by element position (range-for over pairs/tuples/maps' key-value pairs, or a pair/tuple initializer); statements read to `;`; `std::function`/`move_only_function`/`copyable_function`/`absl::FunctionRef`/`AnyInvocable` calls get the function type's return; member whose type is the whole previous line read | PORT | Rust only marks a structured binding as shadowing (`CppRebinding.binding` NM:3871-3876); no element typing, no function-wrapper return types (no `std::function` handling in resolve), no previous-line member types | EV | needs #2439/#2492 (range-for), #2533 (`cppDataMemberIn`) | +| 15 | `8d918067` | #2537 | gtest `TEST_F`/`TEST_P` body (a function node `TEST_F`) resolves bare calls through the fixture class and its bases (`cppImplicitThisMethod`, `cppTestFixture`); `this` in it is the fixture; bare-call results typed by the same lookup; `->` through an outside type (`absl::StatusOr`) takes no last-name class | PORT | No gtest fixture handling in resolve (TEST_F appears only in extraction macro-name tests, `lang/cpp.rs:1179`, :1857); no C++ implicit-this lookup (row 4) | EV | needs #2479, #2533; extended by #2551 | +| 16 | `0cea43e9` | #2539 | Held-type step also reads `absl::StatusOr`/`absl::optional`/`absl::NoDestructor` (holder named like no project type); a `using Base::name;` in a class body lets bare names and inherited members reach a template-dependent base | PORT | No held-type step (row 2) and no C++ implicit-this/member lookup (rows 4, 12); `cpp_supertypes.rs:393-418` `UsingKind`/`usings_in` read file-level `using`s for base lookup, not class-body using-declarations of members | EV | needs #2440, #2479, #2533 | +| 17 | `61cb4188` | #2538 | C/C++ cross-file visibility rejects translation-unit-local targets: types only `.cc` files declare, members written inside them, out-of-line members of such types, and what a source file's unnamed namespace holds (still visible to the file itself, its includers, and headers it includes below); typed lookups prefer candidates the call file can see (`cppVisibleFirst`) | PORT | RS:1041-1100 `c_family_static_function_is_file_local` covers only `static` C/C++/ObjC functions; RS::target_is_visible_across_files RS:1224 has no class/unnamed-namespace TU-local rule. Probe `p57-cpp-member-const-tulocal`: bare `Flush()` in `db_test.cc` -> `ColumnFamilyTestBase::Flush`, a class only `column_family_test.cc` declares (0.9 exact-match) | EV | extends W4-CPP-08/#2421 includers (`cpp_includers.rs`); needs a sync-vs-fresh case (adding a header that declares the type makes it visible) | +| 18 | `a6ceb047` | #2541 | C++ overload choice for typed-receiver and bare method calls: best arity, then argument-type fit (char/number/bool/null/zero literals, written types of caller-declared names, `&name`, `name[i]`, expression types); namesake classes' overloads of the class C++ found; out-of-line defaults read from the in-class declaration; comments dropped from lists | PARTIAL | Present: count + string-literal fit `cpp_namespaces::cpp_overload_fit` (cpp_namespaces.rs:803-865) for macro-namespaced qualified calls only, and arity retarget for a C++ method's call to itself (overloads.rs:87-99). Missing: everything for typed-receiver/bare calls. Probe `p08-cpp-overload-typed`: `db->Get(1, 2, &value)` -> 5-param `DB::Get` (db.h:4), `db->Insert(ch)` with `char ch` -> `Insert(const std::string&, int)` (db.h:6) | EV | needs #2479 (bare), #2493 (`cppMethodOf`); base for #2554, #2612, #2618 | +| 19 | `34dd3d2f` | #2542 | (a) Extraction: a class/struct/union whose name is written in a scope (`struct SkipList::Node {…}`, `struct BlockBasedTable::Rep {…}`) takes its own name, qualified under the written scope (template args dropped), members qualified under it; a specialization stays unnamed. (b) A C++ construction (`new X(…)`, instantiates) makes the class C++ lookup finds as written (template args, enclosing-declared class among same-qualified ones, alias followed; 0.9, 0.7 when only file-visible), nothing for template params/outside-type members | PORT | (a) Probe `p09-cpp-outofline-nested`: both indexed `struct leveldb::` with members `leveldb::::Next`/`::Size`. (b) instantiates refs resolve by last name; RS:2584-2720 `resolve_cpp_constructor` handles constructor _calls_ to constructor methods, not the class lookup for constructions | EV (node names/ids change) | (b) must land with (a) (upstream: naming `DBImpl::Writer` made `new log::Writer` hit it); W4-CPP-04 aliases; base for #2549, #2609 | +| 20 | `6df48276` | #2548 | C/C++ class-name and capitalized-receiver strategies take a method only when its qualified name is exactly the class's plus the method (no nested/namesake class's method); a call through a class uses C++ lookup with bases | PORT | `find_method_in_class` NM:7129-7153 accepts any method whose qualified name _contains_ the class name (NM:7149), used by Strategy 1 NM:6265. Probe `p10-cpp-class-containment`: `descriptor->file()` and `Descriptor::file()` -> `Descriptor::ExtensionRange::file` (0.8 / 0.85). The explicit base call `PessimisticTransaction::PopSavePoint()` already reaches `Transaction::PopSavePoint` (0.7) | EV | needs #2440 lookup; W5-08 `inherited_method` (NM:6280) | +| 21 | `754cc45a` | #2549 | A C++ alias whose target is spelled through a derived class (`using S = Suite::Setting;`, `Setting` declared by Suite's base) is followed a segment at a time through each class's bases (`classReached`), for class lookups and constructions | PORT | `cpp_type_aliases::cpp_class_named` cpp_type_aliases.rs:906-922 resolves the alias target with `class_named` (exact spelling, :692-712), the upstream "before"; the base-aware `lookup_segments`/`member_of` (:935-999, :714-750) exist and are reusable | EV | W4-CPP-05 (#2407 `cppClassNamed`); with #2542(b) constructions | +| 22 | `d94a92ea` | #2551 | gtest `TEST_F`/`TEST_P` body looks unqualified type names up in its fixture (and bases) before enclosing namespaces; a function-local class is visible only inside that function, and a namesake local class's methods are its own body's | PORT | No fixture scope in `cpp_supertypes.rs` / `cpp_type_aliases.rs` scopes (`caller_scope` cpp_type_aliases.rs:212 uses the caller's qualified name only); no function-local-class visibility gate in RS::target_is_visible_across_files RS:1224 | EV | needs #2537 (`cppTestFixture`), #2533 | +| 23 | `d4b9c2b4` | #2552 | C++ line-at-a-time declaration scans read a line starting with `*` as code (`*reinterpret_cast<…>(h);`), and blank multi-line block comments and string contents (from the per-file raw-string pass) before reading any line | PORT | `cpp_code_of` NM:3836-3858 drops every line matching `^\s*(?://\|\*)` as a comment and blanks only same-line `/* … */`; no file-level block-comment/literal pass | EV | refines #2531 (`cpp-raw-strings`) | +| 24 | `24286218` | #2553 | C++ argument splitting opens a template only for `<` right after a name with a matching `>` before the enclosing bracket (comparisons/shifts are not templates); declared types' template arguments pair brackets and may be empty (`parse_context<>& ctx`, `const std::vector& a, std::vector& b`) | PORT | `split_cpp_top_level` cpp_namespaces.rs:697-733 and `overloads::split_top_level` overloads.rs:642-680 count every `<` as depth; declarator regexes NM:3729-3751 use unpaired non-empty `<[^;=(){}]+>` | EV | affects #2541/#2201 overload fit (W4-CPP-07) | +| 25 | `8cba7e53` | #2554 | C++ overload fit: `nullptr` fits `std::nullptr_t` exactly and a pointer by conversion; an overload declared `= delete` is taken only when every overload is | PORT | No argument-type fit for typed calls (row 18). Probe `p11-cpp-deleted-overload`: deleted `reset(T*) = delete` is indexed (u.h:5) and `ptr.reset(nullptr)` links to it, not `reset(std::nullptr_t)` (u.h:6) | EV | needs #2541 | +| 26 | `e03ff673` | #2555 | C++ receiver declaration spanning lines is read: joined until template brackets pair, or with a type line alone above the name | PORT | `infer_cpp_receiver_type` reads one line at a time; a type begun above only marks the receiver shadowed (`cpp_type_began_above` NM:3782, NM:4323-4328) | EV | builds on W4-CPP-06 (#2443); #2533 reads members this way | +| 27 | `1753472a` | #2556 | A member call with explicit template arguments (`r->GetRaw>(…)`, `f->GetOptions()`) reaches the class's template overloads and, when each returns the same template parameter, has the call's argument for it as its type; macro bodies' `\`-spliced lines read as one statement | PORT | `resolve_cpp_call_result_type` NM:3937-3982 reads only `recv.method` without template args and never `->` (`rfind('.')` NM:3955); no template-parameter return substitution | EV | needs #2532 (auto initializers through `->`) | +| 28 | `00d7430e` | #2567 | C++ namespace-qualified receiver types: a macro-named namespace (`#define ROCKSDB_NAMESPACE rocksdb`) counts as the project's both ways; a lowercase outside type beside project namesakes is the library's when every project type of that name is a namesake (`cppFindsOnlyNamesakes`); a capitalized type whose last name finds only namesakes (far declarations, project namespaces the index lacks) gets no edge | PARTIAL | Lowercase half ALREADY-HAVE: probe `p12-cpp-qualified-namesake` `absl::flat_hash_set seen; seen.insert(3)` with project `util::flat_hash_set::insert` unresolved. Missing: macro-namespace equivalence on the typed path (same probe: `rocksdb::DB* db; db->Put(1)` reaches `ROCKSDB_NAMESPACE::DB::Put` only by a 0.65 guess); namesake gate for far declarations (probe `p12b-cpp-far-namesake`: global `absl::Status g_status; g_status.ok()` -> `upb::Status::ok` 0.7). Macro tables exist: `cpp_namespaces::NamespaceMacros` (cpp_namespaces.rs:240-372) | EV | needs #2532, #2493; W4-CPP-07 macro namespaces | +| 29 | `759acbbc` | #2568 | A C++ type name keeps a leading `::` (`global`) and is looked up from the global scope alone: alias targets (`using Arena = ::upb::Arena;` inside a namespace `upb`), base clauses, and alias-by-alias walks for `auto`/chains | PORT | `cpp_type_aliases::cpp_type_name` drops a leading `::` (cpp_type_aliases.rs:143-147); `base_classes_of`/`follow` look targets up from the alias scope. Probe `p13-cpp-alias-global`: `backend::Arena arena_; arena_.Fuse(o)` reaches `upb::Arena::Fuse` only by a 0.65 guess (C++ members are untyped, row 12) | EV | matters once #2533/#2532 type members/autos through aliases; W4-CPP-04 | +| 30 | `8f1f842b` | #2569 | Receiver declared with a leading `::` keeps it (not after a name/template args/`)`), and a function-local `using Foo = Bar;` never stands for `::Foo`; far lowercase outside types (`absl::…`, `std::string`) reach no project namesake | PARTIAL | Probe `p12c-cpp-far-lowercase-global`: `::upb::Arena& a` inside `hpb` with `hpb::upb::Arena` present reaches global `upb::Arena::Fuse` (0.9), and far `absl::flat_hash_set g_seen; g_seen.insert(3)` / far `std::string g_text; g_text.clear()` (p12b) stay unresolved: ALREADY-HAVE. Missing: probe `p12d-cpp-global-vs-local-alias` `using Foo = Bar; ::Foo* x; x->Run()` -> `Bar::Run` (declarator NM:3729 starts at a letter, alias lookup follows the local alias) | EV | with #2567, #2568; keep when porting #2493 | +| 31 | `c71a3d03` | #2573 | C++ receiver declared as a class template's member type (`SkipList::Iterator iter(…)`, `InlineSkipList<…>::Iterator iter_;`) is read whole and looked up as that template's member; a library template's member is a library type only as an iterator (`std::vector::iterator`) | PORT | Declarator regex NM:3729-3751 allows one template list then the receiver, so `SkipList::Iterator iter` is read as `Iterator`. Probe `p14-cpp-template-member-type`: `iter.Valid()` -> `leveldb::Iterator::Valid` (0.9) instead of `SkipList::Iterator::Valid` | EV | needs #2493 lookup | +| 32 | `8fe31569` | #2576 | C++ `->` on a declared container iterator (`std::deque::const_iterator it; it->data()`, `RepeatedPtrField::iterator`) reaches the container's element type (`cppRangeElementOf`), looked up as C++ does; library element or caller's template parameter calls no project method | PORT | No iterator/element reading in resolve (rows 2, 7); NM:6167-6185 lets `->` on library types fall to name guessing | EV | needs #2440 (`cppArrowTarget`), #2492 (`cppRangeElementOf`), #2573 | +| 33 | `c29caf2a` | #2579 | An `auto` local from a std/abseil container's `begin`/`end`/`find`/`lower_bound`/`rbegin`/… types as `::iterator`, and std searches (`std::lower_bound`, `std::find_if`, `std::next`, …) as their first iterator argument; element looked up where the container type is written | PORT | `infer_cpp_auto_initializer_type` NM:3906-3931 has no library-call result typing; `CALL_RE` path returns None for `logs_.begin()` (member receiver untyped, row 12) | EV | needs #2576, #2532, #2533 | +| 34 | `18efc8c9` | #2598 | C++ `(*it)->Visit()` / `(*node).Weight()` (recorded by bare name) resolved on the dereferenced value's class by C++ lookup, read at the call's column; `*x`/`x->` dereference iterators, pointers and holders in expression typing; `auto first = *nodes.begin()` typed | PORT | No C++ expression typing in resolve. Probe `p15-cpp-deref-pair-subscript`: `auto it = nodes.begin(); (*it)->Visit()` over `std::vector` -> `Other::Visit` (0.4 exact-match guess) | EV | needs #2440, #2576/#2579 (`cppDereferenced`) | +| 35 | `8f951e59` | #2601 | `x.first`/`x.second` (and `->`) on a `std::pair` (map iterator, range-for element, declared pair) type as the pair's elements; `it->second.Flush()`, `(*it).first.Print()` and `auto& v = it->second` resolved | PORT | No pair-member typing. Same probe: `mi->second.Flush()` is recorded as `second.Flush` and stays unresolved (Rust keeps the member segment where upstream records a bare name; the port reads the receiver at the column either way) | EV | needs #2598, #2579, #2540 (map elements) | +| 36 | `4727a068` | #2602 | Subscript typing: `a[i].M()` / `p[i]->M()` reach an array's element, a pointer's pointee, a map's mapped value, a sequence's element, or a class's `operator[]` return; declarations record array dimensions; overload arguments use it | PORT | No subscript typing. Same probe: `statuses[0].IsNotFound()` over `std::vector` -> `Status::IsNotFound` only as a 0.4 exact-match name guess (an `Other::IsNotFound` exists) | EV | needs #2598, #2541 (overload args) | +| 37 | `f7951a13` | #2605 | After extraction, a pass over the original source expands the file's own function-like macros whose body defines `Class::method(…) … {` at each namespace-scope invocation (`PROTOBUF_DEFINE_ACCESSOR(FieldDescriptor, number, int)`, `Reflection::Get##TYPENAME`) and mints a method node per definition (qualified like an out-of-line definition, contained by file and same-file class, expanded head as signature); constructors/destructors/variadic macros excluded; resolver reads its return type/params from the signature | PORT | Probe `p56-cpp-macro-defined-methods`: `#define PROTOBUF_DEFINE_ACCESSOR(CLASS, FIELD, TYPE) TYPE CLASS::FIELD() const {…}` invoked twice mints no method node, and `f->number()` stays unresolved. The nearest Rust rule, `recover_single_arg_macro_defined_name` (lang/cpp.rs:1069-1080, upstream #1373), only names a function whose body follows a single-argument invocation and leaves token-pasting alone | EV (new nodes) | the upstream kernel fast-path change is N/A; overload-deleted rule from #2554 | +| 38 | `627018eb` | #2609 | (a) An explicit specialization of a function/member template is named after its template (`ReadPrimitive`, `Deserialize`), receiver taken from the text before the declarator's name (must end in a real `::`). (b) Resolver picks among template/specializations: written template args reach the matching specialization, else the template or an ordinary overload, else nothing; no args reach a specialization only when nothing else has the name; a class's specialized member template ends the lookup; override pass skips specializations | PORT | Probe `p16-cpp-specialization-free-overload`: `template <> bool WireFormatLite::ReadPrimitive(…)` indexed as method `WireFormatLite::ReadPrimitive::TYPE_INT32>`, `template <> int64_t Deserialize(…)` as function `Deserialize` | EV (node names/ids change); check golden:cpp `template_method.cpp`/`templated_call.cpp` (no specializations there) | (a)+(b) together; #2541 overload machinery | +| 39 | `4a591aee` | #2612 | C++ free-function calls (exact, qualified, global, macro-namespace matching) pick the overload the arguments fit among the functions of that qualified name the file can see (count then type); a TU-local overload never competes and a rejected TU-local pick falls to the visible overload; a function hides a same-named class; parameter named like its function no longer read as declarator | PORT | Probe `p16b-cpp-free-overload-order`: `int32_t r; ParseWithLimit(1, "x", &r)` -> the `int64_t& result` overload declared nearer (a.cc:3, 0.4); overload fit exists only for macro-namespaced calls (cpp_namespaces.rs:803) | EV | needs #2541 (`cppOverloadFor`), #2538 (TU-local) | +| 40 | `dc4ccf6b` | #2613 | C call links the function its own file can see (its own, an included header's, else an external-linkage one, best placed) instead of the nearest name match that visibility then drops; a `.c` file's `static` is visible to a file that `#include`s that `.c`; unplaceable `#include`s fall back to path-suffix matching for includers (standard headers excluded) | PORT | Probe `p17-c-static-copy`: `core/server.c` defines `mstime()`, `src/bench.c` a `static mstime()`; `mstime()` in `src/ae.c` (includes `../core/server.h`) and in `src/inc.c` (includes `bench.c`) both unresolved. RS:1041-1100 drops another file's static with no fallback | EV | extends W4-CPP-08/W4-CPP-09 includers (`cpp_includers.rs`), #2538; base for #2615 | +| 41 | `98127e54` | #2615 | A C definition compiled only under a flag nothing in the project sets (file, build files from root to definition/call, C/C++ files of their components) gives way to the non-static, non-variant definition the default build compiles (`fpconv.h` `#ifdef USE_INTERNAL_FPCONV` inline vs `fpconv.c`); a branch around both definition and call decides nothing | PORT | No such rule; `c_macro_visibility.rs` evaluates `#if` for macro definitions only (KNOWN_DIFFS.md "C/C++ macro visibility"), not for choosing among function definitions | EV | needs #2613; sync: a build file or header defining the flag changes the choice (needs a lane or a sync-vs-fresh case) | +| 42 | `0893606e` | #2616 | What a library container/holder member returns is typed where the container type is written: sequence `front()`/`back()`/`at(i)` -> element, map `at(key)` -> mapped value, `stack`/`priority_queue` `top()`, `queue` `front()`/`back()`, `unique_ptr`/`shared_ptr`/`NoDestructor` `get()` -> pointer to held, optional/`StatusOr` `value()`/`value_or()` -> held; used in chains, `auto` locals, ranges, arguments | PORT | No library-member return typing in resolve (rows 2, 33) | EV | needs #2576/#2579 (`cppLibraryIteratorOf`), #2532, #2541 (typed `.get()` arguments) | +| 43 | `19813544` | #2618 | Overload fit picks among `const` twins the one adding `const` to the fewest arguments; a non-const pointer/reference never takes a const object, a reference never a call's value; objects vs pointers, char pointers vs other pointers; written `const`/`constexpr`, arrays as pointers, `&ref` as pointer kept in argument types; template headers read 8 lines up | PORT | No argument-type overload fit for C++ (row 18) | EV | needs #2541, #2616 | +| 44 | `6e884d7b` | #2626 | A C++ call on a member chain (`a.b.m()`, `a->b->m()`, `this->p_.m()`) is read at its site and typed by the members' declared types; when the object is a library type or under a namespace the project declares nothing in, no edge (`.` on `std::vector`/`unique_ptr` is that type's own member) | PORT | Probe `p18-cpp-member-chain`: `options.cf_paths.emplace_back(DbPath())` on a `std::vector` member -> project `Paths::emplace_back` (0.7) | EV (removals) | needs #2533 (`cppDataMemberIn`); step 1 of #2627/#2628 | +| 45 | `e8ec7fd8` | #2627 | Member-chain call on a project-class member reaches that class's (or inherited) method via C++ lookup where the member type is written, overloads by argument type, no edge when the class surely lacks it; member read from the class node lookup found | PORT | Probe `p18b-cpp-member-chain-otherheader`: `thread->rand.Next()` (member `Random64 rand` in `state.h`) unresolved; it resolves only when the struct sits in the call file's same-stem header (p18: header fallback NM:4341-4395) | EV | needs #2626, #2493, #2530 | +| 46 | `e2b0cf5e` | #2628 | `x.member` typing finds members inherited from bases (to depth 4; template-dependent bases only through a using-declaration), e.g. `options.statistics->getTickerCount()` on rocksdb's `Options` | PORT | Same probe: `options.statistics->Next()` with `statistics` declared in base `BaseOptions` unresolved | EV | needs #2627, #2533 (`cppInheritedDataMember`), #2539 | +| 47 | `a944ec35` | #2655 | Go struct emits a `references` ref from the struct to each named field's declared type (no field nodes; predeclared types, own type params and own name skipped; embedded generic's type args are refs, embedded field stays `extends`); unknown-qualifier gate covers every Go type kind; explore: a references edge between two type declarations doesn't make either end entry-connected | PORT | Probe `p19-go-struct-field-refs`: `Header *ResponseHeader`, `handlers HandlersChain`, `[]Op`, `map[string]*Op` give no edge (only the embedded `extends`). Explore half: Rust explore has no upstream `connectedToEntry` file grouping (`engine.rs` handle_explore :1217; `TYPE_KINDS` only in change-surface rescue :3366), so re-check MCP goldens instead | EV; golden:go unlikely (fixture structs hold only predeclared types) | extends W4-GO-02 (#2441 alias type walk); #2417 gate (W4-GO-02); base for #2659, #2764 | +| 48 | `6692e051` | #2658 | Go exact-name matching drops candidates the reference cannot see (unexported name of another package) before ranking, so the package's own declaration wins (also past the ambiguity ceiling); a bare Go call/function value whose enclosing function binds the name (param, `:=`, `var`) stays unresolved | PARTIAL | Probe `p20-go-unexported-shadow`: `[]*memSeries` / `memSeries{…}` in `tsdb/head_append.go` reach the own package's `tsdb/head.go` struct but only at 0.4 (post-ranking veto RS:1318-1327, no pre-ranking Go filter in NM::match_by_exact_name NM:3040-3200, which has Dart/Java/PHP/Kotlin/C# filters). Missing gate: `setup := func(x int){}; setup(t)` links to package func `setup` (0.9) | EV | W4-GO-01 (#2361 package dirs), W4-GO-03 (#2448 scope reader for local bindings) | +| 49 | `383c2cd9` | #2659 | Go interface method nodes get a `references` ref per type name in their parameters and results (predeclared types and the interface's own type params skipped; the interface's own name kept) | PORT | Probe `p21-go-interface-sig-refs`: `KV::Put(key, val string, opts ...OpOption) (*PutResponse, error)` and `KV::Children() []KV` are method nodes with no outgoing refs (only the defined type `OpOption`'s underlying-type edge from W4-GO-02 exists) | EV | needs #2655's type walk | +| 50 | `93f85d10` | #2660 | Go import mappings no longer list an unaliased import under its last path element when another import of the file is explicitly given that name (`"github.com/cheggaaa/pb/v3"` beside `v3 "go.etcd.io/etcd/client/v3"`); goimports' assumed name kept | PORT | IR `extract_go_imports` IR:973-980 maps every unaliased spec to its last path element with no check against explicitly named specs | EV | W4-GO-03 (#2410 assumed names) | +| 51 | `90d6501b` | #2664 | Go call of a standard method name (`Error`, `String`, `Lock`, `Len`, …) on a plain variable: the scoped declaration decides (project type's own method via its package; nothing for predeclared/outside/literal/outside-function values or a type lacking it); else a guess needs the receiver to name the owner type (case/trailing digits aside) in Strategy 3 and Strategy 2 (no file-containment match) | PORT | Probe `p22-go-std-method-guess`: `var pendingMu sync.Mutex; pendingMu.Lock()` -> project `Mutex::Lock` (0.9); `err := doThing(); err.Error()` -> `notRegisteredErr::Error` (0.7). `go_calls::GO_STD_METHODS` (go_calls.rs:29) and the #226 word gate exist but do not consult the scope reader | EV | needs W4-GO-03 scope reader; #2489's "outside function hands out" rule; relates to #2706, #2782 | +| 52 | `5c1e55f4` | #2667 | Go call through a same-package package-level `var`/`const` (receiver bound by no local/param/import) typed from its spec: written type, composite literal's or conversion's type, or the spec above for a lone `const` in a group; project type -> own method 0.9 via its package; outside/predeclared/literal -> nothing; project-function values, untyped consts, build-tag-divergent declarations left to strategies; `package foo_test` is another package | PORT | Probe `p23-go-package-var`: package vars are nodes (`variable lg/display/Strategy`) but `display.Print()` (`var display printer = &simplePrinter{}`) and `Strategy.Print()` (`var Strategy = simplePrinter{}`) stay unresolved; `go_scope.rs` reads only function-local scopes (go_scope.rs:1-12) | EV | needs #2682 (var-block nodes); W4-GO-01 package dirs; #2784 build-tag twins | +| 53 | `bb8a0f73` | #2675 | In a C/C++ test file, when several files declare a name, candidates narrow to what the test's translation unit declares (own file, transitive includes, the same-stem source implementing an included header unless it keeps the definition TU-local), for exact-name, typed-receiver, class-name and receiver-word strategies; bare names only to non-class functions/types/constructors; unchanged when the TU declares none | PORT | No include-based candidate narrowing in NM (only `prefer_call_site_file`, NM:3330-3343, NM:3678-3681); includers are used only by the test-suite visibility rule RS:1873-1961 (#2421) and macro visibility (`c_macro_visibility.rs`) | EV | uses `cpp_includers.rs` (W4-CPP-09), #2538 TU-local rule; generalized to non-tests by #2684 | +| 54 | `23f728fa` | #2678 | Go doc comment is only the comment group ending on the line right above the declaration (a blank line ends a group; a comment ending on the declaration's line documents nothing) | PORT | Probe `p24-go-doc-varblock`: `Run`'s docstring is `-- section banner ----\nRun runs things.` (banner above a blank line joined); `Detached` (comment, blank line, func) gets `TODO: remove` | EV (docstrings) | Go-only extractor option; with #2679, #2680 | +| 55 | `f43432c8` | #2679 | Go comment directives (`//go:embed x`, `//nolint:errcheck`, `//line`/`//extern`/`//export …`) are dropped from doc text but still delimit where the doc starts; a declaration whose only comment is a directive has no docstring | PORT | Same probe: `//nolint:unparam` above `func restore()` gives docstring `nolint:unparam` | EV (docstrings) | needs #2678 | +| 56 | `6e68a11b` | #2680 | A member of a Go `const ( … )` group takes its own doc comment (Go rules), else the group's | PORT | Same probe: `ErrorTypeBind` (own comment inside the group) has docstring NULL. Rust Go var/const nodes carry no docstring at all: `extract_go_variable` WK:5098-5125 creates them with `NodeExtra::default()` (upstream gives the group's docstring even before #2680) | EV (docstrings) | pre-existing gap: Go var/const docstrings (see Questions) | +| 57 | `22e9f7b3` | #2682 | Every member of a Go `var ( … )` block (wrapped in `var_spec_list`) becomes a variable node with its own or the group's doc, its initializer walked under it | PARTIAL | `extract_go_variable` WK:5098-5125 walks descendants and `break`s after the first identifier, so the first member of a var group is indexed (upstream before: none), but no other member. Probe `p24b-go-groups`: `var ( x = 1; y = 2; z int )` -> only `x`; `const ( A; B; C )` -> only `A` (upstream indexes every const spec); `var p, q` / `const D, E` -> first name only (same as upstream, which reads `spec.namedChild(0)`). Probe `p24c-go-var-init`: `var c = f()` / `var reg T = T{}` record no call/instantiates (upstream walks Go initializers under the var since #693) | EV | pre-existing gaps (const-group members, Go initializer walk #693) needed for #2667; see Questions | +| 58 | `c58f0417` | #2683 | Swift `try!` calls parse right on Windows: tree-sitter-swift 0.7.3's scanner builds the `try!` mask entry as `1UL << FAKE_TRY_BANG` (bit 32), which MSVC folds to 0, so `try! Message2(…)` became `! Message2` and `try! A.b.load()` a bare `load`; fixed by 0.7.4's `1ULL` | PORT | Rust compiles the same C: `tree-sitter-swift = "0.7.3"` (crates/codegraph-extract/Cargo.toml:57, Cargo.lock:3882-3885) and ships `x86_64`/`aarch64-pc-windows-msvc` (.github/workflows/release.yml:382-387); the registry source has `1UL << FAKE_TRY_BANG` at `tree-sitter-swift-0.7.3/src/scanner.c:131`. Fix in Rust is a crate bump to 0.7.4 (present in the local index cache), not upstream's vendored patch (grammar-manifest.md forbids vendoring). Acceptance needs a Windows probe (`try! Foo(data: d)` resolves) | EV (Windows Swift parse; check grammar-tables identity) | upstream kernel/wasm build machinery N/A | +| 59 | `32b839ac` | #2684 | #2675's translation-unit narrowing applies to C/C++ code outside tests too, with refinements: a source implements only the same-stem header _beside it_ that it includes; a header's overloads reach its source's definitions; never narrow to functions the arguments can't fill past one outside the unit that they can; a C call keeps #2615's flag-variant choice; file-level "calls" left as is | PORT | Same gap as row 53 (no include-based narrowing in NM) | EV | needs #2675, #2615, #2541 (arity fit); refined by #2693 | +| 60 | `3308cff0` | #2686 | Swift walker strips prefix operators (not implicit-member `.`), `try` and `await` off a call's callee and receiver (`!isReady()` parses `(!isReady)()`, `try! Decoder().decode(d)` parses `(try! Decoder()).decode(d)`); receiver chain text read from the innermost operand; a member read through `!` references its type; `!(x)` emits no call | PORT | Probe `p25-swift-wrapped-calls`: `!isReady()` recorded as unresolved `!isReady`; `!store.contains(d)` and `try! Decoder().decode(d)` lose their receivers and resolve as bare `contains`/`decode` exact-match guesses (0.4) | EV; golden:swift possible (check `try`/`!` call sites) | W4-SW-02 (#2118/#2170 call shapes) | +| 61 | `12ea27fa` | #2689 | Swift receiver typing reads `let x = try/try!/try?/await Type(…)` (type arguments, stepping over `try`/`await` on a `let`/`var` line with no member after the constructor call); bare `x = try T(…)` and `try! Realm().write {…}` unchanged | PORT | Same probe: `let storage = try! DiskStorage.Backend(config: 1); storage.store(1)` unresolved | EV | W4-SW-02 (#2205 typed receivers) | +| 62 | `6c202bca` | #2690 | Objective-C indexes a struct/union/enum defined in a declaration's type (`static struct { Class isa; } placeholder;`, `struct Pair {…} pair;`, `enum {…} mode;`), also in error trees; an unnamed one takes the first declared variable's name; the declaration's comment is its doc; a type a `.m`/`.mm` defines is visible only to that file (classes stay visible); a typedef right after a lone-macro line is recovered | PORT | Probe `p26-objc-decl-types-macros`: none of the three `Foo.m` declarations yields a node. The C/C++ half (#2446) is W4-CPP-03 (WK variable branch); ObjC does not take it | EV; golden:objc possible | extends W4-CPP-03 (#2446), #2538 (TU-local types) | +| 63 | `40987d77` | #2691 | Objective-C pre-parse blanks a macro alone on its line (`NS_ASSUME_NONNULL_BEGIN`, `OF_SUBCLASSING_RESTRICTED`, `RCT_EXTERN_C_BEGIN`) with ObjC rules (code below may start with `@`; a preprocessor line above ends at its line; a macro that is a method's whole body is kept); ObjC supertypes read from the `@interface` line within the class | PORT | Probe `p26-objc-decl-types-macros`: after `NS_ASSUME_NONNULL_BEGIN`, `@protocol Runnable` and `@interface Foo : NSObject ` produce no nodes; without the macro (`p26b-objc-no-macro`) both are indexed with `Foo -implements-> Runnable`. Rust blanks lone macro lines in C++ only (KNOWN_DIFFS.md "C/C++ pre-parse"; `lang/cpp_preparse.rs`); `lang/objc.rs` has no pre-parse | EV; golden:objc possible | relates to #2709 (C) and the KNOWN_DIFFS C/C++ pre-parse entry | +| 64 | `65d73423` | #2692 | Rust type aliases record visibility; a private module item is out of scope outside its module ahead of ranking (so an imported function wins over a private namesake); a name a `use` binds is an item of the crate its path starts from (`crate::`/`self::`/`super::` = own crate; named root when the file's manifest lists it) or of project crates that crate's `[dependencies]` name, transitively (path/workspace deps, renamed keys, dotted keys; dev/build deps not re-exported) | PORT | Probe `p27-rust-private-crate-scope`: with a private `fn timeout` in `app/src/patcher/patch.rs`, `use crate::time::timeout; timeout(3)` in `app/src/user.rs` stays unresolved (post-ranking veto only, RS:1328-1335); both `type Result` aliases have `visibility` NULL. `rust_scope::RustCrates` (rust_scope.rs:23-29) is one project-wide set of crates and of all dependencies (dev/build included), with no per-crate dependency graph | EV; golden:rust possible (`lib.rs`/`consumer.rs` use paths) | extends W4-RS-01 (#2124/#2214); base for #2702, #2714; sync: manifest edits re-scope (W5-06 manifest inputs exist) | +| 65 | `1b12bf5b` | #2694 | C/C++/ObjC pre-parse rewrites Foundation enum macros in place (`typedef NS_ENUM(NSInteger, Name) {` -> `enum Name {`, offsets kept; NS_OPTIONS, NS_CLOSED_ENUM, NS_ERROR_ENUM, CF_ENUM, CF_OPTIONS, CF_CLOSED_ENUM), matching on code with comments/literals/directives masked so the macro's own `#define` is untouched | PORT | Probe `p28-objc-nsenum-docs`: `typedef NS_ENUM(NSInteger, SDImageCacheType) {…}` in `Cache.h` -> junk `type_alias SDImageCacheTypeNone`, `NS_OPTIONS` enum missing, `typedef CF_ENUM(int, CFMode) {…}` in `flags.hpp` -> junk `type_alias (int, CFMode)` (upstream's "before") | EV (nodes); golden:objc possible | ObjC pre-parse needed (row 63) | +| 66 | `6f8e6caa` | #2693 | A C/C++ source that includes no same-stem header in its own folder implements one there that it reaches through other headers (`field_def.c` -> `internal/field_def.h` -> `def.h` -> `field_def.h`) | PORT | Part of #2675/#2684's TU narrowing, which Rust lacks (row 53); `cpp_includers.rs` (CppIncluders, :71) has the transitive include walk to build on | EV | needs #2684 | +| 67 | `3273f20f` | #2696 | Objective-C doc comment above a method/function/declaration inside an `@implementation` (each wrapped in an `implementation_definition`) documents it; each wrapper holds one item | PORT | Same probe: `/// Clears everything.` above `- (void)clear {}` and `// A helper.` above `static int helper` inside `@implementation` give docstring NULL | EV (docstrings); golden:objc possible | - | +| 68 | `60b2f1e7` | #2697 | A call into a method of a project `impl` on a std type (`impl From for String`, `impl Storage for Vec`) stands only when Rust could pick it: a std trait needs an argument of the crate's own type argument (built from it, `self` in an impl of it, or a name the function declares with it); a project trait must be in scope in the calling file (declared, implemented, imported, or via a glob that may carry it); else unresolved | PORT | Probe `p29-rust-std-impl`: `String::from("x")` -> project `String::from` (0.95 qualified-name; upstream after: unresolved), `String::from(IDI::Install)` -> same (kept upstream too), `files.iter_all()` on a `Vec` with `Storage` not imported in `run.rs` -> `Vec::iter_all` (0.9) | EV; golden:rust possible (`impl_ownership.rs`) | OVERLAPS the owner-deferred narrow Rust std gate (#1987; memory `rust-member-path-std-gate-deferred`): both gate calls whose receiver is a std type; W4-RS-03 (#2169/#2177) | +| 69 | `ed895771` | #2699 | Objective-C file-scope declarations take C's declarator branch (initialized, pointer, array declarators; initializer as signature; `static const` -> constant): `NSString *const Domain = @"…";`, `static const NSInteger k = 3;`, `static dispatch_queue_t queues[4];`; ones inside `@implementation` too, qualified under the class; a global a `.m`/`.mm` defines is file-local, dropped before the pick (a header's `extern` stands for the definition) | PORT | Probe `p30-objc-globals-cpp-list`: `Err.m` yields no variable/constant node at all, not even the bare `int count;` upstream's generic fallback always read (pre-existing gap) | EV; golden:objc possible | needs #2690 (`OBJC_FILE_LOCAL_KINDS`) | +| 70 | `20431527` | #2698 | C++ declaration listing several names (`ByteBuffer a, b;`, `Foo *a, b;`, `Table *index_, *data_;`) gives each later name the declaration's type plus its own `*`/`&`; commas only at statement depth; used by receiver scan, header scan, class data members, and the bare-call local check | PORT | Probe `p30-objc-globals-cpp-list`: `ByteBuffer symbols_found, strings_found; strings_found.Size()` unresolved (first name typed at 0.9) — declarator regex NM:3729-3751 needs the type right before the name | EV | applies to #2533's member reader, #2708's local check | +| 71 | `5530676f` | #2700 | Rust `Self::x(…)` is the function (or variant, `Self::Text(…)`) of the impl's/trait's type: inherent first (cfg twins equal), a trait impl's only when unique (several `From`/`From` unresolved), own-name call in a trait impl hands on to the inherent function, in the type's own impl it is recursion; trait's own method as fallback when unshadowed; outside types only through impls beside the call; no such function -> unresolved | PORT | Probe `p31-rust-self-calls`: `Self::new(0)`, `Self::new()` and `Self::Text(String::new())` all unresolved. W4-RS-03 (#2231) covers type-position `Self::X` only (rust_scope.rs `self_path_at` :655) | EV; golden:rust possible (`self_field.rs`, `impl_ownership.rs`) | W4-RS-02 (#2354 variants), W4-RS-03 | +| 72 | `f2f5dee0` | #2701 | Rust method lookup through a `self` declared `Pin<&mut Self>`/`Box`/`Rc`/`Arc` (and values `Pin<&mut T>`) as Rust does: type's method taking that self first, then the wrapper's own, then deref; inherent before trait on paths, typed values and self; in a trait impl `fn wake(self) { self.wake() }` reaches the inherent method, never itself; `(self.f)(x)` calls a field; tuple receivers are no named type's | PARTIAL | Present: probe `p31-rust-self-calls` `self.in_scope()` with `self: &Rc` and `self.poll_write_priv()` with `self: Pin<&mut Self>` reach `Error::…` (0.9); probe `p31b-rust-inherent-first` `w.wake()` reaches the inherent `Waker::wake`. Missing: same probe, `self.wake()` inside `impl Wake for Waker` unresolved (upstream: the inherent `Waker::wake`); blanket `impl … for Pin

` exclusion, `(self.f)(x)` and tuple-receiver rules unverified | EV | OVERLAPS the deferred Rust std gate (wrapper/`Arc::from_raw` std calls); W4-RS-03 | +| 73 | `70783f31` | #2703 | Objective-C messages to an ivar or property are typed by its declaration (per-file member reader: `@interface` ivar block seen by subclasses, class-extension/`@implementation` ivar blocks, `@property` incl. two-line/IBOutlet, `@synthesize`; protocol lists, type args, `OF_GENERIC(…)`): `self.name` = a property of the class or superclass, a bare name = an ivar (own, synthesized `_name`, `@synthesize`d, superclass `@interface` ivar); typed path at 0.9, outside classes no project method; same-named `@interface` in several files narrowed to the caller's directory | PORT | `objc_scope.rs` reads `@property` types only to keep an untyped receiver's unique-name guess (objc_scope.rs:54-70, :231-300); no typed ivar/property path. Probe `p32-objc-ivar-property`: `[self.current nextEntry]` (`@property OFTarArchive *current`) unresolved; `[_archive nextEntry]` (ivar `OFTarArchive *_archive`) reaches `OFTarArchive::nextEntry` only by a 0.65 name guess with `OFLHAArchive::nextEntry` as namesake | EV; golden:objc possible | W4-SW-04 (#2150/#2179 ObjC hierarchy); needs a sync lane like the ObjC head row (`HeadRow`, objc_scope.rs:11) for header member changes | +| 74 | `6c49bfa6` | #2706 | Go receiver inference asks the scope reader first for every receiver: the in-scope declaration (param, result, grouped name, `var (…)` spec, func-literal param) gives its written named type; project type resolves in its package (embedding, aliases); outside/predeclared/alias-of-those/type literal reaches no project method; unknown qualifier keeps the name lookup; other names the type lacks go to name strategies | PORT | Probe `p33-go-param-pkg-type`: `func Apply(client rest.Interface) { client.Patch() }` -> `RESTClient::Patch` (0.65) instead of `rest.Interface::Patch`; `func TestX(t *testing.T) { t.Errorf(…) }` -> project `helper.T::Errorf` (0.8). NM:5930-5945 consults `go_ref_declared_type` only after the patterns fail and never applies the outside-type stop | EV | needs #2664's scoped-declaration rule; subsumes the W4-GO-03 import-named-receiver block; W4-GO-01 | +| 75 | `b5553e23` | #2707 | Rust `type`/`const` written directly in an `impl` is qualified by the impl type (`ValueHint::Err`, `Limits::MAX`; non-name types keep the impl spelling, e.g. `(A, B)::First`); never matches a bare name or a module path, only `Self::X` in its impl or `<…>::X`; `crate::m::X` never picks one | PORT | Probe `p34-rust-assoc-items`: `impl FromStr for ValueHint { type Err = String; … }` gives a file-scope `type_alias Err`, and the same file's bare `Err(String::new())` call links to it (0.9; the KEEP-RUST prelude rule for bare `Err` does not stop it), `io::Error` links to `impl Writer { type Error = u8; }`'s `Error` (0.9) | EV (names/ids); golden:rust possible | W4-RS-01 prelude rule (KNOWN_DIFFS "Rust calls that lost their receiver"); #2712 builds on it | +| 76 | `e3f23cc4` | #2597 | Go scope reader: a name declared in one switch/select case clause is out of scope in later clauses; parameter names inside a func-typed result (`func() func(run string)`, `*func(…)`, `chan<- func(…)`) are not the function's locals | PORT | Probe `p35-go-scope-case-result` vs control `p35b-go-scope-control`: `func f() func(run string) { run.Do() }` and `case 1: jwt := 3 … case 2: return jwt.Parse()` leave `run.Do`/`jwt.Parse` unresolved (the W4-GO-03 "a local named like an import is that variable" rule reads the over-wide scopes from `go_scope.rs`); renaming the shadowing names makes both resolve to the packages (0.9 import) | EV | fixes `go_scope.rs` (W4-GO-03, #2448) used by #2658's gate | +| 77 | `90e2456b` | #2708 | C++ bare call on a name the calling function binds (parameter, lambda parameter, local lambda/functor, range-for variable, later name in a list; nearest in an open block decides) links nothing; a local type or a function the body declares is not a local callable; expression look-alikes (`a && f(x)`) declare nothing | PORT | No C++ local-callable gate in NM::match_reference (the JS/TS rule #2226 has no C++ counterpart). Probe `p58-cpp-local-callable`: `void Gen(Formatter& format) { format("x"); }` -> `TestResult::format` and `auto key = [](int i){…}; key(3)` -> `ArenaWrappedDBIter::key` (both 0.9 exact-match) | EV (removals) | needs #2698 (listed declarators), #2439 (range-for) | +| 78 | `a31bf2f4` | #2709 | C/C++ lone-macro blanking reads a preprocessor directive above the macro as ending at its line (only a trailing `\` continues it), so `G_BEGIN_DECLS` under `#include ` is blanked and the next declaration survives | KEEP-RUST | C half: Rust never blanks lone macro lines in C (`lang/cpp_preparse.rs:1544-1554` "C++ only here: the C pre-parse stays as it was (KEEP-RUST)"; KNOWN_DIFFS.md "Kept different on purpose" -> Extraction -> "C/C++ pre-parse"). Probe `p36-c-lone-macro-include`: in `gbytes.h` (C) `typedef struct _GBytes GBytes;` after `G_BEGIN_DECLS` is lost (upstream after: kept). C++ half ALREADY-HAVE: the same text as `gbytes2.hpp` keeps `type_alias GBytes` (Rust's C++ rule already passes the `>` directive line) | EV if adopted for C | see Questions (the KEEP-RUST choice now costs GLib-style first declarations) | +| 79 | `5a7a4347` | #2710 | Rust `x.as_mut().m(…)`/`x.as_ref().m(…)` (recorded by bare name) read from the call's chain and resolved on x's declared type as `as_mut` passes it on: `Pin

` re-pins, `Box`/`NonNull`/`Rc`/`Arc` lend the held type, `Option` stays `Option` (std methods) unless `?` unwraps; type params/std/dependency types give no project method; fields read from the struct (also via pin-project `self.project()`), locals/params from their declarations incl. `let x: T = …` | PARTIAL | Probe `p55-rust-as-mut`: Rust records the bare names `reset`/`filter` as upstream does, but leaves both unresolved (KEEP-RUST P15, KNOWN_DIFFS.md "Rust calls that lost their receiver": such a call binds only a same-named method, never through a fuzzy guess or a std method's name; with two `reset`s and an Option `filter` nothing binds), so the wrong links upstream removes (`Interval::reset` self-link, `Store::filter` on an `Option`) never form: removal half ALREADY-HAVE. Missing: the positive typing, `self.delay.as_mut().reset(n)` on `delay: Pin>` -> `Sleep::reset` (unresolved) | EV (additions) | needs #2701, #2715, #2719; OVERLAPS the deferred Rust std gate (Option/Box std methods on std-typed receivers) | +| 80 | `5e72a43b` | #2702 | Rust `use` path is walked module by module from the module the `use` is in (`crate::`/`self::`/`super::`, 2018 child modules, crate name, project crates the manifest depends on): the item declared in that module (not in a fn or inline module), else the module's own `use` (macro-wrapped `cfg_sync! { pub use … }` included), else its globs; inline modules found by braces; candidates the path doesn't name are out of scope for every strategy; unfollowable paths say nothing | PORT | Probe `p37-rust-use-path-walk`: `use crate::sync::watch::Receiver;` then `fn make(r: Receiver<()>)` in `src/signal/mod.rs` -> `net/unix/pipe.rs`'s `Receiver` (0.4); the `use` line's own import edge is right. `rust_scope::is_rust_name_in_scope` (rust_scope.rs:398) checks that a `use` binds the name, not which module's item it is | EV; golden:rust possible (`consumer.rs`) | needs #2692 (crate deps); base for #2711, #2713, #2714 | +| 81 | `505c355b` | #2711 | A Rust name written through a path is an item of what the path names: a std/core/alloc/dependency-crate path names nothing of the project's in any file (unless the project is that crate or a `use` binds the root); the same-file shortcut is gone: a candidate counts only when its file is the path's module, its qualified name holds the segment, or it sits in an inline `mod` of that name | PORT | Probe `p38-rust-path-namesake`: in `src/error/mod.rs`, `&std::ffi::OsStr` -> own `struct OsStr`, `io::Error` -> own `struct Error`, `mio::Interest` (mio a `[dependencies]` crate) -> own `struct Interest` (all 0.9). rust_scope.rs `written_path` (:300) + `is_rust_name_in_scope` (:398) accept same-file candidates | EV; golden:rust possible | needs #2702 (module walk), #2692 (deps) | +| 82 | `818e7803` | #2712 | A trait associated type named `::X` (`Self` -> the enclosing impl's own item; a generic -> no impl's; a type -> its impl of that trait) or bound as `Trait`/`X: …` inside an unclosed `<` links only to what it names (a binding links nothing) | PORT | Same probe: `impl Iterator` -> same-file `enum Item` (0.9); `x: ::Io` with generic `L` -> `ReadyListener`'s `type Io` (0.9) | EV | needs #2707 (impl-qualified associated items) | +| 83 | `e2aa5d20` | #2713 | One brace-based answer to "which inline `mod` is this place in" for path candidates (`flat::Flat` without indentation found; `outer::Shell` excludes `outer::deep::Shell`; unbalanced files say nothing) | PORT | Neither #2711's inline-module test nor #2702's brace blocks exist in Rust (rows 80-81); port them brace-based from the start (upstream A/B byte-identical on its corpora) | EV | fold into the #2702/#2711 port | +| 84 | `f5158fac` | #2714 | A name only globs bring in goes through #2702's module walk per glob (from the module it is written in), stepping through modules re-exported under a name (`pub use dioxus_hooks as hooks;`, `pub use m::{self, *}`), with Rust glob visibility (inside the module: everything; elsewhere: only `pub` items, `pub use`s, `pub` globs); a glob that brings the name settles it; unfollowable globs fall back to the module-name rule | PORT | `rust_scope::rust_glob_covers` (rust_scope.rs:280-291) is upstream's "before": an item counts when its file is named like the glob's last segment, and `use super::*` takes anything in the parent directory | EV; golden:rust possible | needs #2702, #2692 | +| 85 | `23b5ca1b` | #2715 | Rust receivers typed by the block-scoped binding the call sees (new per-file scope reader: params, closure params, `let`, if-let/while-let/let-else, `for`, match-arm bindings; type = written, built-from value, or the variant/struct field the pattern takes); method chosen as Rust does (inherent, in-scope trait impl, provided trait method, blanket impl when bounds met, Deref; `&`/Box/Rc/Arc/Pin/Cow/lock guards looked through, wrapper's own methods kept; `impl Trait`/`dyn Trait`/bounded generics -> trait or supertrait method; namesake types by path); std/dependency/primitive types reach only an in-scope project trait impl; untyped bindings no longer take a type from another declaration of the name | PARTIAL | Present (shared line-pattern inferrer, NM:5900-5915): probe `p39-rust-local-receivers` `fn param(a: BuildArgs) { a.build() }` and `let r = BuildRequest; r.build()` reach the right `build` (0.9). Missing: block-scoped scope reader and pattern bindings (same probe: `Commands::Build(opts) => opts.build()` unresolved, upstream `BuildArgs::build`), Rust method-pick order, wrapper look-through, trait-object/generic bounds, std-type stop | EV; golden:rust possible (`self_field.rs`, `consumer.rs`) | OVERLAPS the deferred Rust std gate (std/dependency-typed receivers reach no project method, a superset of the narrow gate); W4-RS-03 (#2169); base for #2716, #2717, #2719, #2722, #2724 | +| 86 | `f76021db` | #2716 | Rust local bound to a method call (`let s = b.port(80).build()`, `cfg.load()?`, `c.connect().await`, `arg.get::()`) has the return type of the method the call reaches on its receiver's type (from the signature; `?` on `Result`, `.await` on `async fn`/`impl Future`, turbofish for a method type param, provided method returning `Self` = receiver's type); two impls of one generic trait pick the one whose trait arg is the first argument's type | PORT | Probe `p40b-rust-field-dep-generic`: `let x = b.build(); x.run()` (`build(self) -> Server`, an `Other::run` namesake) unresolved | EV | needs #2715; the memory note on the deferred Rust std gate names Rust `let x = f()` return-type inference as "the bigger lever" (~1,300 guessed edges) | +| 87 | `4286083a` | #2717 | Rust `for` variable is an item of what it iterates (std sequence element, map `(K, V)`, slice, std iterator / `impl Iterator` item, through `&` and deref pointers; item-keeping/projecting adapters `.iter()`/`.rev()`/`.skip()`/`.keys()`/`.values()`/`.enumerate()` looked through only when the receiver is read); a top-level tuple pattern's names take their field; a field access has its struct's declared field type; a `use … as` module alias is followed for free-function return types | PORT | Probe `p40-rust-return-for-field`: `for j in &jobs { j.process() }` with `jobs: Vec` (and a `Task::process` namesake) unresolved | EV | needs #2715, #2716 | +| 88 | `7324faf6` | #2719 | Rust `self.field.m()` resolves on the field's declared type read from the struct (wrappers looked through, `use`s of the struct's file), a struct type param known by the impl's bounds (`impl Worker`); a std/dependency value reaches a project trait impl only when the impl is for that type | PARTIAL | Present: project field types by last segment, and std/dependency field types stay unresolved: probe `p40-rust-return-for-field` `self.job.process()` -> `Job::process` (0.85); `self.inner.lock()` (`std::sync::Mutex`, project `Mutex::lock` exists) and `self.std.elapsed()` (`std::time::Instant`, project `Instant` exists) unresolved; probe `p40b-rust-field-dep-generic` `self.inner.name()` (`multer::Field`, project `Field::name`) unresolved (upstream "after" in all three). Missing: same probe, `self.store.put()` with `store: S` under `impl` unresolved; namesake types by the struct file's `use`s and the impl-for-that-type rule not covered | EV | needs #2715; golden:rust `self_field.rs` likely affected | +| 89 | `bd62d9c0` | #2720 | Rust extraction names a turbofish call by the function it wraps and drops a path's type arguments (`s.get::()` -> `s.get`, `helper::()` -> `helper`, `Pool::::new()` -> `Pool::new`) | PORT | Probe `p41-rust-turbofish-generic`: refs recorded as `m.get_one::`, `helper::`, `Pool::::new`, all unresolved | EV; golden:rust possible | - | +| 90 | `17f1453a` | #2722 | The written type of a Rust value (for `x.as_mut().m()` and calls through a `Pin`) is the binding the block-scoped reader finds in scope at the call, not a backward line scan for `x:` (which took out-of-block `let`s, struct-literal fields, and stopped at a same-line rebinding) | PORT | Rust has neither #2710's as_mut path nor #2715's scope reader (rows 79, 85) | EV | needs #2710, #2715 | +| 91 | `ac9f96f8` | #2723 | C++/Rust partial qualified-name match needs a scope boundary (the candidate's qualified name is the written name or ends with it right after `::`/`.`); own-language candidates first; a C++ name qualified by a template parameter gets no edge except to a member of the parameter's default (`typename Parser = TcParser`); C++ template heads name each parameter by its last word | PORT | Probe `p42-cpp-qualified-suffix`: `Status::OK()` -> `IOStatus::OK` (0.85 qualified-name). Rust's own suffix match is boundary-less too: probe `p41-rust-turbofish-generic` `Key::get(k)` reaches `FfiMapKey::get` (0.85 qualified-name) only because `FfiMapKey::get` ends with `Key::get` | EV; golden:cpp `namespaced_member.cpp` (exact), check `type_parameters.rs` C++ heads | must land with #2724 (Rust bounded-generic calls currently rely on the boundary-less match); W4-CPP-07 | +| 92 | `f6d8f19b` | #2724 | Rust call through a trait-bounded generic path (`Key::get(…)` with `Key: MapKey`, `trait MapKey: FfiMapKey`) resolves among the bound traits and their supertraits (function and impl/trait bounds, `<…>` or `where`); outside-only bounds, markers, or two traits declaring the method give no edge; recorded as typed (trait method's missing `pub` doesn't hide it) | PORT | Same probe: `Key::get(k)` links `FfiMapKey::get` only through the boundary-less suffix match #2723 removes; no bound reader exists | EV | needs #2723, #2715's trait helpers | +| 93 | `226ac930` | #2725 | A C++ call whose qualifier carries template arguments (`formatter::format(…)`) keeps an out-of-line member of a full specialization only when that specialization's arguments are the call's (template's own members, partial specializations', in-class members stay), in exact/partial qualified matches and `cppMethodOf`; when no member is found through a written specialization of a project class template, no name guess | PARTIAL | Missing half: probe `p44-cpp-written-specialization` `fmt::formatter::format(42, ctx)` -> `fmt::formatter::format`, the out-of-line member of `formatter` in `spec.cc` (0.95 qualified-name). Present half: `fmt::formatter::parse(ctx)` (template declares no `parse`, a `native_formatter::parse` exists) stays unresolved | EV | needs #2609 (specialization naming); W4-CPP-07 qualified matching | +| 94 | `f66d0642` | #2727 | C++ function naming walk skips `noexcept(…)`, `throw(…)` and `requires` clauses, so a qualified name inside them never names the function | PORT | Probe `p43-cpp-noexcept-unknown-class`: constructor `basic_json(CompatibleType&& val) noexcept(noexcept(JSONSerializer::to_json(val)))` indexed as method `JSONSerializer::to_json` (j.hpp:6), `alloc(int) throw(std::bad_alloc)` as method `std::bad_alloc`, `put(T) requires std::integral` as method `std::integral` | EV (node names/ids); robustness | - | +| 95 | `009e4377` | #2729 | A C++ call through a capitalized class `X::m()` that no C/C++ class/struct/union/enum/alias/namespace node names and the calling file makes nothing of (template param, local/macro-declared alias, opened/aliased/used namespace, gtest `TypeParam`/`TestFixture`) gets no shared-word guess; a project-unique method name is still taken | PORT | Probe `p43-cpp-noexcept-unknown-class`: `FeatureSet::default_instance()` (no `FeatureSet` anywhere) -> `UnknownFieldSet::default_instance` (0.7 instance-method). NM `is_undeclared_type_name` + #2166 gate (NM:6375-6395) exempts C++ (`types_only` covers C#/Java/Rust) | EV (removals) | W4-CPP-07; #2730 | +| 96 | `81fd0078` | #2730 | A C++ call through a namespace qualifier (lowercase name no C/C++ type/alias node has, not a template param/alias the file declares; a namespace the file opens confirms it) gets nothing from the method-name strategies (capitalized-receiver class, unique method, receiver-word guess); a typedef'd class (`hash_table::Insert`) and a constructor of a class named through the namespace keep their edges | PARTIAL | Present: probe `p45-cpp-namespace-qualifier` `absl::StripPrefix(name)` (project `MultiCasePrefixStripper::StripPrefix`) stays unresolved (W4-CPP-06 lowercase-outside rule). Missing: same probe, `internal::Helper()` -> `Internal::Helper` (0.8, the capitalized-receiver Strategy 2) | EV (removals) | W4-CPP-06/07; with #2729 (`cppNamesBroughtIn`) | +| 97 | `5994edb3` | #2731 | Members of an anonymous union/struct (no name, no declarator: `union { Impl_ _impl_; };`) are read as the enclosing class's data members; a union with a declarator or a partial specialization keeps its own | PORT | Rust reads no C++ data members of the caller's class at all (row 12, #2533); member chains are unported (rows 44-46) | EV | needs #2533 (`cppNestedSpans`/`cppDataMemberIn`), #2626-#2628 | +| 98 | `bdf288a7` | #2733 | A pimpl `Rep` that a header names (`struct Rep; std::unique_ptr rep_;`) and its source file defines is found by C++ lookup for code in that source (lookup sees the classes of the referencing file's translation unit, `visibleFrom(file, unit)`) | PORT | `cpp_supertypes::class_node`/`pick` (cpp_supertypes.rs:295-372) and `cpp_type_aliases::cpp_class_named` have no translation-unit visibility (the #2538 TU rule is unported, row 17) | EV | needs #2538, #2440, #2533 | +| 99 | `0c284805` | #2735 | `->` on a value of a project class follows its `operator->` (through the pointer it returns, or again on a class it returns: library holder or another such class), else its `operator*`; return type read where the class declares it with the class's template params bound to the written args (`UnownedPtr`'s `T* operator->()` is `DB*`) | PORT | No `->` target reading for project types (rows 2, 32): a `->` call on a project wrapper (`FileSystemPtr fs_; fs_->NewWritableFile(…)`) falls to the name strategies (NM:6167-6185 only stop lowercase library types) | EV | needs #2576 (`cppIteratorTarget`), #2440, #2626 (member chains) | +| 100 | `6e247115` | #2745 | Go-only synthesis pass `goFuncFieldEdges`: a call `x.F(…)` through a func-typed struct field links (calls, provenance heuristic, `synthesizedBy: go-func-field`, `field`/`via`/`registeredAt`) to each function/method value put in that field by a composite literal, an assignment `x.F = v`, or one field-to-field copy; receivers typed by the Go scope reader; channels keyed by package/struct/field; explore/node trail render "func field `A.f` (set from `B.F`)" | DEFER | Rust has no synthesis stage (W7-14, plan "W7c"); Go synthesis is W7-15 | EV (synthesized edges) | W7-14, W7-15; uses #2706's scope reader | +| 101 | `e450ae3a` | #2746 | Go method sets key an unexported method name by the directory of the file declaring the method (both sides), so an interface asking for an unexported method is satisfied only from its own package (embedded `Unimplemented…` types in the interface's package keep edges); the interface-dispatch bridge uses the same key | DEFER | Rust computes no Go structural `implements` edges or interface-dispatch bridge (no Go implements code in `crates/codegraph-resolve/src`); scheduled as W7-15 "Go implements synthesis" | EV (synthesized edges) | W7-15 (#2402, #2414, #2419, #2430, #2447) | +| 102 | `a5fe6e1a` | #2755 | Go call on an indexed element (`schemas[ix].ValidateBytes(d)`, `(*in)[i].DeepCopyInto(…)`, `m.Items[len(m.Items)-1].Unmarshal(…)`) typed as Go does (`matchGoIndexedCall`): chain head from the scoped declaration or a package-level var, values (literals, make/new/append, conversions, fields, elements, addresses, range elements), struct fields incl. promoted, element of slice/array/array pointer/map/named slice, `(*p)` dereferenced; element type's own/interface/promoted method, type param via constraint; outside/predeclared/literal/outside-alias -> nothing; methods in an unreadable file of the package read from its text | PORT | Probe `p46-go-indexed-element`: `schemas[ix].ValidateBytes(data)` with `schemas []Schema` -> `Other::ValidateBytes` (0.4 exact-match guess); the unique `DeepCopyInto` links only because no namesake exists | EV | needs #2706/#2664 scope reader use, #2667 package vars; W4-GO-03 (#2444 `go_chain_links`) | +| 103 | `1f3a274c` | #2757 | `resolveGoMethodInPackage` (every typed Go receiver) reads method declarations from the package's files the index couldn't read (over the 1 MB cap, e.g. `generated.pb.go`) from their text, and links nothing when the type declares the method there instead of a promoted embedded method; typed branch and package-value path keep that null | PORT | `go_packages::resolve_go_method_in_package` go_packages.rs:902-990 walks embedded types (:957-) with no check of files skipped by `indexing.max_file_size` (codegraph-core/src/config.rs:53-59, 1 MiB) | EV (removals) | needs #2755 (shared path), #2667; sync: an oversize file's edits must re-resolve (no node rows for it) | +| 104 | `847f1df7` | #2759 | Go implements synthesis counts methods of embedded standard-library types (a 130-type table `name:params/results` from go1.27.3, arity-gated both sides; `std:` key for unexported), an embedded `error` is recorded (stays unresolved), failed `extends` rows are read back with their package; other outside types met by a type embedding the same one or the only type with every other method | DEFER | Rust has no Go `implements` synthesis (W7-15). Rust's only Go std method list is `go_calls::GO_STD_METHODS` (go_calls.rs:25-63, 33 hand-listed names for call-shape gating, upstream's name-matcher `GO_STD_METHODS`), a different table | EV (synthesized edges, an extends ref for `error`) | W7-15; needs #2746 (`goMethodKey`), #2760 | +| 105 | `8b5d1d54` | #2760 | `scripts/gen-go-stdlib-methods.mjs` regenerates #2759's Go standard-library method table from a Go source tree with the engine's grammar and arity counter (`--write`; reproduces go1.27.3's table byte for byte) | DEFER | No Rust counterpart table or generator: the table exists only for #2759's synthesis (W7-15). Rust's `GO_STD_METHODS` (go_calls.rs:29) is hand-maintained with no generator. A port should commit the generated table plus a check-mode generator (read a pinned Go source tree, count with the Rust Go grammar), like `scripts/regen-goldens.sh --check` | - (dev tooling) | with #2759, W7-15 | +| 106 | `dbb6aa9b` | #2762 | VB.NET member reads: a method named without parentheses (`Me.Load`, `Me.New`, `MyBase.New`) resolves to the overload taking no arguments (none or only Optional/ParamArray), never the calling member (AddressOf/NameOf keep the first); a receiver that is neither value nor type is looked up as a namespace (around the read, root namespaces, Imports; `Global.`), each link a type/nested namespace/Module member; a bare field/property/Module variable before the dot counts as read | DEFER | Rust has no VB.NET (no `Language::VbNet`; plan W8-00/W8-01 adds `tree-sitter-vb-dotnet =0.1.0`, W8-02 `vbnet_receivers.rs`) | EV (once VB.NET exists) | W8-02 (#2355, #2377) | +| 107 | `bf6f1fa6` | #2763 | Dart typedef is named by the last type name before its `=`/type params/param list (legacy `typedef Report LegacyMaker(int n);` is `LegacyMaker`), and gets a `references` ref per type its aliased type names (function type return/params, generic args, record fields, type-param bounds, legacy form's return/params; annotations and import prefixes excluded; own/generic-function type params skipped unless prefixed) | PARTIAL | Naming half ALREADY-HAVE: probe `p47-dart-typedefs` indexes `type_alias LegacyMaker` (and `ReportCallback`, `Reports`), no type alias named `Report`. Missing: no outgoing refs from any typedef (`void Function(Report r)`, `List`, legacy return/param types) | EV; golden:dart possible (`extension_type.dart`) | W4-DART-03 (#2360 type-position refs, re-derived for the crate grammar) | +| 108 | `efff7457` | #2764 | A bare Go type name resolves as Go reads it (`goBareTypeDir`): the file's own package, then a project package the file dot-imports that declares it; applied to field chains, typed receivers, method values, embedded types, alias targets, package-level values and type positions; an exported name only an outside dot import can supply names no project type | PORT | `go_packages::go_dot_import_dirs` (go_packages.rs:655-700) is used only by the assertion path (:626, #2444). Probe `p48b-go-dot-import-sortfirst`: with `import . "example.com/m/controller/config"`, field `controller Controller` + `h.controller.AllConfigs()`, param `c Controller` + `c.AllConfigs()` and the type ref all reach the un-imported `aaa.Controller` (0.85 / 0.9 / 0.4) when it sorts first (`p48-go-dot-import-field`: right only when the dot-imported package sorts first) | EV | needs #2655 (field refs), #2706, #2667; W4-GO-01/02 | +| 109 | `6bd217a2` | #2769 | Every dynamic regex built from a node/reference name or source word escapes it (one helper; 114 sites), so C++ code calling `this->operator++()` no longer stops index/sync with "Invalid regular expression", `operator()`/`operator[]`/`operator+=` read their own argument lists; `size_type`/`difference_type` score as numbers in the overload scorer | PARTIAL | Crash half present: probe `p49-cpp-operator-names` (`init` and an edit + `sync` succeed; `this->operator++()` links `Iter::operator++`), and the overload readers escape the name and fail soft (`overloads::paren_list_after` overloads.rs:697-703). Overload half missing: upstream's own fixture (`__tests__/operator-method-names.test.ts`) on v0.55.1 sends `c.operator++()` and `c.operator++(0)` both to the postfix overload and both `c.operator+=(3)` and `d.operator+=(c)` to `operator+=(int)`; upstream reaches each overload, because an explicit `operator(...)` call reads its own argument list (main-thread verification). `size_type`/`difference_type` scoring and the Scala/Kotlin cases were not re-run | - | scorer half with #2541 | +| 110 | `5a6917b4` | #2773 | C pre-parse keeps a column-0 macro call that is a function's return type (`CJSON_PUBLIC(char *) cJSON_Print(…) {`, `GIT_EXTERN(int) git_blob_dup(…);`: one type-like argument, only a declarator follows, the line above leaves no declaration open) instead of blanking it as annotation markup | PARTIAL | Single-line shape present: probe `p50-c-macro-return-type` (`CJSON_PUBLIC(char *) cJSON_Print(...)` is a function node with its `print_value` call). Upstream's own fixture (`__tests__/c-macro-return-types.test.ts`) on v0.55.1 fails three shapes (main-thread verification): `unsigned long` / `ATTR(pure)` / `usable_size(...)` on separate lines gives no `usable_size` node and no call to it from `caller`; `checked_sum`'s node starts at its `__attribute__` prototype line 24 instead of the definition line 25; `api.h` emits a `calls` edge (file -> `git_blob_dup`, line 7) after the lone `GIT_BEGIN_DECL` line, where upstream expects none. The last two come from C's lone-macro rule (row 78, KEEP-RUST) | - | - | +| 111 | `c326b6be` | #2776 | Go extraction records a function-value use once per Go scope (block, if/for/switch/select implicit block, each case clause) when the function binds that name itself (func-literal params, `:=`, `var`, `const`, range/type-switch vars, select-case value), so a later unshadowed use keeps its reference; own receiver/params/results keep one reference; a file-scope func literal is its own unit | PORT | WK `flush_fn_ref_candidates` (WK:7819-7900) keys candidates by `{from_node_id}\|{name}` (one use per function and name, WK:7892-7894), upstream's "before" | EV; golden:go possible (`generator.go`/`payroll_usecase.go` function values) | must land with #2658's local-binding gate (row 48), which made the loss visible upstream | +| 112 | `929c65c8` | #2778 | Pascal pre-parse (offset-preserving, hand-written scanner skipping strings/comments/directives) blanks an RTTI attribute group at the start of a routine parameter, before or after `const`/`var`/`out`/`constref` (`const [ref] AValue`, `[MVCFromBody] const Person`), in routine headers, procedural types and anonymous methods; signatures read the source as written so the attribute stays visible | PORT | Probe `p51-pascal-attr-forvar`: `procedure WithRef(const [ref] AValue: Integer; B: Integer);` yields no method node in the class or the implementation, and the body's `After()` call is credited to the file node (`Unit1.pas -calls-> TFoo::After`, 0.4). `lang/pascal.rs` has no such pass (`pascal_include.rs` is the `.inc` sniff, W4-PAS-01) | EV; golden: none (no Pascal corpus) | base for #2781 (same pre-parse) | +| 113 | `88ebefa1` | #2781 | Pascal pre-parse blanks an inline `for var x[: Type] in` loop's `var` and `: Type` (type to the `in` at depth 0), so Delphi 10.3+ loops parse as `for x in` and paren-less calls in their body are indexed; `for var i := 0 to` and occurrences in comments/strings untouched; receiver typing still reads the declared type from the source | PORT | Same probe: `for var lItem in AList do lItem.DropIfEmpty;` inside `TFoo.After` records no call, and that method's node spans only its first line (Unit1.pas:30-30) | EV | needs #2778's pre-parse; with #2787/#2797 | +| 114 | `0c3e12dd` | #2782 | Go call on a receiver the extractor keeps no name for (a fluent chain's later link `m.WithContext(0).Where(1).First()`, a call's result `time.Now().UTC().Format(…)`, a composite literal `GitOracle{}.Worktree()`) is typed link by link at the chain's column: call results (incl. multi-value), conversions, composite literals, generic calls with type args, embedded fields, package vars from their initializer call; the method Go selects on that type; outside/unreadable types link nothing; repeated names bind the later call | PORT | Probe `p52-go-chain-links`: after `model.WithContext(0)` (typed, 0.9) the `.Where(1).First()` links go to `Query::Where`/`Query::First` (0.4 exact-match) instead of `DB`'s, `GitOracle{}.Worktree()` -> `Other::Worktree` (0.4), `time.Now().UTC().Format("x")` -> project `Layout::Format` (0.9). W4-GO-03's chain gate (`go_calls::go_call_shape`/`is_go_call_target`, go_calls.rs:98-268) only restricts method-vs-function | EV | needs #2667, #2706, #2755 (`goChainLinks` typing); #2664 | +| 115 | `800e582d` | #2784 | Go: a call whose target is a type (conversion `Category(s)`, `(*Pair)(p)`, `model.Kind(3)`) is a `references` edge, not calls/instantiates; two files of one directory under different package clauses (`package a` vs `package a_test`) see each other's top-level names only through an import; a definition with build-constrained twins (GOOS/GOARCH file suffixes, `//go:build`/`// +build`, default tags) is reached in the twin that builds for the most typical target the referencing file builds for (linux/amd64, then darwin/arm64, windows/amd64, …) | PORT | Probe `p53-go-conv-xtest-buildtags`: `Category(s)` -> `calls Category`, `(*Pair)(p)` -> `instantiates Pair`; `helper()` in `b_test.go` (`package a_test`) -> package `a`'s `helper` in `a.go` instead of `a_test.go`'s; `sepName()` in `use.go` -> the `//go:build !unix` twin `sep_other.go` | EV; golden:go possible (`generator.go`/`nightly.go` conversions) | W4-GO-01 package dirs (#2361); #2667 build-tag twins rule; sync: a `//go:build` edit re-picks twins (needs a sync-vs-fresh case) | +| 116 | `0953084b` | #2787 | Pascal extraction walks a call's receiver chain and records each paren'd call in it, with calls in its arguments and indexes (`MD5FileSized(TMeta.ExtendedPath(P)).IsSame(K)`, `A(1).B.C`, `List[GetIndex(x)].Free`), naming a chain link only when precise; a bare-name Pascal call resolving to a type is a cast and gets a `references` edge (not instantiates/calls) | PARTIAL | Probe `p54-pascal-chain-parenless`: `MD5FileSized` and `TMeta.ExtendedPath` inside `MD5FileSized(TMeta.ExtendedPath('x')).IsSame('k')` are recorded (0.4 / 0.85) — present; missing: the outer link is kept as the unresolvable `MD5FileSized(TMeta.ExtendedPath('x')).IsSame`, and the cast `TWorker(Sender).Before` -> `instantiates TWorker` (0.9). All of these are credited to the file node: Rust walks no Pascal routine body under its routine (probe `p54b-pascal-control`, KNOWN_DIFFS.md:102-110) | EV | needs the Pascal body-scope fix (see Questions); with #2778/#2781 | +| 117 | `407efb1c` | #2797 | Delphi paren-less calls (`Before;`, `X := FProvider.Value + 1`, `if Ready then`) are recorded with their use (statement, value, event method, receiver), the routine's class and a receiver's declared type, excluding routine declarations, class/unit data, assigned/Inc/Dec'd names, conventional data names and `with` bodies; a new Pascal scope resolver links them only by Delphi scope (class and ancestors, unit, used units last-first, receiver's declared type), data links nothing, functions call, procedures-as-values/event methods/arg-needing routines are references; `class sealed (TBase)`/`class abstract (TBase)` name ancestors; function values capture only `@Handler` | PORT | Probe `p54b-pascal-control`: in `TWorker.Run`, `Before();` links (credited to the file node, 0.4) but `Before;` and `if Ready then` record nothing. Ancestors: probe `p54c-pascal-sealed-heads` gives no `extends` edge or ref even for `TPlain = class(TBase)` (Rust's PascalSpec, lang/pascal.rs, reads no heritage — pre-existing gap vs upstream `extractPascalDeclType`) | EV | needs the Pascal body-scope fix and heritage extraction (see Questions), #2787 | + +### Families in pass A + +Row numbers in brackets. Every family below is graph-semantic (EV) unless noted. + +- **C++ declaration reading for receivers** [1, 7, 8, 10, 13, 14, 23, 24, 26, 31, 70]: #2439, #2492, #2493, #2531, #2536, #2540, #2552, #2553, #2555, #2573, #2698. Extends W4-CPP-06 (`infer_cpp_receiver_type` NM:4231, `build_declarator_regex` NM:3729, `cpp_code_of` NM:3836). Rust reads one line at a time, comments only blanked, one template list, type right before the name. +- **C++ held types, iterators, dereference, containers, `operator->`** [2, 9, 16, 32, 33, 34, 35, 36, 42, 99]: #2440, #2530, #2539, #2576, #2579, #2598, #2601, #2602, #2616, #2735. None present; NM:6167-6185 is the only `->` rule. +- **C++ `auto`/chain/return typing** [11, 27]: #2532 (PARTIAL), #2556. Builds on `infer_cpp_auto_initializer_type` NM:3906. +- **C++ class members and member chains** [12, 44, 45, 46, 97, 98]: #2533, #2626, #2627, #2628, #2731, #2733. Needs a C++ member surface and a sync lane. +- **C++ implicit `this`, gtest fixtures, local callables** [4, 15, 22, 77]: #2479, #2537, #2551, #2708. +- **C++ overload selection** [18, 25, 39, 43; scorer half of 109]: #2541 (PARTIAL), #2554, #2612, #2618, #2769's `size_type`. Reuses `cpp_namespaces::cpp_overload_fit`. +- **C++ class/qualified lookup and namesakes** [20, 21, 28, 29, 30, 91, 93, 95, 96]: #2548, #2549, #2567 (PARTIAL), #2568, #2569 (PARTIAL), #2723 (+Rust half), #2725 (PARTIAL), #2729, #2730 (PARTIAL). Extends W4-CPP-04/05/07 (`cpp_type_aliases.rs`, `cpp_supertypes.rs`). +- **C/C++ translation-unit visibility and include narrowing** [17, 40, 41, 53, 59, 66]: #2538, #2613, #2615, #2675, #2684, #2693. Extends `cpp_includers.rs` (W4-CPP-09) and RS:1041 static rule. +- **C/C++/ObjC extraction** [19, 37, 38, 62, 63, 65, 67, 69, 78, 94, 110]: #2542 (out-of-line nested class names + constructions), #2605 (macro-defined methods), #2609 (specialization names + choice), #2690, #2691, #2694, #2696, #2699, #2709 (KEEP-RUST), #2727, #2773 (PARTIAL). Node names/ids change for #2542, #2609, #2727. +- **Objective-C resolution** [73]: #2703 (ivar/property typing). +- **Test-path classification** [5]: #2484 (`codegraph-core/src/file_class.rs`). +- **Go receiver typing through the scope reader** [3, 6, 51, 52, 74, 76, 102, 103, 108, 114]: #2478, #2489, #2664, #2667, #2706, #2597, #2755, #2757, #2764, #2782. Extends W4-GO-01..03 (`go_scope.rs`, `go_packages.rs`, `go_calls.rs`); #2597 fixes `go_scope.rs` bugs visible today. +- **Go package, import and build semantics** [48, 50, 115]: #2658 (PARTIAL), #2660, #2784. +- **Go extraction** [47, 49, 54, 55, 56, 57, 111]: #2655, #2659 (type refs), #2678, #2679, #2680 (docs), #2682 (PARTIAL, var blocks), #2776 (function values per scope). +- **Go synthesis, deferred to W7** [100, 101, 104, 105]: #2745 (W7-14/15), #2746, #2759, #2760 (W7-15). +- **Rust paths, uses and scope** [64, 75, 80, 81, 82, 83, 84]: #2692, #2707, #2702, #2711, #2712, #2713, #2714. Extends W4-RS-01 (`rust_scope.rs`). +- **Rust receiver typing and method choice** [68, 71, 72, 79, 85, 86, 87, 88, 89, 90, 92]: #2697, #2700, #2701 (PARTIAL), #2710 (PARTIAL), #2715 (PARTIAL), #2716, #2717, #2719 (PARTIAL), #2720 (extraction), #2722, #2724. Rows 68, 72, 79, 85, 86 (and 88) overlap the owner-deferred narrow Rust std gate (#1987). +- **Swift** [58, 60, 61]: #2683 (Windows `try!`, crate bump to tree-sitter-swift 0.7.4), #2686, #2689. +- **Pascal/Delphi** [112, 113, 116, 117]: #2778, #2781 (pre-parse), #2787 (PARTIAL), #2797 (paren-less calls + `pascal-scope`). +- **Dart** [107]: #2763 (PARTIAL). +- **VB.NET, deferred to W8** [106]: #2762 (W8-02). +- **Robustness** [109]: #2769 (PARTIAL: no crash today; explicit `operator(...)` calls do not read their own argument lists for overload choice). + +## B. JS/TS, React, Vue, routers, Python, sync, explore, tooling + +| # | Upstream | PR | Behavior (one line, Rust-neutral) | Disposition | Rust target / evidence | Graph impact | Depends on / overlaps | +| --- | ---------- | ----- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------ | ----------------------------------------------------------------------------------------------------------------------------- | +| 1 | `cd97bb37` | #2428 | `codegraph context` call paths label every synthesized hop with the one shared wording explore and the node trail use (`describeSynthesizedHop`: summary + call-path-only detail + `@registeredAt`), not `event …`; footnote reads "Hops marked `[…]`" | DEFER | W9-01 (`codegraph context` absent at 4a7e158; frozen contract predates this). The contract must absorb: call-path hop label = `

@site` per `src/graph/synthesized-hop.ts` (callback via \`via\`/a registrar; HTTP METHOD href + " — the client's call onto its own route"; queue job \`event\` + " on \`queue\`"; socket message/bus event \`event\` + " → server/→ client"; event \`event\`; React re-render via setState; renders /a child component; Vue @event/a template event handler; interface → impl / interface → method promoted into X; runs \`field\` handlers; fn-pointer via; GoFrame route r; default = synthesizedBy with `-`→space) and the new footnote text. The explore/node-trail `dynamic: @site` half needs synthesized edges first (W7-14, W7-06); Rust renders none today (`rg synthesizedBy crates/codegraph-mcp` = no hit) | - | W9-01, W7-06, W7-14; #2414 (promotedInto, W7-15) | +| 2 | `b994365b` | #2452 | sync: a route rendering a same-file `lazy(() => import(...))` value relinks when its module is added/changed (`lazyModules` + `reopenRouteModuleReaders`); a sync adding a JSX-renderable node redraws jsx-render edges from unchanged files | DEFER | Route half: React Router lazy routes and `declaredComponent` (#2400/#2436) are W7-09, their sync relink W7-23 (no `frameworks/react_router.rs`). JSX half: upstream's edge is the synthesized jsx-render `calls` edge (W7-14); Rust's static JSX-tag `references` edge (WK:8082 `extract_jsx_component_ref`) already converges: probe `p02-jsx-new-component` (unchanged `App.tsx` renders ``, ``; add both modules; sync == fresh, `references App->Team/Other` present) | - (sync only) | W7-09, W7-14, W7-23; #2400, #2436 (prior audit, W7-09) | +| 3 | `33c14361` | #2432 | a default import binds what the module's own `export default` statement declares (by position) or names (by name); an anonymous default function/class/arrow is no node; only an expression default, an undeclared binding or no statement keeps the first-exported guess; `require('./x').default` reads the same statement | PORT | IR:2611 `esm_default_export` reads only an `export default NAME` alias, else the first exported function/class. Probe `p03-default-decl`: `import Vans` from a file with `export async function loader` above `export default function Vans` gives `calls main->loader`; `new Store()` -> `helper`; anonymous default -> `guess` (upstream after: Vans, Store, nothing) | EV | #2433/#2189 (W4-JS-04, IR:2515-2611); #2481 (row 7) pins it | +| 4 | `34183992` | #2475 | a JSX tag (and a Vue template tag/handler) the file imports from a declared package renders no same-named project component; a package-imported Vue tag no longer falls back to a Nuxt auto-import | DEFER | Rust's JSX tag is a static `references` ref (WK:8082) resolved first by the React resolver's Pattern 1 (`frameworks/react.rs:58-66` -> `resolve_component` :356, same-dir/component-dir/unique, never reads imports), so NM's out-of-repo rule (NM:2852, NM:2874 `is_out_of_repo_binding`) is never reached. Probe `p04-jsx-package-tag` (antd/@mui/react-router-dom declared): `