Repository navigation
fix(vbnet): link reads through a namespace or a bare member name, and run the parameterless overload (#2305) - #2762
Merged
Conversation
… run the parameterless overload (#2305) Three kinds of VB.NET member read that #2355 and #2377 left unlinked: - A method named without parentheses (`Me.Load`, `Calc.GetTargetDAR`, a constructor's `Me.New` / `MyBase.New`) went to the first overload declared, so `Me.Load` reached `Load(path)` instead of `Load(Optional force = False)`, and a `Me.New` whose first overload was the calling constructor itself linked nothing. - A read whose first name is a namespace (`Billing.Invoice.MaxLines`, `StaxRip.UI.ButtonEx.ButtonSymbol.Delete` with the root namespace in front, a Module's `RedGifs.RedGifsSiteKey`) linked nothing: the receiver was looked up as a value or a type only. - A field, property or Module variable named bare before the dot (`Button1.Text`, `Settings.Plugins`, staxrip's global `p.TargetWidth`) was not counted as read: a bare name is no member access, so only what is read through it could link, and nothing when that is .NET's (`Text`). Fix (src/resolution/vbnet-receivers.ts; resolution only, extraction output unchanged): - A method a reference runs without parentheses resolves among its type's overloads to one that takes no arguments (none, or only Optional and ParamArray parameters, read from the declaration), never the member the reference is in. AddressOf / NameOf keep the first overload, as before. - A receiver name that is neither a value nor a type is looked up as a namespace the way VB.NET does: nested in a namespace around the read, outward to the root namespaces, then in the file's and project's Imports. Each further link is a type declared in it, a nested namespace, or a member of one of its Modules. The read links the type (`Billing.Invoice`) or the member (`Assets.Logo`), as #2355's `Outer.Mode` reads do. - A bare name before the dot that VB.NET binds to a field, property or Module variable (not a local or parameter, which hide it) is linked as a read alongside what is read through it. Not for a `With` block's `.Text`, a method run through the name (the call is the method's alone, as with parentheses), another project's Module, or a member declared with an outside type of its own name (`Responser As Responser`), whose Shared members and nested types VB.NET reads through the type; a project type of its own name follows #2377's Color Color rule. - membersNamed looked a type's members up in every project's same-named type and memoised the list by qualified name alone, so SCrawler's two plugin `UserData` classes shared one list ordered by whichever was asked first. It now keeps to the type's own project. Alone this leaves main's graph unchanged on SCrawler and staxrip; without it, 17 of the new bare-name reads in one plugin linked the other plugin's members. Dropped from the 2026-10-04 test set: a method named through its class also linking the class (#2355 treats it as a call, and its test pins that); `AppSession.SessionId` through a property typed OtherSession linking nothing (#2377 links OtherSession's field, pinned the same way); `SCrawler.My.Resources...` reads (#2355/#2377 send no path that starts with `My` or `Global`); and same-named classes picked by namespace, Imports and project, which main already does once the fixture declares its RootNamespace. Verification: new vbnet-member-access-scope.test.ts (9 tests) fails 6/9 on main and passes; a mutation that restores main's membersNamed fails the own-project test. The other VB.NET, C#, extraction, resolution, sync and framework suites pass; tsc and build clean. Validation, main vs this branch (indexes from each arm's own build; nodes unchanged; self-loops unchanged; serilog and gin dumps byte-identical): - SCrawler 31,201 -> 36,378 edges. 1 removed: `COLOR_PICKER.ColorsGet` re-pointed from the two-argument overload to `ColorsGet() As DataColor`. Added: 4,973 bare-name reads (3,731 own class, 957 Module variables, 285 inherited), 192 namespace reads, 12 reads through a Module member reached by namespace, and that 1 overload. - staxrip 70,864 -> 83,909 edges, 0 removed. Added: 12,983 bare-name reads (8,991 own class, 3,820 Module variables, 172 inherited), 61 reads with the root namespace in front, and `box.Show` reaching `Function Show() As DialogResult` from its Shared overload. - Checked against source: every bare-name read's name starts the access, has no local of that name, and binds to its class, an ancestor (23 through a qualified `Inherits Instagram.UserData` the graph's own extends edge misses) or a Module of its project; every namespace read's path ends its target's full name and the target's project is the reader's or one it references; no edge crosses between staxrip and its AutoCrop tool; 48 sampled edges hand-checked, all correct. - Cost (5 interleaved rounds, medians, quiet machine): SCrawler wall 5.60 -> 5.75 s, CPU 19.5 -> 20.3 s, DB 43.4 -> 45.1 MB; staxrip wall 7.23 -> 7.11 s (noise), CPU 25.7 -> 26.3 s, DB 59.0 -> 64.4 MB, the growth being the new edges (unresolved refs fall 47,074 -> 43,607 and 38,051 -> 36,165). Not covered: a call through a bare name (`Button1.Focus()`) or a function named before the dot, reads in a `With Button1` block, and `My.` / `Global.` paths. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
bompus
added a commit
to bompus/codegraph
that referenced
this pull request
Oct 29, 2026
…ons it exposed (#582) * fix(resolve): port upstream's lone same-file match confidence (cde4cd7) A lone same-file definition chosen by findBestMatch scored by directory proximity (0.7/0.4), losing to a framework's naming guess in another file. is_decisive_same_file_match scores it 0.9 when it is the only same-file candidate, is not the caller itself, and, as a member, belongs to an owner the caller is inside. Ports upstream cde4cd7 (colbymchenry#1938). same-file-match-confidence: 7/7. * chore(resolve): dump the kernel profile at close(), not only at drop The resolver is not dropped before process exit on the CLI index path, so CODEGRAPH_KERNEL_PROF=1 accumulated timings that never printed. close() is the deterministic teardown point. * test(ts): assert the fork's native error-tree path for export type * Upstream's kernel defers a file whose parse tree has errors, so the test expected tryKernelExtract to return null. The fork's tsjs walker extracts the recovered tree natively (cba9256) and keeps the re-export signature as written — assert that contract instead. * fix(resolve): port upstream's indexed import-path spelling (8651990) An alias, workspace or direct-path join kept a specifier's lexical spelling, so `@/widgets/Chart/` probed `Chart//index.tsx` and `src/widgets/./Chart` probed `./` segments no files row is keyed by. probe_extensions now spells each candidate as the index keys it for the ES-module family; other languages keep the path as found. Ports upstream 8651990 (colbymchenry#2792). import-path-spelling: 5/5. * fix(resolve): port upstream's Dart library-privacy rule (f7820b5) A Dart `_name` is private to its library — the library file and every file its `part` directives name — not to its file. private_is_file_local drops `dart`; is_visible_across_files gets the dart arm (a private candidate is seen only from a file of its own library); and the exact-name pre-pick filter declines a private candidate another library declares so the caller's own library's declaration wins. Ports upstream f7820b5 (colbymchenry#2832). dart-part-privacy: 10/12 — the two remaining failures resolve a typed receiver's private method through resolve_method_on_type's member path, whose visibility gate still needs tracing (upstream's dart arm at name-matcher.ts ~13147 / preferOwnDartLibrary is the next suspect). * fix(resolve): vet every strategy's pick through is_visible_across_files finish() applied name_post_guard but not the file/library-locality veto resolveOne's nameResult gets at index.ts:1867, so typed-receiver picks (instance-method) linked private members of another library. With the dart arm in place this completes f7820b5: dart-part-privacy 12/12. * fix(library): indexFiles keeps other writers out until its files are stored The file lock was released as soon as indexing started — the promise returned unawaited, the try ended, the finally let the lock go. Awaited, the lock now holds until the files are stored, as indexAll and sync hold it (upstream 865ddf4 / colbymchenry#2845). * fix(resolve): let a framework own a reference past the name strategies settleKernelOutcome merged kernel candidates beside the frameworks', so a project namesake could answer a call Nuxt's navigateTo owns (upstream 58eb57a / colbymchenry#2826). With ownsReference set, the frameworks' best answer wins or the ref stays unresolved. * test(vue): assert the fork contract for tsx blocks — grammar always compiled in Upstream's test asserted wasm-preload sets (9ee6718 / colbymchenry#2824); the fork has no wasm loader, so a tsx <script> can never lack its grammar. The block-mapping half was already fixed in sfcScriptLanguage. * fix(resolve): finish() visibility guard on the final node, name picks only Two corrections to the finish() is_visible_across_files port: - Run it on the node after supertype/overload/alias retargets, the way upstream vets the target matchReference reports — a pre-forward object property or import alias is not the node upstream inspects. - Vet only name-matcher picks: upstream's guard sits inside the matchReference arm, so import, file-path and framework results never reach it. An import pick's alias forward can legitimately land on an unexported module member (export const api = { run: right }). Also ports the Rust arm upstream added for typed receivers: a method a trait declares carries no pub of its own — reached through a typed receiver it is the trait's (rust_trait_of + rust_typed_refs, marking rust_written_call exits). Fixes the rust-* regressions the guard exposed (rust-typed-receivers, rust-receiver-chains, rust-generic-bound-paths, rust-method-value-types, rust-self-field-types, rust-wrapped-self-calls) while keeping dart-part-privacy 12/12. Remaining exposed failures are import-binding port debt, not guard bugs: items$.getState().inc (import-type-modifier) and styled(Disclosure) (function-ref-project-imports) resolve upstream through the import path the kernel does not fully carry. * feat(kernel): port Go value-type inference, indexed/chained/package-value call arms Port goReceiverChainType/goElementOf/goPackageValueType semantics tree-natively into the kernel: package-level var/const typing, indexed and chained receiver calls, and declared-type terminal vetoes for literals/outside types. Bound-receiver misses are terminal unless the receiver is an asserted local the index cannot type (upstream strategy-3 passthrough). TS gateTargetKind gains the missing upstream arms (import self-edge, Go extends qualification, dot-imported supertypes) and goBareTypeDir for type-position targets. * fix(kernel): resolve Go package-value calls at typed-receiver confidence Upstream's matchGoPackageValueCall resolves at 0.9; the arm inherited go_method_in_package's 0.85. * feat(kernel): Go element/field/call-result expression typing goElementOf (named slice/map types resolve through their declarations), goFieldTypeOf (struct field written types), selector-expression and call-expression result arms in go_expr_written. Param/decl locals the declaration reader misses fall back to infer_local_receiver_type. * feat(kernel): Go chained/generic receivers, range elements, unread-file methods * feat(kernel): Go build-constraint twins, external test packages, conversion refs (colbymchenry#2581) Port upstream 800e582's three Go semantics into the kernel: - A `pkg.Type(…)` conversion resolves its type through the import member arm — the kind filter now accepts Go exported member kinds (struct/interface/type_alias/variable/constant), which the TS edge-kind rewrite then turns into a `references` edge. - `go_name_visible` is clause-aware: files sharing a directory but declaring different package clauses (`a` vs `a_test`) see each other's bare top-level names only through an import — qualified, or bare after a dot import and exported. - New `go_build.rs` ports `goFileConstraint`/`preferGoBuildTwin`: `//go:build` and `// +build` expressions plus `_GOOS`/`_GOARCH` filename suffixes evaluate against the ordered GO_BUILD_TARGETS; a resolved target with constrained twins retargets to the twin the reference's own file builds with, and `go_pick_twin` collapses multi-candidate package members the import arm couldn't pick. Also fixes the fork's `go-type-visibility.ts`: module-root packages spell their dir `''` (matching `getGoPackageDir` and kernel `pos_dirname`), so `goTypePositionTarget` retargets a namesake function to the module-root type. * feat(kernel): VB.NET namespace receivers, overload pick, head members (colbymchenry#2762) Port upstream dbb6aa9: VbReceiver gains a namespace arm (vb_known_namespaces/vb_namespace_around/vb_namespace_named/ vb_types_in_namespace/vb_module_member_in) so reads like Billing.Invoice.MaxLines and Acme.Billing.Invoice.MaxLines link the type or Module member the namespace declares; vb_takes_no_arguments + vb_runnable_overload pick the overload VB.NET runs when a method is named without parentheses (Me.Load, Optional/ParamArray, a ctor's Me.New never resolves to itself); vb_head_member + vb_with_head link a bare member before the dot (Button1.Text) when no local or parameter shadows it, gated by foreign-Module and outside-namesake checks. vb_receiver_type's member search is extracted as vb_member_around. * feat(kernel): workspace package entries, path deps, manifest-edit sync (colbymchenry#2502, colbymchenry#2456) Port e8ddc4e's declared-entry import resolution into the kernel and its sync-side invalidation into codegraph.ts. Kernel (napi config grows entriesByDir + scopedByName): - resolve_workspace_import takes from_file; workspace_import_targets tries declared entries first — exports (exact, wildcard, fallback arrays, nested conditions), then source/module/main/types/typings in order — then an indexed direct probe, then emitted→source mapping, then the direct probe as last resort. Path deps (file:/link:/portal:) resolve scoped by the importer's nearest manifest, before global names; longest package name wins. - imports.rs gains longest_package_name/match_workspace_package/ declared_workspace_entries/indexed_target/built_source_of plus WorkspaceTargets/exported_targets/built_sources_of; prefilter passes the importing file through. TS sync side (upstream index.ts port): - resolver: refreshWorkspacePackages/getWorkspaceFingerprint/ workspacePackageDirOf; a moved map closes the kernel since the config is construction-time. - codegraph.ts: js_workspace_fingerprint metadata stamped at index and re-checked on full reconcile; a moved fingerprint re-opens every ESM-language ref for the orphan sweep. reopenReferencesThroughAddedFiles gets packageDirOf so a late-appearing declared entry re-links importers. - loader.ts KernelWorkspaceIn + serialization gain the two new maps. workspace-package-entries: 26/26. Regression sweep: 146/147, the one failure a pre-existing tracked bucket (7180fd0 colbymchenry#2788). * feat(kernel): a call on a this-field element resolves on the element's type Port 449eefa's resolver half: `this.items[0].save()` arrives as `this.items[].save` from the extractors (already ported) and now binds the element type the field's declaration writes instead of bare-name matching any project method. - method_call_shape: elementOf arm `^this\.(#?[\w$]+)\[\]\.([\w$]+)$` → match_ts_this_field_call(field, method, r, element=true) — exclusive, like the plain `this.field.m` arm. - TsFieldDecl gains element; ts_field_element_type reads it off the written type (`Item[]`, `Array<Item>`, `ReadonlyArray<Item>`, `Record<string, Item>`) and rejects unions, arrays of arrays and non-plain elements; ts_field_element adds tsFieldRead's multi-line continuation guard (`| Other[]` on the lines below). - ts_field_held filters element reads through ts_class_type_parameter — `class Store<Item> { items: Item[] }` holds no project `Item`. - ts_class_type_parameter ported upstream: `class|interface|type` keyword anchor, 24-line multi-line head, returns true when the list's `>` is not found (drop the type rather than take a parameter for a class). ts-this-field-element 11/11; expression-receiver-calls + ts-array-annotated-receivers green; receiver sweep shows only tracked debt (08478ee colbymchenry#2811, 013b91c colbymchenry#2825); golden dumps unchanged. * feat(kernel): calls on a typed local or parameter reach the builtin-named method (colbymchenry#2821) A python call `reg.get()` on a builtin-named method was dropped by the builtin filter before any strategy could read the receiver. Port matchPythonTypedLocalCall (colbymchenry#2583) into python_attribute_verdict: a plain local or parameter receiver settles only through scope evidence — `python_local_class` agrees a binding def's parameter annotation (quoted, Optional[T], Union[..., None], T | None, read off the raw def header) or its assignments (ctor/factory/None; any foreign binding shape, rebinding or contested evidence refuses). Members come from `python_strict_members` — the class's own or a declared base's, resolved through the file's imports, so a base from outside the project holds none of its methods and the extends edges never substitute a same-name class. Sync side: FAILED_PY_ATTR_REF widened to the one-dot `x.y` shape. The fork's delta-narrowed retry keys (perf/sync-delta-retry) never list an unchanged name like `get`, so a signature-only edit to the factory a failed typed-local call reads its type from gave no retry key; the attr-retry lane kernel-probes candidates and retries only resolvable ones, which also lands the edge's typeFrom stamp for future edits. * feat(kernel): a call on an unqualified call result resolves on its return type (colbymchenry#2822) `repository().pending()` — and `val repo = repository()` locals — type the receiver by the inner call's declared return, so `pending` is the method the returned project type declares, never a same-named method elsewhere. A type from outside the project leaves the name strategies untouched, and an extension the bound-member walk can't see keeps the old name match. The extractor's return_type keeps only a user_type's first identifier (`Request`), so `kotlin_scoped_hit` retypes the callee through its signature (`(): Request.Builder`) and writes a lone nested name through its declaring outer (`Builder` → `Shop.Builder`). Two pre-existing filters were misaligned with the kotlinCall/kotlinBare split this relies on: member-scope reachability vetted receiver-written names (`text().reverse`) as if receiver-less, and a Chain-shape call with a non-project receiver type (`StringBuilder`) vetoed every name match — upstream only constrains standard-library names there. Both now match upstream's isReceiverLessKotlinCall / kotlinStdChain boundary. Also: python_local_class returns Option<Answer> — a name no enclosing def binds (module-level, global) is upstream's `undefined`, not a refused local, which restores module-global `store = Store()` receivers the strict arm claimed and dropped. * feat(kernel): non-test refs resolve as if Jest manual mocks were absent (colbymchenry#2790) Port upstream e69546e's mockless context: a ref from non-test code resolves on a graph without the project's __mocks__/ files, while test code keeps the whole graph. resolve_ref sets a per-ref mockless flag; nodes_by_name, nodes_by_lower_name and nodes_by_qualified_name then drop __mocks__/ nodes (gated on the cached mock-name sets so unaffected names aren't re-collected). The TS callback-synthesis guards were already in place. Also fix ts_scoped_reference's type-ref tail: upstream importedTypeMember falls through (undefined) on a found-miss unless the specifier is outside the repository — a resolved package directory whose exports can't be read is not a refusal. The old gate refused references/extends refs bound to a no-entry workspace package, which upstream answers by name-match. * fix(sync): record files a JSX tag import reads through as synthesis inputs (colbymchenry#2563) collectSynthesisInputs only kept files whose own content matched mayFeedSynthesis, so a barrel or index that merely forwarded another module's component was never recorded as an input. When a later sync edited only that index, the JSX pass never reran and the tag kept its stale endpoint. Port upstream's importedTagModules: for each JSX-bearing file, map its capitalized tags to project imports and collect every file exportedComponent reads through, memoized per collection run. * feat(kernel): resolve Rust calls by the receiver's written type (colbymchenry#2831) Port upstream 8fdc8a1: a field chain or struct literal receiver's declared type decides the call — `vis.map.get` is HashMap's, `Xyz{}.to_val` is Xyz's — and a path call naming a type std or a dependency owns reaches only the project's impls of that type or the named trait, never a project namesake. - rust_expr_type types tuple-struct/enum-variant constructor calls - undeclared-type guard limited to plain named `field_expression` heads, exempting generics, Self, outside types, use-aliases and wrapper-own methods; derived-trait provided methods resolve through `#[derive]` - rust_path_call_reachable gates name-match on the path's outside type Rust sweep 28 files/206 tests green; kernel golden dumps clean; the 16 remaining full-suite failures are all tracked port debt. * feat(kernel): scope named class expressions and export them over CommonJS (colbymchenry#2825) A named class expression is a class bound inside its expression: index its members and supertypes, but resolve references written outside the expression on a graph where that class and its members are not — a same-named declaration or binding keeps its links, and `new Widget()` elsewhere links nothing. References written inside see the whole graph unless the name is another expression's, bound inside that one alone. `module.exports = class Router` / `exports.Store = class StoreImpl` are the module's value: the class stays reachable to every importer, and collect_cjs_export records the declared name as the export's local binding. Inheritance refs resolved through an import binding emit upstream's import confidence 0.9; the scoped arm's 0.95 stays for type-position references. * fix(kernel): a call or new never lands on an interface or a type alias (colbymchenry#2801) Nothing calls an interface or a type alias, or makes an instance of one. A calls/instantiates result that found a TypeScript type by name or through an import meant the value its file declares beside it — the function under `interface Ok` in a result module, the class merged with an interface — and a global the project only types, like `new Response()` or `new Worker()`, links nothing. * fix(kernel): an explicit operator call reads its own argument list tree-sitter-cpp parses `d.operator+=(c)` as a call on the receiver alone, with the operator's name stranded in an ERROR sibling (`function: (identifier) (ERROR ".operator+=") arguments: (c)`), so the callee never spells `operator+=` and cpp_call_argument_types found no call. Every overload then tied at 0 and the first — `operator+=(int)` — took a call that `operator+=(const Counter&)` fits. Accept a call whose error spells the operator name (the member-access dot is part of the error text), so the argument types are read and the class overload wins. `size_type` and `difference_type` count as numbers now, the container convention upstream uses (6bd217a): nlohmann/json's `p->operator[](0)` reaches the index overload, not the `T*` one. * fix(kernel): a typed-local receiver keeps the invocation-time binding The colbymchenry#2821 port (0b564c78) settled a builtin-named method call through pythonLocalClass alone, which refuses when a name is bound more than once. `store = A(); store = B(); store.get()` then resolved to nothing, though the fork's receiver-scope rule has always read the binding in effect at the call (B). Read that binding: among plain assignments at or before the call, the last one decides, and a bare annotation (`store: B`) does not rebind. python_receiver_uncertain still holds back a same-line replacement and a later replacement a closure's captured cell sees, and a later binding no longer poisons an earlier one when the call reads before it. A def's parameter keeps its annotation when nothing rebinds it. Three shapes the strict read owns stay with it: a binding that is not a plain assignment (a branch, loop, `with`, comprehension), a base from outside the project, and a future binding read from a lambda body. A receiver naming a class declared here (`File.write(f, "x")`) and a lambda parameter of the receiver's name keep the ordinary paths. * fix(resolve): vet only name picks through a module's unexported bindings 2ca95adb applied isVisibleAcrossFiles to every strategy's pick. Upstream guards just the name match (index.ts:1867), and the port's ESM leg vetoed picks that were never name guesses: a typed store action (`items$.getState().inc()`) and an imported component function value were both dropped as unexported module bindings. Keep every language's privacy rule for a structured pick, and skip the ESM export check for a pick a receiver's type or a function value made. * test(eval): record the json, flask, vite and svelte precision runs Every case held on each corpus (json 11 absent + 7 present, flask 2 present, vite 6 absent + 2 present, svelte 1 absent). * fix(kernel): close the review findings on the three fixes - C++ (P3): a comment inside the access (`b./* note */operator+=(a)`) left the comment in the error's text, so the operator name never matched. Compare the `operator_name` node the grammar still reads, and keep the trimmed-text form only when there is none. - Python (P2): a local read before its only assignment in the same def (`result = store.get(); store = A()`) is an UnboundLocalError, not the later value; refuse it, keeping the future-initialization exception for a nested def that captures the outer name. - Python (P2): two conditional bindings in different blocks leave no value in effect (`if flag: store = A() else: store = B()`, then `store.get()`); refuse. One conditional beside a `None` placeholder or a later plain assignment still reads, and a conflicting set whose binding in effect may not run stays unknown. - ESM (P2): a function value is import-justified only when the file's own import resolves to the target's file, so a bare name fallback can no longer take an unexported namesake from another module. A default-exported wrapper still reaches its inner function through the default import, and `export default function Name` counts as an exported name. Regression tests: commented operator access, a future local read, two class-binding branches, and an imported name the module does not export. --------- Co-authored-by: Devin <158243242+devin-ai-integration[bot]@users.noreply.github.com>
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.This suggestion is invalid because no changes were made to the code.Suggestions cannot be applied while the pull request is closed.Suggestions cannot be applied while viewing a subset of changes.Only one suggestion per line can be applied in a batch.Add this suggestion to a batch that can be applied as a single commit.Applying suggestions on deleted lines is not supported.You must change the existing code in this line in order to create a valid suggestion.Outdated suggestions cannot be applied.This suggestion has been applied or marked resolved.Suggestions cannot be applied from pending reviews.Suggestions cannot be applied on multi-line comments.Suggestions cannot be applied while the pull request is queued to merge.Suggestion cannot be applied right now. Please check back later.
Summary
Three kinds of VB.NET member read that #2355 and #2377 left unlinked now link:
Billing.Invoice.MaxLines,StaxRip.UI.ButtonEx.ButtonSymbol.Delete(the project's root namespace in front), a Module's member through its namespace likeRedGifs.RedGifsSiteKey. The namespace is looked up as VB.NET does: the namespaces around the read, outward to the root namespaces, then the file's and project'sImports; another project's same-named namespace is not read.Button1.Text,Settings.Plugins.Count, staxrip's globalp.TargetWidthnow count as reads of the form'sButton1, the Module'sSettings,p, alongside whatever is read through them. A local or parameter of that name hides it; a member of a same-named class in another project, a member declared with an outside type of its own name (Responser As Responser) and a method run through the name are not linked.Me.Load,Calc.GetTargetDAR, a constructor'sMe.New/MyBase.Newnow reach the overload that takes no arguments, never the calling member itself, instead of the first overload declared (or nothing).Follow-up to #2355 / #2377 for #2305. Resolution only: extraction output and
EXTRACTION_VERSIONare unchanged.Cause
matchVbMemberReadtook a method throughmemberOn, which returns the first declared overload (vbnet-receivers.tson 847f1df, lines 1522-1524 and 1528-1531, viamemberOnat 1053). Without parentheses VB.NET passes no arguments, soMe.LoadreachedLoad(path); when the firstNewwas the calling constructor,Me.Newwas dropped by the self check.receiverAt(lines 1416-1423) looked a receiver name up as a value or a type only; a name that is neither returned null, so a read through a namespace path linked nothing, andmemberAt(1432-1440) had no namespace step.matchVbMemberReadreturns null at line 1507 when that is .NET's, e.g.Button1.Text):codegraph callerson a form control or a Module variable missed nearly every code-file use.membersNamed(lines 470-485) gathered a type's members from every project's same-named type and memoised them under the qualified name alone, so SCrawler's two pluginUserDataclasses shared one member list in whichever order was asked first. Main's own graph is unaffected on SCrawler/staxrip, but the new bare-name reads in one plugin linked the other plugin's members (17 edges) until it was scoped to the type's project.Fix
All in
src/resolution/vbnet-receivers.ts:runnableOverload/takesNoArguments: a method a reference runs without parentheses resolves among its type's overloads to one that declares no parameter or onlyOptional/ParamArrayones, never the member the reference is in.AddressOf/NameOfkeep main's first overload.namespaceNamed,knownNamespaces,namespaceAround,typesInNamespace,moduleMemberIn: a receiver name that is neither a value nor a type is a namespace if one of that name is nested in a namespace around the read (root namespaces from each.vbprojincluded) or in an imported one. Each further link is a type declared directly in it, a nested namespace, or a member of one of its Modules. The read links the type (Billing.Invoice) or the Module member (Assets.Logo); a member read through a namespace-qualified type links the member alone, as fix(vbnet): link Shared fields and properties read through their class (#2305) #2355'sOuter.Mode.Fastdoes.headMemberOf: for a member read whose receiver is a bare name written where the reference starts, the field, property or Module variable VB.NET binds the name to (after locals and parameters) is added as a read. Skipped for aWithblock's.X, a method run through the name, another project's Module, and a member declared with an outside type of its own name; a project type of its own name follows fix(vbnet): link fields and properties read or written through a value #2377's Color Color rule (instance member: read the value; Shared/Const/Enum: through the type).membersNamed: parts and memo scoped to the type's own project.VB_NAMESPACES,VB_NO_ARGUMENTS,VB_NAMESAKES) are cleared inclearVbnetReceiverMemos.Not reused from contributor PR #2321; its idea (VB.NET static-member refs) landed in #2355.
Tests
New
__tests__/vbnet-member-access-scope.test.ts(9 tests), adapted from the 2026-10-04 test set for #2305 onto main's representations:A mutation restoring main's
membersNamedfails the own-project test. Dropped from the 2026-10-04 set: a method named through its class also linking the class (#2355 treats it as a call, pinned byvbnet-shared-member-refs);AppSession.SessionIdthrough a property typedOtherSessionlinking nothing (#2377 linksOtherSession::SessionId, pinned the same way);SCrawler.My.Resources…(#2355/#2377 send noMy./Global.path); same-named classes by namespace/Imports/project, which main already resolves once the fixture declares itsRootNamespace(kept as a guard).Related suites (
vbnet-*,csharp-*,extraction*,resolution*,reference-target-kind,sync*,frameworks*, kernel built,CODEGRAPH_KERNEL_EXPECT=1): 43 files, 1,497 tests, all pass.tsc --noEmitandnpm run buildclean.Full suite on the final commit (kernel built,
CODEGRAPH_KERNEL_EXPECT=1,--maxWorkers=4, Windows 11): 699 files — 693 passed, 6 skipped (platform-gated watchdog/install tests); 8,351 tests — 8,269 passed, 82 skipped, 0 failed.Validation
Arms built from each commit's own sources (main 847f1df, this branch), indexed with private HOME,
CODEGRAPH_NO_DAEMON=1, telemetry off; dumps fromscripts/dump-graph.mjs, diffs keyed by qualified names.Added edges:
p2,782,s618,g419)COLOR_PICKER.ColorsGetre-pointed fromColorsGet(ByRef b, ByRef f)toColorsGet() As DataColor. staxrip'sbox.ShowinsideShared Function Show(title, …)now reachesFunction Show() As DialogResult(main dropped it as the caller itself).Inherits Instagram.UserData, which the graph's own extends edge misses), or of a Module of its project. 257 staxrip reads through a project type of the member's own name all read instance members. No head read shares a line with a lambda parameter or loop variable of its name..vbprojreferences.Source/Tools/AutoCrop; SCrawler's cross-project reads are members ofVideoListForminherited across a project reference.membersNamedscoping produced main's graph exactly on both repos.Cost (5 interleaved rounds per arm, medians; machine quiet, ~15 GB free):
The DB growth is the new edges; a CPU profile puts the new resolver code at about 0.2 s on SCrawler, the rest being the pipeline's per-edge work for the extra resolved reads.
Notes / limits
Button1.Focus(),g.VerifyRequirements), still links the method only; reads inside aWith Button1block don't linkButton1; a function named bare before the dot (GetList.Count) isn't linked.My.andGlobal.paths stay unsent (fix(vbnet): link Shared fields and properties read through their class (#2305) #2355/fix(vbnet): link fields and properties read or written through a value #2377); in SCrawler that is 185 designerGlobal.SCrawler.My.Resources.Resources.Xreads and 133My.Resources.SiteResources.Xreads, which link nothing.Namespaceblock with that namespace and drops nestedNamespaceblocks (Namespace A+End Namespace+Namespace Bputs B's types, and a later namespace-less class, underA). Only 2 SCrawler files nest namespaces, plusMy Projectdesigners.🤖 Generated with Claude Code