colbymchenry/codegraph v1.6.2 on GitHub

[1.6.2] - 2026-10-03

Highlights

Far fewer wrong links, in every language. A call, import or type now resolves the way its language scopes names — through imports, packages, namespaces and the class it is written in — so it stops landing on an unrelated symbol that only shares its name. This covers TypeScript and JavaScript, Python, Java, Kotlin, Scala, C#, VB.NET, Swift, Objective-C, Go, Rust, C and C++, PHP, Ruby, Dart, Lua, R and more, and makes callers, impact and codegraph_explore answers more trustworthy.
Overloads, super and recursion resolve correctly. A call reaches the overload its arguments fit, a super call reaches the parent's method, and a method that calls another overload, or another object's method of the same name, no longer looks like it calls itself.
Routes for more frameworks. Angular (including Nx libraries), Vue Router admin apps, Rails nested routes, Flask's add_url_rule, ASP.NET FastEndpoints, Play subprojects, Vapor closure routes and Expo Router API routes are found. NestJS and Laravel routes are named by the path a request actually takes, and a Spring or Laravel test that calls a route by URL counts as covering it.
More of your code in the graph. Vue Options API components, Java and Kotlin enum constants with bodies, Flow-typed JavaScript, Kotlin infix calls, React Native native views and events, Expo modules, tag-based CFML and Delphi .inc files are all indexed now.
Windows: no flashing windows, no random crashes. The background server no longer pops up console windows while it works, sporadic access-violation crashes (exit code 3221225477) while indexing or shutting down are fixed, and codegraph upgrade works while an agent session is using CodeGraph.
A steadier background server. Newer MCP clients such as Antigravity connect again, Claude Code sees the full text of codegraph_status, a session that lost the shared server reconnects by itself, and a project queried through projectPath is released after 10 idle minutes.
Indexing that finishes. Large C and C++ projects no longer run out of memory while resolving references, a COBOL file can no longer stall indexing, and codegraph sync keeps every caller of a name that is defined more than once.
Upgrading: re-index your projects after this release — most of these fixes are written while indexing.

New Features

In Nuxt and Astro projects, a file-routed page is now linked to the component its file defines. An Astro endpoint is linked to the HTTP-verb handlers it exports, like export const GET. Before, a page route like Nuxt's pages/admin.vue or Astro's src/pages/about.astro linked to nothing, so callers, impact and flows stopped at the route.
React Router links and navigate(…) calls written through a route-config object, like bulletproof-react's paths.app.discussion.getHref(id), now reach the route they open. A <Link> with an arrow-function attribute before its to, such as onMouseEnter={() => …}, is read too.
React Router data-router routes are named by their full path: nested children paths are joined to their parent's, path: paths.app.root.path constants are read, and lazy: () => import('./routes/x') routes link to the module's component. A guard wrapper like <ProtectedRoute> no longer stands in for the page. On bulletproof-react, every route now has its real path and page.
Vapor routes whose handler is a trailing closure, like app.get("hello") { req in … }, WebSocket routes like app.webSocket("chat") { req, ws in … }, and routes.on(.POST, "x", use: handler) registrations are now found, and a closure route links to what the closure calls, the way an Express inline handler does. Before, only routes with a use: handler were read, and a closure route linked to nothing, so callers, impact and flows stopped at it.
Flow-typed JavaScript files (those with @flow in their header comment) are now parsed like TypeScript, so type annotations like render(): React.Node no longer cut classes short. This mostly affects React Native code: on React Native's own libraries the graph gained over 8,000 links, and component classes keep their methods. Files without the pragma are unchanged. Re-index after upgrading.
A link made by a framework or bridge resolver now records which one made it (metadata.framework, such as swift-objc-bridge or react-native-bridge), as the README describes. Before, only synthesized event and view channels were named.
ASP.NET apps built with FastEndpoints now have their routes: each endpoint class's Get(…) / Post(…) in Configure() becomes a route linked to its own HandleAsync / ExecuteAsync, including paths kept in a request class's Route constant. ardalis/CleanArchitecture went from no routes to 24. Minimal API routes written without a leading slash (app.MapGet("api/todos", …)) are now named /api/todos.
Play projects kept in subdirectories are recognized, so each one's conf/routes is read. A repository with no Play build at its root, like playframework's samples, went from no routes to over 130.
Rails routes are now read with their nesting: namespace and scope add their path and controller module, nested resources sit under their parent's :id, and member / collection blocks add their actions. A namespaced route now links to its own module's controller. Routes in a Rails engine's config/routes.rb are found too: solidus went from no routes to over 600, and mastodon's route-to-action links nearly tripled.
Flask routes registered with add_url_rule(…) are now found and linked to their view function or class-based view. So are routes registered through a project's own helper that passes a list of paths and a view_func=. flaskbb, which registers every view that way, went from no routes to over 100.
Vue components written with the Options API (export default { methods: {…}, computed: {…}, watch: {…}, mounted() {…} }), as every Vue 2 app is, now have their methods, computed properties, watchers and lifecycle hooks in the graph. Each one has its own callers and calls, and a template's @click="handleLogin" links to the method it runs. On vue-element-admin that's over 800 new links, where a component's calls used to belong to the whole file.
React Native events whose name is held in a constant now link native code to the JavaScript that listens for them, like NetInfo's addListener(PrivateTypes.DEVICE_CONNECTIVITY_EVENT, …) or a Java .emit(PROGRESS_EVENT, …). The constant is read the way the language scopes it, from the same file, an import or its owning class, so a parameter that happens to share a constant's name is never mistaken for it.
React Native views declared with requireNativeComponent('X'), the older Paper style that react-native-maps and segmented-control use, now link from JavaScript to their native iOS and Android implementations, as Codegen specs already did, including in plain .js files. A JSX tag written under a different name than its component, like <Autocomplete> for import Autocomplete from './autocomplete.vue', now links to the component it renders.
Expo Router API routes (app/hello+api.ts) are now endpoints, one per exported method, like GET /hello, bound to the function that handles them. They used to show up as a screen named /hello+api. In a repository whose root declares Expo Router for an example app, a Next.js app in its own folder, like react-native-true-sheet's docs/, no longer gets Expo screens made from its files.
Calls into an Expo module now reach the module's native functions even when the JavaScript names the module something else, like expo-camera's CameraManager for requireNativeModule('ExpoCamera'). Both the iOS and the Android implementations are linked. expo-camera's calls used to link back to the same-named method making the call, so a method looked like it called itself.
Angular apps split across Nx libraries, like angular-spotify, now have their routes and navigation. A lazily loaded route written async () => (await import('@app/home')).HomeModule is followed through the library's index.ts to the module it re-exports, and a routerLink in one library now reaches a screen declared in another. Route paths built from a class constant (RouterUtil.Configuration.Lyrics, `issue/:${ProjectConst.IssueId}`) or an enum are now read. A redirect in a routes file that only lazy-loads others now counts, and router.navigate(['project', 'issue', id]) without relativeTo is read from the root, as Angular does. Re-index Angular projects after upgrading.
React Router apps now show navigation written as React Router v5's <Redirect to="/login" /> and through a styled link, like react-boilerplate's HeaderLink = styled(Link) used as <HeaderLink to="/features">. Apps built this way had routes but no links between their screens.
SvelteKit routes are now named by the address a browser asks for. A (group) folder like (app) or (marketing) is no longer part of a route's path, and a parameter with a matcher, like [id=integer], is just :id. So goto('/blocks') and <a href="/blocks"> now reach a page that lives in src/routes/(app)/blocks/, where before they reached nothing and the app's screens showed no navigation. Re-index SvelteKit projects after upgrading.
Vue Router apps built like vue-element-admin, vue-admin-template or vben now have their routes and screens. Routes declared in a named table (export const constantRoutes = [...], const routes: RouteRecordRaw[] = [...]), in per-module route files, or through new Router(...) are now read. Child routes are joined onto their parent's path, and the parent's component is the layout around them. A lazily loaded view (() => import('@/views/dashboard/index')) is bound to the file it names, and this.$router.push(...) counts as navigation. Nuxt's file-based routes now come only from a Nuxt app, so a plain Vue app's pages/ folder no longer turns into made-up screens, and a Nuxt app at the root of its repository now gets its routes. Re-index Vue projects after upgrading.
NestJS routes are now named by the path a request takes: the global prefix from app.setGlobalPrefix('api') is applied, along with its exclude list, and so is URI versioning from app.enableVersioning(...), with @Version, VERSION_NEUTRAL and a controller's own version taken into account. A route that used to appear as GET /user is now GET /api/v1/user, so a front end's this.http.get('/api/v1/user') or fetch call connects to the controller method that serves it. Re-index NestJS projects after upgrading.
Laravel routes are now named by the path a request takes: a leading / is added where the routes file leaves it out, Route::prefix() and Route::group(['prefix' => …]) groups are applied, and routes in routes/api.php carry the /api prefix Laravel serves them under, read from your RouteServiceProvider, bootstrap/app.php or any file that mounts a routes file. A front-end fetch('/api/…') now connects to the Laravel route that serves it. Re-index Laravel projects after upgrading.
Controllers that Spring or Laravel tests exercise by URL now count as tested. That covers MockMvc's perform(post("/owners/new")), WebTestClient, TestRestTemplate, RestAssured, Laravel's $this->postJson('api/me'), Pest's get('/about'), and a project's own request helpers built on them. codegraph_explore now names the test suite that reaches such an endpoint, where before every one of them looked untested. Re-index Spring and Laravel projects after upgrading.
In an Angular app, a method a template calls, like (click)="toggleFavorite()" or (ngSubmit)="submitForm()", is now linked from its component. These methods used to show no callers at all, so impact and callers questions stopped at them, and dead-code checks could list them as unused. Re-index Angular projects after upgrading.
Angular apps now have routes and navigation in the graph. Each screen in a Routes array is a route named by its full path, including children, lazily loaded loadChildren files and NgModules, paths written as route constants or $localize strings, and redirects. Each route is linked to its component. router.navigate([...]), navigateByUrl, a guard's createUrlTree and every routerLink in a component's template link to the screen they open, and a template's child components (<app-article-list>) are linked to the component that renders them. Questions like "where does this button go" and "what renders this component" now have answers in codegraph_explore. Re-index Angular projects after upgrading.
Delphi and Free Pascal include files (.inc) are now indexed as Pascal. Before, they were read as PHP and came up empty. A .inc file with a <?php tag is still PHP, and a codegraph.json mapping for .inc still wins. Thanks @ijbranch for the report. (#2279)
In tag-based CFML, calls written in tags are now linked: in <cfset>, <cfif>/<cfelseif>, <cfreturn>, <cfloop condition> and #…# expressions. Before, only <cfscript> and <cfquery> code was read, so callers and impact found almost nothing in tag-based components. Functions wrapped in tags like <cfprocessingdirective> or <cfsilent> are now indexed too, and a <cfinterface> is indexed as an interface that implements links to. Re-index CFML projects after upgrading. Thanks @HarryMuc for the report. (#2091)
Java enum constants and Kotlin enum entries with a body of their own now have their methods in the graph. Examples are PLUS { int apply(…) { … } } and NewBuffer { override fun pipe() … }. Before, those methods were missing and every call inside them was dropped. jsoup's HTML tokenizer and tree builder are written this way, so over 2,000 of their calls were invisible. Re-index to pick this up.
Kotlin infix calls, like Users.id eq id1 or koin's single { … } bind MyApi::class, are now recorded as calls to the infix function. Before, they had no callers at all. On Exposed, eq now shows over a thousand callers. Bit operations on numbers (x and 0xff, h shr 8) are left to Kotlin's own operators, even where the project defines a same-named extension. Re-index after upgrading.

Fixes

Windows

On Windows, terminal windows no longer flash open and closed while CodeGraph runs in the background. Since 1.6.1, a background MCP server popped up a console window (a full Windows Terminal window when that is the default terminal) several times when it started and again every time it re-synced a changed file. All of CodeGraph's git calls now run hidden. Thanks @Suharaz, @23q3, @A-Van-Gestel, @HarryMuc and @MzaGuille. (#2094, #2096, #2312)
On Windows, a project opened with a different drive-letter or folder-name case, like d:\work\app and D:\Work\App, now joins the CodeGraph background server that is already running for it. Before, each spelling started a server of its own that exited at once, so the session quietly served the graph by itself with no shared file watching or auto-sync, and codegraph list showed the project twice. Thanks @greatjackzhou. (#2278)
On Windows, codegraph upgrade no longer breaks the install while an agent session is using CodeGraph. It used to stop partway and leave CodeGraph unable to start; it now swaps the new files in with CodeGraph running and puts the previous version back if anything fails, and re-running the PowerShell installer works the same way. If an earlier upgrade already broke your install, re-run irm https://raw.githubusercontent.com/colbymchenry/codegraph/main/install.ps1 | iex to repair it. Thanks @tippmar-nr for the report. (#2185)
On Windows, CodeGraph no longer sometimes crashes with exit code 3221225477 (an access violation) on a busy machine: right after parsing in codegraph init, codegraph index and background syncs, or as the background server shuts down. Stopping one of its helper threads (the ones that parse files, resolve references, write the index and count changes for codegraph_status) while it was still starting up, or before it had finished cleaning up its memory, took the whole process down. Threads now finish starting and clean up before they exit.

The background server, sessions and the CLI

The Claude Code prompt hook no longer runs on the messages Claude Code uses to hand a subagent's report back to the main session. Before, such a long report could keep the hook busy past Claude Code's 30-second hook timeout and inject context unrelated to what you asked. Thanks @danusha2345, and @tippmar-nr for the report. (#2184)
Newer MCP clients such as Antigravity 2.5 connect again: the server now answers their server/discover probe right away with "method not found", so they go straight on to the regular handshake instead of waiting on a reply that could take seconds or never come. Thanks @danusha2345, and @samem26 for the report. (#2084)
A CodeGraph session that queried another project through projectPath no longer keeps that project locked for as long as it runs: after 10 minutes without a query it lets the project go, so the project's own session and codegraph index can take over again (tune with CODEGRAPH_PROJECT_IDLE_TIMEOUT_MS, 0 keeps it open). Thanks @danusha2345, and @bompus for the report. (#2087)
Claude Code now shows the model the full text of codegraph_status and of explore's stale-index refusal. Both results also carried structuredContent, and Claude Code shows a result's structuredContent in place of its text, so the model saw only a freshness JSON object: no refusal message, no retry guidance and no status report. Both results are now text only. Thanks @bompus. (#2088)
When an agent asks CodeGraph about a separate git repository nested inside an indexed project, one the project's index leaves out (for example because the parent's .gitignore excludes it), it now gets the usual "isn't indexed" guidance instead of answers from the parent project's code. Nested repositories the parent does index, such as submodules, work as before. Thanks @wstczyw for the report. (#2110)
An agent session that lost its connection to CodeGraph's shared background server, or couldn't reach it at startup, no longer stops that server from running for the rest of the session. It reconnects on its own once the server can start, so other sessions on the same project get auto-sync back instead of running read-only. Thanks @ijbranch for the report. (#2277)
codegraph index no longer gives up with "Could not verify that the active CodeGraph daemon has stopped" while the background server is still finishing its shutdown, and codegraph daemon no longer reports such a server as one it could not stop; both now wait for it to exit, for up to about 20 seconds. An agent session that is serving CodeGraph by itself, because the background server was unavailable, now also waits for that work to stop before it exits instead of exiting partway through, which could crash on Windows. Thanks @bompus. (#2311)
Anonymous usage telemetry now sends one daily count per tool or command, as documented, instead of one per codegraph process. Before, every MCP server launch, CLI command and prompt hook queued its own entry, so a busy machine uploaded thousands of copies of the same count each day. If you have telemetry turned off, nothing changes.

Indexing and sync

A COBOL file whose last line ends inside the sequence area (columns 1-6), such as a closing period indented only four spaces, no longer stalls indexing for over a minute and then ends up in the index with no symbols.
Editing a file that defines the same name more than once, like two classes that each have an execute method or a method's overloads, no longer moves every caller from other files onto one of them during codegraph sync. A sync interrupted partway through a file also no longer loses those callers until a full re-index. Thanks @ijbranch for the report. (#2276)
Indexing a large C or C++ project no longer runs out of memory partway through "Resolving refs". Headers whose include guard is written as #define X_H 1, as in OpenSceneGraph and osgEarth, or that are included under a build flag codegraph cannot know, used to be re-read on every include path, which grows exponentially with the depth of the include tree. Each is now read once per include state, and a hard limit stops the check on any include tree that is still too large. Thanks @danusha2345, and @coolhitmanleon for the report. (#2127)
On a busy machine, indexing or syncing a small project no longer starts extra background threads for resolving references that it can't use. Under heavy load the slower pace made a ten-file project look big enough to need them, which added seconds to the run and held extra memory.

Across languages

A type that extends another type of the same name now links to that other type instead of to itself. When the source spells out the qualifier, that qualifier picks between same-named candidates. Before, cats' trait BigDecimalInstances extends cats.kernel.instances.BigDecimalInstances and every trait AllOps … with Functor.AllOps[…] pointed back at the declaring trait, and Newtonsoft.Json's JsonConverter<T> : JsonConverter extended itself.
Framework name conventions for Django, FastAPI, Flask, ASP.NET, Gin, SwiftUI and Vapor now only pick a class the reference can see. Examples of these conventions are "a …View is a view", "a …Service is a service" and "a capitalized name is a model". The pick starts from the reference's own file and then its package, and never takes a class declared inside some function or nested in another file's class. Before, Django REST framework's tests linked each file's own MockView and Serializer to another file's, and netbox's tests linked TestForm() to a form declared inside a different test function.
A method that calls a same-named method on another expression's result is no longer linked to itself in any language. Examples are Scala's requestToArmeria(request).execute() inside execute(), Rust's self.0.into_route(state) inside into_route(), and Kotlin's this@Buffer.write(…) from an inner object. A value whose initializer chain calls a same-named method, like sttp's val response = basicRequest.get(…).response(…), no longer links to itself either.
A method that hands its call on to another object is no longer linked to itself. In TypeScript and JavaScript, a call through this.<field> or window.<x> counts as recursion only when the field is declared as the method's own class. A guess from a receiver's name alone never lands on the calling method. Before, BookStack's toggle() doing this.container.classList.toggle('open'), listen() doing window.$events.listen(…), and FileStorage::delete doing $storage->delete($path) each pointed at themselves.
A function or name passed as a value now resolves to what is in scope where it's written. A function nested inside another function is only reachable from inside it. In Python, a parameter or local of the same name is that local. A pytest fixture is a test's parameter only in its own module or under its conftest.py. Before, httpx's self._build_auth(auth) linked to an auth a test defines inside another function, and auth_flow(self, request) handing request on linked to the package's request() function.
In Java, C#, Kotlin, Swift, Scala, Dart and VB.NET, a call now reaches the overload whose parameters fit its arguments, not whichever same-named overload was indexed first. For example, HashCodeBuilder.reflectionHashCode(this) now reaches the one-argument overload with varargs, not a three-parameter one. Each overload's callers are now its own.
A method that calls another overload of itself now links to that overload rather than to itself. An example is toInstant(instant) returning toInstant(instant, Instant.EPOCH). The fuller overload now lists its convenience overloads among its callers, so its impact includes them. This applies to Java, C#, Kotlin, Swift, C++, Scala, Dart and VB.NET. Real recursion is unchanged.
Production code no longer links to a same-named symbol inside a test suite, since tests aren't built into the program. Before, typeorm's Record<string, …> types reached a test entity called Record, and okhttp's sample @Override annotations reached a test's nested Override class. Test-support code a project ships, such as a testing/ folder or a *-test module, stays in reach.
A method call on a variable is no longer guessed to be a test double's method just because the double has the only method of that name. That covered classes named Mocked…, Fake…, Stub… or Dummy…: django-allauth's resp.json() calls had all gone to its MockedResponse. A test that names the double still calls it.
A call through a class name, like THorse.Get(…), MyView.as_view() or ColorChoices.values(), now reaches the class method that class inherits. The inheritance is read from the class declarations themselves, in Pascal, Python, Ruby, PHP, TypeScript/JavaScript and the Java family. Before, such a call was resolved by guessing from the name. On Horse, THorse.Get('/ping', …) used to land on a route-group interface's Get 120 times. Re-index after upgrading.
A method guessed from a receiver's name no longer lands on a request handler the web framework dispatches to, such as a Django or DRF view's post / get or a controller's update / destroy. It also no longer lands on a test double the calling file never mentions. On django-allauth, tests' client.post(…) used to land on a ClientRegistrationView 425 times. On mealie, response.json() used to land on a test's _FakeHTTPResponse 424 times. In Python, site = Site.objects.create(…) now makes site a Site, so site.save() reaches the model's own save. Re-index after upgrading.
In C#, Java and Kotlin, a call through a field, property or parameter now lands on the method of the type it is declared with. That includes a type inherited from a base class with its type argument filled in, a generic or for-each declaration, a C# using alias, and a type parameter's bound. A call no longer falls back to a guess at some project class's same-named method, and a type from outside the project gives no link. On Newtonsoft.Json, _innerWriter.WriteValue(…) inside a writer wrapper used to land on the wrapper's own WriteValue, and a TextWriter's Write(…) on a test writer's. On commons-lang, a DateFormat field's parse(…) used to land on the project's DateParser 284 times.
A call on a variable declared with a type from outside the project (List<String> list, var sb = new StringBuilder(), signer = TimestampSigner()) no longer lands on a project type's method with the same name. On gson, list.add(…) used to land on a project list wrapper; on commons-lang, s.length() and buffer.append(…) on project classes. In Python, a keyword argument inside a call (prefix=IPNetwork(…)) is no longer taken for an assignment to that name.
A call on a type from outside the project, like Integer.valueOf(…), Arrays.asList(…), Object.assign(…) or Delphi's Exception.Create(…), no longer lands on the project's own method with that name. On commons-lang, Integer.valueOf used to land on StringUtils.valueOf over 800 times. Go's exported variables and Pascal's capitalized parameters and locals are not mistaken for type names.
In PHP, CFML, Pascal, COBOL and VB.NET, a call written in a different case than its definition now resolves, like formatprice() for FormatPrice or CFML's ToMatchWithCase() for toMatchWithCase. These languages ignore case in names, but such calls used to be dropped before resolution.
In Java, Kotlin, Swift, C#, C and C++, Go, Scala, Ruby, Dart and the other case-sensitive languages, a name no longer links to a symbol whose name differs only in case. On jsoup, JUnit's @Test had linked every test to a test method; new CookieManager() had linked to a cookieManager() getter, and a Method type to a method(). PHP, Pascal, CFML, COBOL and VB.NET, whose names really do ignore case, are unchanged.
A super call in an overriding method, like super.viewDidLoad(), [super init], base.Handle(), parent::setUp() or super().dispatch(…), no longer makes the method look like it calls itself. The call goes to the parent's version, so an override stops showing up as recursive and no longer lists itself among its own callers.
A generic type parameter, like A in def zipWith[A, B](…), T in <T> T max(…) or class Foo<T>, no longer links to a project symbol that happens to share its name. On cats, one implicit def A had thousands of made-up dependents from every A in the library. The same goes for Rust, Dart, TypeScript, Java, Kotlin, Swift, Go, C# and C++. A class or other type declared inside a function is only linked from inside that function. In Scala, a def's own parameter, like f in (f: A => B), no longer links to a same-named field elsewhere. A bare name no longer reaches a type nested inside another type unless the code is inside that type, extends it or imports its members; the type in scope is linked instead, like cats' own FlatMap in place of Eval's nested FlatMap. Re-index projects in these languages after upgrading.

JavaScript and TypeScript, with Vue, Svelte, Astro, React, Express, NestJS and Hono

In Vue, Svelte and Astro files, a component now owns its script, and what a <script setup>, a Svelte instance script or Astro frontmatter does at its top level is the component's doing. That covers a Nuxt page's useAsyncData(…), a Svelte page's onMount(…) and Astro's await getCollection(…). Imports and a module-level script stay with the file. Before, those calls belonged to the file, so callers and flows from a component found nothing. The component was also recorded as containing its own file, and a file with no script had no file node at all.
In JavaScript and TypeScript, a CommonJS require('./application') now counts as an import of that file, the way an ESM import does. A module path also resolves the way Node and bundlers find it: extensions, index files and path aliases. Before, a CommonJS file depended on nothing at file level, so Express's own lib/express.js showed no imports and impact analysis missed the files it loads. An extensionless side-effect import like import './polyfills' also stopped at its own import statement instead of reaching the file.
An Express route whose handler is written inline as function (req, res) {…}, the form Express's own examples use, now links to what that handler calls, just like an arrow handler does. The handler is the route's last argument, so an inline middleware before a named handler no longer stands in for it, and a wrapper like asyncHandler(async function (req, res) {…}) and a trailing comma both work. Before, a route such as POST /login linked to nothing.
In NestJS projects, the provider naming convention (…Service, …Controller, …) now picks a class only from the reference's own file. Another file's provider is reached through its import, or by ordinary name matching that prefers the nearest declaration. Before, the convention's preference for *.service.ts files sent Nest's own specs' TransientService and TestService to same-named classes in unrelated sample apps.
In Astro projects, the component-name convention now applies only inside .astro files, where components are used. Before, a TypeScript type with a component's name was linked to that component: astrowind's image?: Image and callToAction?: CallToAction in its type declarations, and starlight's Playwright page: Page in its tests.
In JavaScript and TypeScript, the Express conventions for middleware (validate…, auth, logger, …), controllers and services now pick only the calling file's own declaration. Another file's is reached only through an import or require. Before, SvelteKit's remote functions linked validate(arg) to its config loader's validate in another package, and Express's examples linked logger('dev') to one example's logger.
In JavaScript and TypeScript, the React conventions for hooks (use…) and contexts (…Context, …Provider) now pick only from the reference's own file. Another file's hook or context is reached only through an import. An optional call like onSuccess?.(…) now gets the same scope rules as a plain call. Before, trpc's WebSocket adapter's createContext?.(…) option linked to an example app's createContext, zod's schemas.ParseContext linked to the v3 copy instead of v4's, and bulletproof-react's apps linked useUser() to one another's.
What a Svelte component's instance <script> or a Vue component's <script setup> declares is now private to that component. Only a Svelte <script module>, a plain Vue <script>, or a type a <script setup> exports can be reached from another file. Before, shadcn-svelte's <Item.Root> linked to a type Item that one example component declares for itself, and halo's isActive imported from its editor core linked to a tab component's local value.
In JavaScript and TypeScript, a name the calling function binds itself, as a parameter or a plain var/let/const above the reference, now means that local instead of a same-named function elsewhere in the file. Before, every lodash helper's object parameter linked to a function object() {} declared inside runInContext, and zod's new Class(…) linked to an unrelated Class when Class was the function's parameter. Destructured hook results like const { t } = useI18n() still link to the function they come from.
In a project with a React front end, the React rules for hooks (use…) and contexts (…Context, …Provider) no longer apply to backend code. In halo, a Spring app with a React UI, Java imports such as SecurityContext and ObjectProvider had been handled as React contexts.
In a project with a Vue front end, the backend's calls no longer land on Vue components. mealie's Python QueryFilterBuilder(…) had been linking to the QueryFilterBuilder.vue component. The Vue rules (compiler macros, Nuxt auto-imports, components by name) now apply only to the app's scripts.
Calls in your own JavaScript no longer link to a same-named function inside a vendored minified script, like a *.min.js or a bundle made of a few enormous lines. Those names are mangled. In healthchecks, every jQuery $(…) call had gone to a one-letter helper inside bootstrap-native.min.js.
Calls inside an inline route handler now keep their receivers, so they resolve like any other method call. Before, Hono's app.get('/', (c) => c.text('Hello')) linked the route to the one other text method in the project, its client's ClientResponse.text; that happened in over 400 routes. A call like userService.lookup(id) reaches the service it names.
A barrel's export * as core from './core' now exports only core, not everything in ./core. In zod, z.string() and z.number() had been landing on same-named regex constants deep in its core module instead of the schema functions. Calls through import * as ns also find members a barrel forwards by name (export { safeParse } from '../core'). They follow a namespace path like z.coerce.number() too.
JavaScript calls through CommonJS require bindings now reach the right function. var express = require('../') follows module.exports through an index.js to the function it exports, and every binding in a var a = require('x'), b = require('y') list is read. require('./utils').setCharset means that module's setCharset rather than its first export, and a call to a package from outside the project (supertest, node:assert) is no longer an edge to the local variable. On express, over 700 express() calls now reach createApplication.
Imports through a tsconfig or jsconfig path alias now use the config nearest the importing file, so each app in a monorepo resolves its own @/… or ~/… alias. On bulletproof-react and trpc's examples, those imports used to fail or land in a different app.
In JavaScript, TypeScript and Vue, a call through a name destructured from a composable or custom hook, like const { getDefaultActivityRoute } = useDefaultActivity() or const { t } = useI18n(), now reaches the function the hook returns. These calls used to resolve to nothing. mealie, elk, halo and excalidraw each gained dozens to over a hundred such links.
In JavaScript and TypeScript, a module's top-level function, variable or type that the module doesn't export is no longer linked from other files. Every form of export still counts: the export keyword, export { … } lists, export default, and a default-exported object. On typeorm, test fixtures' local ColumnMetadata used to capture import { ColumnMetadata } from "typeorm"; on sveltekit, an unexported resolve collected other files' resolve(…) calls; on zod, a local z collected the zod package imports.
A JavaScript or TypeScript call on something the file imports, like fireEvent.click(…) or util.omit(…), no longer links to a same-named method declared in the calling file itself.
TypeScript's import type { X } no longer reads as an import of something named type, and import { a, type B } binds B, not type B. So a type-only import now links to the module it names, where it used to link to whatever project symbol had that name. A type imported from a package, like RsbuildConfig from @rsbuild/core, no longer links to a project symbol, and JavaScript and TypeScript names no longer match a symbol whose name differs only in case (Mock is not mock).
In a monorepo with an Expo app next to a Next.js app, like create-t3-turbo or tamagui's starter, each router now reads only its own app. Expo Router used to read the Next.js app's files too, so layout.tsx, page.tsx, a _components folder and an API route showed up as screens named /layout, /page or /_components/posts, and a shared package's files became screens as well. Re-index such monorepos after upgrading.
Calls in Vue, Svelte and Astro components now follow the same rules as JavaScript and TypeScript. A t('…') from useI18n() or a ref(…) from vue used to link to an interface property or a local variable of the same name elsewhere in the project, so on halo two unrelated symbols had over a thousand made-up callers each. A call imported from a package is also no longer mistaken for a project symbol when the package is declared in a nested app's package.json or a Deno import map. An import through an alias CodeGraph can't follow, like SvelteKit's $lib/… or a nested Nuxt app's ~/…, is still treated as project code. Re-index Vue, Svelte, Astro and JavaScript/TypeScript projects after upgrading.
A minified or bundled JavaScript file is now recognized as generated even when it isn't named .min.js, for example a docs site's bundle.js, a readable webpack build or a vendored underscore-min.js. Its one-letter functions now rank below your own code in search and codegraph_explore answers.
JavaScript and TypeScript calls are no longer linked to a class member that merely shares their name. A call on a namespace import, like zod's z.string() (import * as z from 'zod'), or on something imported from an npm package, used to link to whichever class in the project had a string member, and a bare call like mocha's it(…) or describe(…) to an interface's it property or a class's describe field. On zod one test helper's getter had thousands of made-up callers and topped the most-depended-on list. A React hook or component imported from a package, like useQuery from @tanstack/react-query, no longer links to a same-named one in the project, and a hook nested inside another function is no longer a target at all. Re-index JavaScript and TypeScript projects after upgrading.

Python

A Python module member used through the imported module, like generic.ObjectEditView after from netbox.views import generic, serializers.ValidationError or utils.assert_deserialize(…), now also follows the package's re-exports to its definition. Before, netbox's view classes lost their generic.* base classes, and mealie's test helpers called through utils. went unresolved.
A Python name imported from a package now follows the package's re-exports to where it's defined. That covers both from .users import * and from .tokens import Token in its __init__.py. Before, httpx's own tests' httpx.Client(…) and httpx.URL(…), pytest's pytest.raises(…) and pytest.param(…), and netbox's from users.models import User went unresolved or to a same-named class elsewhere, such as a test's User or an Alembic migration's copy of a model.
In pytest tests, a parameter now takes the class its fixture returns, so a call on it reaches that class's method. If the class comes from a library, the call no longer reaches the project's only method of that name. Fixtures a conftest.py pulls in with from … import * or pytest_plugins now count as in reach. Before, flask's runner.invoke(…) on click's CliRunner() linked to the project's FlaskCliRunner.invoke, and @app.get(…) on a Flask(…) fixture linked to an unrelated get.
In Python, an attribute passed as a value through an object nothing types, like netbox's device=self.parent.device, is no longer linked to the project's only method of that name when the object isn't named after the method's class. Before, netbox's model-field reads went to a GraphQL filter's device method, and healthchecks' check.last_ping went to a notification transport's.
A Python call to a name the function or module binds itself now means that local value, not a same-named function in another file. In Django REST Framework's tests, view = SomeView.as_view() followed by view(request) had pointed at one test file's def view. The same goes for a parameter or a for/with … as target. A pytest fixture a test takes as a parameter is still the fixture.
Python calls like User.objects.get(…), self.client.login(…) or request.POST.get(…) no longer link to whichever class in the project has a method of that name. Such a call now links only to a member of what its receiver names, like helpers.slugify() to slugify in helpers.py, and a bare get(1) never links to a method. A name the file imports from a package outside the project, like from django.shortcuts import render, no longer links to a same-named project function. In Django projects these made-up links had given single test or serializer methods thousands of callers, for example netbox's .all() calls on one UserConfig.all. Re-index Python projects after upgrading.
In Python, a call written on the instance, like self.get_breadcrumbs(...), now links to the class's own method even when the file also imports a function of the same name. Before, the import claimed it: Django REST Framework's renderers, netbox's change logging and django-allauth's account adapter all linked their own method calls to an imported helper.
In Python, a method passed as a value through a module-level variable that a setup function assigns, like settings.docStoreConn.delete_payload_fields after global docStoreConn; docStoreConn = QdrantConnection(), now links to that class's method. When several backend classes can be assigned, it links to the declaration they all inherit. Thanks @JosefAschauer. (#2074)
In Python, an import split over several lines in parentheses, from x import (A, B) written one name per line, is now read in full. Before, its names were invisible to resolution, so Django REST Framework's serializers.CharField() and netbox's model mixins linked to the wrong class or to nothing. Thanks @JosefAschauer.

Java, Kotlin and Scala

In Java, a bare type name now resolves only to a type in reach. That is a type in the same package, one imported by name or with .*, or a nested type used from inside its owner, from a subclass (anonymous classes included), or written through its owner as in Outer.Inner. A constructor no longer stands in for its class, and an enum constant is reached by bare name only inside its enum, in a case label, or through a static import. Before, retrofit's new Retrofit.Builder() linked to RequestFactory.Builder, halo's micrometer Counter to its own Counter class, and jsoup's java.lang.Class<?> to a nested selector class.
Bare calls in Gradle Kotlin scripts (build.gradle.kts), like plugins { }, dependencies { } or api(…), are no longer linked to a method or property of one of the project's own classes. Build logic's extension functions on Gradle's types still resolve. Before, nowinandroid's build scripts pointed every plugins { } and dependencies { } block at its build logic's Graph class, and every api(…) at a lint registry's api property.
In Scala, a package object's member now resolves only where it is in scope: in its own package, the packages under it, or a file that imports through that package. Before, cats' laws resolved Eq, Order and Monoid to the algebra package object's aliases rather than the cats package object's, and sttp's akka tests reached a zio package object's whenRequestMatches.
In Spring projects, a class name now resolves to the one in the reference's own file or package before any guess by folder convention. A class nested inside another file's class is never reached by its bare name. Before, every MyBatis Example class's new Criteria() in mall linked to the first Example's nested Criteria, and halo's Lombok @Builder linked to a nested Builder class elsewhere.
In Scala, a kind-projector placeholder in a type, like Align[Either[A, *]], is no longer linked to an operator method named *. A symbolic name in a type, like cats' F ~> G, now resolves only to a type.
Kotlin calls inside a DSL lambda now reach the lambda's own receiver. That receiver comes from the function the lambda is passed to, even through a typealias like koin's Definition<T> = Scope.(…) -> T. It also wins over other types the project uses as lambda receivers elsewhere. On koin, over 2,000 get() calls in single { … } now reach Scope.get instead of Koin.get; on Exposed, varchar(…) inside a table object reaches Table.varchar; on kotlinx.coroutines, launch { } reaches CoroutineScope.launch.
A Scala chained call like xs.map { … } no longer lands on an object that happens to be named map, as with cats' alleycats.std.map and its syntax/instances objects. A type or object in a chain is only matched when the receiver names what holds it, as in sttp.client4.Response(…).
Kotlin imports now decide what a name means, as Java imports already do. import java.net.Proxy or import org.mockito.Mockito.mock no longer links to a same-named project symbol, and a member the file declares itself still comes first. An import x.Foo picks the right one of several same-named classes: on okhttp, MockResponse.Builder() and Request.Builder() now reach their classes. A renaming import like import …internal.unsafeFlow as flow means the function it names.
In Java, a class you import from outside your project now owns its name. After import java.lang.reflect.Field; the file's Field no longer links to a project class that happens to share the name. In gson that was a test's nested Field class; in jsoup's W3C converter it was jsoup's own Document and Element. A static import like import static org.mockito.Mockito.verify; is covered the same way.
Scala calls no longer land on another test's local value. A val f written inside one test("…") { } block was being picked for a lambda parameter f in another suite, and even for f(…) in cats' core library. A package import like import cats.syntax.all._ no longer puts every class's members in scope. Members that really are in scope now resolve: those of an imported package object's parent types (import sttp.client4._ gives SttpApi's multipart), and of the file's own package object.
Kotlin files using newer syntax now keep their classes intact. That covers when guard conditions (is X if cond ->), ..< ranges, multi-dollar strings ($$"…") and nullable receivers in function types (T?.() -> R). Before, the class around such code could come out as a scatter of loose functions. On Exposed, files with a parse error dropped from 65 to 43, and on kotlinx.coroutines from 50 to 46. Re-index after upgrading.
Kotlin code using an infix function whose name starts with e, like Exposed's Users.id eq id1, now parses cleanly. Before, the rest of such a line was a parse error, and in a file with many of them the whole class around it could be lost. On Exposed, files with a parse error dropped from 229 to 71. Re-index after upgrading.
In Kotlin, a call with no receiver now reaches a method of another class only when that class is in reach. That means a class, an anonymous object : Base() or an extension function's receiver around the call, what those inherit, or the receiver of a DSL lambda (koin's single { get() } runs on a Scope, Exposed's withTables { … } on a transaction). An object member the file imports is in reach too. Kotlin's own error(…), require(x >= 0) { … } and check(…) no longer land on a project class's method of that name. On koin, module { … } in one test used to land on another test class's private module over 260 times, and inside a lambda get() landed on the wrong class's get. Re-index after upgrading.
Kotlin classes whose primary constructor sits on the line after the class name, before a supertype list (expect open class ByteString / internal constructor(…) : Comparable<ByteString>, common in Kotlin Multiplatform code), no longer lose their members to loose functions. A call later in a chain to a Kotlin standard-library function (apply, let, toString, map, contains…) no longer lands on a project type's same-named method. On okhttp, .apply { … } used to land on ConnectionSpec.apply. Re-index after upgrading.
In Scala, a call reached by its name alone now stays in reach. A name that the enclosing function binds as a parameter or local (f(true) for f: A => B) is that local. A call later in a chain, like fa.iterator.map(…), reaches only a member of what its receiver is named after. A plain call reaches only the enclosing class and its supertypes (an anonymous subclass's base included), a companion, or an imported object. On cats, parameter calls like f(a) used to land on a case class's field f over 400 times, and chained .map(…) on one ops class's map.
In Kotlin, a call to a top-level or extension function now resolves only to one the file can see: one in its own package, one it imports by name, or one from a package it imports with *. On Exposed, tests that imported kotlin.test's or JUnit's assertEquals, or the JDBC suite's helper, used to land on the R2DBC suite's helper over 3,000 times. On okhttp, tests that import mockwebserver3.MockResponse used to construct the deprecated class of the same name. A function type with a qualified receiver, like (DatabaseConfig.Builder.() -> Unit)?, no longer breaks the parse of the class around it. Re-index after upgrading.
A bare Java call like verify(mock), assertThat(x) or hashCode() now links only to a method of the class it's in, of that class's parents, or one the file imports statically. It used to link to any class's method of that name: in halo, Mockito's verify and eq gave one service's verify over a thousand made-up callers, and in retrofit Truth's assertThat did the same to a test helper. Calls to inherited methods and static imports from the project now link to the right one, like jsoup's attr(…) through LeafNode or halo's and(…) / equal(…) through import static …Queries.*. Re-index Java projects after upgrading.

C# and VB.NET

C# names now follow the language's scopes. A block namespace X { … } qualifies only the types inside it, so a type declared after the block, or in a file's second namespace, is no longer filed under the first. A namespace written inside another is Outer.Inner. A using links to the project's namespace instead of another file's using of the same name. A global using applies only within its own project. A nested type is reachable by bare name only from inside its owner or a type deriving from it, including through another partial part. Before, serilog's Guard was filed under JetBrains.Annotations, its tests' Some.InformationEvent() went to the performance tests' Some, and AutoMapper's same-file new Source() could reach another test class's nested Source.
C# type names now follow namespaces. A type is in reach from its own namespace or one nested inside it, or through a using of its namespace. Also counted: a project-wide global using, the project's <Using> entries, the SDK's implicit usings, or an alias that names it. Before, Newtonsoft's async Task tests linked Task to a test class of that name in another namespace, and AutoMapper's DTOs linked to another namespace's BaseEntity.
C# members of an interface are now public and types declared without a modifier are now internal, as the language defines. A call on an interface-typed field now reaches the interface's method, where it used to find nothing. A guess from a receiver's name now weighs only the owner type's own name, not its namespace. Standard .NET names like ToString, Add and Write need a receiver named after the owner. In every language, a guess from production code no longer lands on a mock or helper defined in a test suite. Re-index after upgrading.
In C#, a bare name like TestContext, Easing or Helper() now resolves only to a member of the class it's written in, its outer classes, their base classes, or a type brought in with using static. That includes a global using static and a project file's <Using … Static="true"/>. On eShop, test classes' TestContext used to land on one other test class's property; on Newtonsoft.Json, TypeNameHandling.All now reaches the enum rather than a same-named property.
In VB.NET, a call through a receiver like Me.Panel.Controls.Add(…) or New System.Drawing.Size(…) no longer lands on an unrelated class's member with the same name. It now resolves only through Me, MyBase or MyClass, through the member's own class or module (Logger.Log(…)), or through a service lookup's type (GetService(Of Notifier).Notify()). On SCrawler, the Windows Forms designer code used to link over 700 Size calls to a nested enum's case and over 500 Controls.Add calls to a collection class.
In C# and VB.NET, a type written in code, like Type sourceType, List<int>, new TypeMap() or Dictionary<string, Type>, now links to the type and no longer to a property, method or field that shares its name. List<…> used to link to some test class's List property, Type to an attribute's Type property, and a parameter of type TypeMap to a TypeMap property instead of the TypeMap class. Those members showed up with hundreds of made-up dependents. Reading a property or passing a method, like Builder.Services or MapGet("/x", GetItems), still links as before. Re-index C# and VB.NET projects after upgrading.

Swift and Objective-C

An Objective-C class that conforms to a protocol of its own name now links to that protocol instead of to itself. Swift's naming conventions for views, models and controllers also no longer apply to Objective-C code. Before, every one of SDWebImage's @interface SDDiskCache : NSObject <SDDiskCache>-style classes implemented itself.
In Swift, a call to an overloaded method now reaches the overload whose argument labels it spells, with defaulted parameters optional. Before, only the argument count was compared. Alamofire's self.tableView(tableView, numberOfRowsInSection:) inside another tableView overload linked to itself, and cancel(optionallyProducingResumeData:) linked to cancel(producingResumeData:).
A Swift call on a property declared with a type, like Kingfisher's var cache: ImageCache! or self.storage.write(…), now reaches that type's method or one it inherits. It no longer lands on a subclass override in a test, or on another type's method of the same name.
A Swift call on a value built on the spot, like JSONDecoder().decode(…) or Realm().create(…), now resolves to that type's method, or to one it inherits. It no longer lands on some other type's method of the same name: Vapor's JSONDecoder().decode calls had gone to a request's private container.
In Objective-C, [super init] and other messages to super now reach the superclass's method, never the sending class's own override. This also works where the index lost the @implementation's range. On SDWebImage, NSObject subclasses' [super init] used to land on SDDiskCache's init, and [self class] in tests on a proxy class's class. On AFNetworking, a serializer's [super encodeWithCoder:] now reaches its superclass. Re-index after upgrading.
In Swift, a call written with no receiver, or through self. or super., now reaches only a member of the type around it or of what that type inherits or conforms to, and the nearest override wins. A standard-library name later in a chain (axis.entries.removeAll(), names.contains(x)) no longer lands on a project type's method, unless the receiver or the call's argument label points to it. On Charts, min(a, b) and max(a, b) used to land on a range type's min field and a Sequence extension, and super.init(…) on an Objective-C demo's init over 170 times. A global in a playground or a test target is no longer linked from the main code. Re-index after upgrading.
In Objective-C, a message now reaches a method only when it could really be sent there. A message to self or super reaches only the sender's class and its superclasses, including categories on UIKit and AppKit views. A C-style call like completionBlock() is never taken for a method or property. A message to a local variable uses the variable's declared type (FMResultSet *rs). On SDWebImage, [self class], respondsToSelector: and isKindOfClass: used to land on a proxy class's overrides over 150 times, and on fmdb [rs close] now reaches the result set.
A Swift call through a nested type, like API.PackageController.GetRoute.query(on: db), now links to that type's method. Only query used to be kept, so the call linked to whichever type's query came first; in a Vapor app every route type has one, so callers, impact and codegraph_explore answers pointed at another endpoint's code. The same applies to nested types' initializers (API.PackageController.Model(name:)), to enum cases (Gitlab.Error.requestFailed(status:)), to types declared in an extension API.PackageController { … }, and to The Composable Architecture's Path.State.detail(…). A call on a type path that names no type in the project, such as an SDK's Plot.Node.footer(…), is left unlinked. Re-index Swift projects after upgrading.
A SwiftUI view, a @main app, a view controller and a UIView subclass are now indexed once. Each used to get a second, one-line copy with no callers or calls, which showed up next to the real type in search and codegraph_explore answers as a dead end. Re-index Swift projects after upgrading.
A Swift class or struct that declares a protocol composition across lines, like typealias Client = AutocompleteService.Client followed by & PostingService.Client on the next line, is now indexed whole. That line used to break the parse of the entire enclosing type, so its methods, initializer and properties went missing, and calls into them landed on same-named methods elsewhere. Re-index Swift projects after upgrading.
A Swift reference to a type now links to the type's own declaration, not to a file that extends it. An extension View { … } or extension Text { … } used to stand in for SwiftUI's type, so every view, every Text("…") and every Color.red in an app linked to whichever file happened to extend it. Those files topped the most-depended-on lists and their impact reached the whole app. A bare name like @State, @Test or Result<…> no longer links to some other type's nested State or Result, and a qualified name like Build.Id links to the Id it names. Methods declared in an extension of an SDK type still resolve on the types that conform to it, and a protocol's methods declared in any of its extensions now connect to each conforming type's own implementation. Re-index Swift projects after upgrading.
A Vapor route now links to the handler it names. use: SearchController.show used to link to whichever controller's show came first, so routes with a common handler name, like show, index or get, pointed at another endpoint's code in callers, impact and codegraph_explore answers. Nested types like API.PackageController.get and handlers declared in an extension of the controller now resolve too, and use: self.index resolves to the collection's own index. Re-index Vapor projects after upgrading.

C, C++, Go and Rust

A call in C code is no longer linked to a C++ class's method, since C has no methods and can't call one. Before, redis's POSIX read(fd, buf, n) calls and hiredis's c->funcs->read(…) function pointer pointed at a Qt adapter's read method.
In Go, a name written through an imported package from outside the module, like context.Context, http.ResponseWriter or testify's require.Contains, is no longer linked to a project symbol of that name. Before, fiber's context.Context parameters pointed at a method Stream.Context, its require.Contains(…) assertions at an extractor's Contains, and gin's http.ResponseWriter at its own ResponseWriter interface.
In Rust, Self::Error in a signature now resolves to the enclosing impl's or trait's own associated type. A path through a generic parameter, like V::Value, no longer resolves to an unrelated struct of that name. Before, serde's Self::Error signatures pointed at its one struct Error, and axum's Self::Error at axum-core's error type.
In Rust projects, a struct, handler or service name no longer resolves to an item declared inside some function body, and a file's own item comes before any other crate's. Before, axum's examples' Uri linked to a struct Uri declared inside a routing test, tokio's runtime Handle linked to tokio-test's, and ripgrep's Glob { … } in globset linked to the CLI flags' Glob.
Rust type and function names now follow Rust's scoping. A name from another file counts only when a use brings it in (or a * glob over its module). One imported from outside the project, like use std::task::{Context, Poll} or use futures::Stream, means that outside item. A path names its module: io::Result isn't an unrelated Result alias elsewhere, and std::io::Error is std's. On tokio, over 1,200 io::Result and 600 Context references had been landing on private project types.
A C++ call into a macro-opened namespace, like fmt::format("{}", x), now picks the overload its arguments fit. Before, the first overload indexed won: fmt's 1,400 fmt::format calls all reached the text_style overload in color.h. A narrow string literal now fits a narrow format string, a wide L"…" fits the wide overload, and the argument count has to fit too.
C++ classes written around macros and preprocessor conditionals now keep their members. These include an access specifier spelled as a macro (JSON_PRIVATE_UNLESS_TESTED:), an attribute macro after a template head or a doc comment, and an #if in the middle of a declaration, such as inside a constructor's initializer list. The first branch of a mid-declaration #if is the one indexed. nlohmann/json's basic_json class used to be lost whole and now has its roughly 390 members. Files with a parse error dropped on redis, curl, pybind11 and leveldb, and no file got worse. Re-index after upgrading.
Calls on a library's own types and modules no longer land on a project method that happens to share the name. In Rust, Vec::new(), String::from(…) and module paths like task::spawn(…) stay the standard library's. A later link of a multi-line Rust or Go chain now counts as a chained call, named after the chain's first line. In Go, w.Header().Get(…) is net/http's. In R, a plain call like range(x) is a function, not an object's method. In JavaScript, response.text() / .json() is fetch's. On tokio, task::spawn(…) used to land on TaskTracker::spawn 300 times. On ggplot2, range(…) used to land on a coordinate system's range method. Re-index after upgrading.
In C and C++, a qualified name like fmt::format now reaches a declaration inside a namespace the library opens with a macro, like fmt's FMT_BEGIN_NAMESPACE, pybind11's PYBIND11_NAMESPACE_BEGIN(…) or rapidjson's and spdlog's …_NAMESPACE_BEGIN. It also works through a namespace alias like namespace py = pybind11;. On fmt, 1,728 fmt::format(…) calls used to link to nothing, and so did about 1,400 py::… calls on pybind11.
In Rust and Go, a call later in a chain, like sym.filename().map(…) or c.Flags().String(…), no longer lands on the project's own method of that name when the name is a standard-library one (unwrap, clone, map, iter, Go's String or Error). A plain call like get(handler) or drop(x) never lands on a method. On tokio, .map(…) on an Option used to land on MutexGuard::map; on axum, the router's get(handler) on a cookie jar's get; on ripgrep, .clone() on an error type.
In Rust, a bare Ok(…), Some(…), Err(…), Result<…>, Option<…>, Vec<…> or drop(…) now means the standard library's, unless the file defines or imports a project item of that name. These used to link to any same-named enum variant or struct in the project: every Some(x) in ripgrep to one enum's Some variant, and every Ok and Result in serde to structs its macro-hygiene tests declare. An enum variant is now reached by a bare name only where the file uses it or its enum's *, and a variant never stands for a type. Re-index Rust projects after upgrading.

PHP, Ruby, Dart, Lua, R, Solidity, Erlang and CFML

In Laravel apps, a route whose controller is named by string now links to its handler, without needing a Controller suffix and keeping the namespace it's written with: 'Common\Uploads@inline', and Route::resource('companies', 'Common\Companies', [...]) with an options array. Two same-named controllers in different namespaces are told apart by that namespace. Before, akaunting linked 304 of its 313 routes to nothing.
In Rails apps, a resources line's only: and except: are now read in every form Rails accepts: %i[new create index], %w(index show), a quoted name, and the older :only => [...]. Before, only a bracketed list was read, so maybe's resources :family_exports, only: %i[new create index] became all seven routes, four of them to actions the controller doesn't have.
In PHP, a class written with a namespace in its name now links to that class. After use App\Fields as Field;, new Field\FirstName(), extends Field\Base and Field\FirstName::make() all name App\Fields\FirstName, as do Fields\FirstName written inside namespace App; and a fully qualified \App\Fields\FirstName. Before, none of these had a link, so callers and impact missed every class reached that way. Thanks @drakeo338. (#2256)
In Solidity, a call to an overloaded function now reaches the overload whose parameter count it fits, as in the other languages with overloading. Before, OpenZeppelin's _checkRole(role, _msgSender()) inside the one-argument _checkRole(bytes32 role) was linked to itself.
In R, a call like c(1, 2) is no longer linked to a data variable that happens to share a base function's name, since R skips non-function bindings when it looks up a call. Before, ggplot2's facet tests bound c <- data_frame(b = 3), and every c(…) call in those files pointed at that data frame. Functions built by a factory, like ggplot2's geom_point <- make_constructor(…), still resolve.
A Dart extension on X { … } with no name is no longer mistaken for the type X, and its members are reachable only inside the file that declares it, as in Dart. Before, bloc's linter linked analyzer's Token and Dart's Uri to small extension blocks, and every flutter_test find.text(…) call linked to a text getter on another example's TaskStatus.
In PHP, an unqualified class name now resolves to the current namespace's class or the one a use imports, as PHP does. If the imported class comes from a library, it resolves to nothing in the project. Before, koel's form requests linked extends Request to whichever Request class was indexed first, and BookStack's controllers linked Request $request (Laravel's, by import) to BookStack's own Request subclass.
A Dart call like ext.endsWith(".avi") or map.putIfAbsent(…) on a value whose type isn't known now counts as Dart's own String, List or Map method. It no longer lands on a project method of the same name. A Dart extension is also matched by the type it extends, not by its own name, so getx's ext.endsWith on a String stopped reaching extension RxStringExt on Rx<String>.
A bare Lua call like ipairs(t), error("…") or busted's setup() now means Lua's own function unless the file defines one. It no longer lands on a table method of the same name: telescope's ipairs calls had gone to a linked list's ipairs, and kong's error calls to its response module. A function's own alias of a host table member, like local get_query = kong.request.get_query, is now followed as well.
Lua calls made through a local alias now reach the function it names. That covers local splitn = require("kong.tools.string").splitn, a module member such as utils.select_listener, and a function a module exports under another name (return { check = check_phase }). Aliases of Lua's own functions, such as local type = type or local fmt = string.format, no longer show up as calls into your project. On Kong that is over 1,000 calls that now reach their real function, and about 5,000 fewer dead-end edges.
In Solidity, a call with no receiver now reaches a function of the contract around it or of one it inherits. On OpenZeppelin, _msgSender() in contracts built on Context used to land on ERC2771Context's override 83 times. In Erlang, a call to another module's function now follows the file's -import(Mod, [f/N]). On cowboy, -import(req_SUITE, [do_get/3]) calls used to land on another suite's do_get/3. A bare call with no such import no longer links to some other module. Re-index after upgrading.
In Lua and Luau, a call through a standard or host library table (string, table, io, vim, ngx, busted's assert…) or a string method like line:find(…) no longer lands on the one project method with the same name. Functions the project itself defines on those tables still link. On kong, the specs' assert.truthy(…) and assert.falsy(…) used to land on a condition helper over 1,700 times; on telescope, line:find(…) on the picker's find.
In PHP, a call through a variable nothing types no longer lands on an unrelated class's method just because it's the only method with that name. The variable now needs to be named after the method's class, or after a class that inherits it ($page->save() where Page extends Entity). On guzzle, the tests' $response->getHeaderLine() used to land on a test double; on symfony/console, $e->getMessage() on a progress bar.
In CFML, a call no longer lands on an unrelated component's method just because the name matches. A call with no receiver inside a component now reaches only that component's methods and those of the components it extends, so built-ins like now() stay built-ins. A call on an untyped variable now needs the variable to be named after the component, so server.keyExists(…) is no longer taken for some component's keyExists. On coldbox, now() used to land on a date helper over 200 times, and TestBox's fail(…) in specs now reaches the spec base class.
In Ruby, a call no longer lands on an unrelated class's method just because it's the only method with that name. A call on an untyped receiver now needs the receiver to be named after the method's class, like web_push_request.legacy_encrypt. A call with no receiver inside a class now reaches only that class's methods, its superclasses' methods, and those of the modules it includes, extends or prepends. On rubocop, node.loc on a syntax node used to land on the project's one loc method over 1,200 times, and Kernel's format(…) on the language server's format. On mastodon, render in controllers used to land on an inline renderer, and authorize now reaches the authorization concern.
In Dart, a call written without a receiver now reaches only a method of the class it's written in, of a class it extends, mixes in or implements, or of an extension on one of those types, and picks the nearest one. On riverpod, package:test's test(…) in the test files used to land on a container class's test method over 1,100 times, shelf's and getx's expect(…) on unrelated classes' expect, and bloc's emit(…) in a Cubit on the wrong base class. Classes declared as class A = B with C; are now indexed under their name, with what they extend and mix in. Re-index after upgrading.
In R, a variable assigned at the top of a test file is no longer linked from the package or from other tests, because testthat runs each test file in its own environment. On ggplot2, a test's c <- ggplot(…) used to collect 2,455 of the package's c(…) calls. Variables in helper-*.R and setup-*.R, which testthat loads for every test, are still shared.
In Lua and Luau, a local variable or function is no longer linked from other files, since it's only visible in the file that declares it. On kong, a spec helper's local it = it used to collect every other spec file's it(…) (over 4,000 links), and one module's local ipairs = ipairs took the whole project's ipairs(…). Global functions are still linked across files.
PHP calls on $this, self, static and parent now reach the method of the class they're written in, a class it extends, or a trait any of them uses, with parent classes and traits found through the file's namespace and use imports. On Drupal core, $this->assertEquals() (PHPUnit's) used to link to an unrelated comparator class 8,832 times, $this->assertSession() to a JavaScript-test base class, and $this->t() to Views::t. They now reach UiHelperTrait and StringTranslationTrait, or nothing when the method lives in a package outside the repository. A call inside a trait, and a base class calling a method its subclass defines, keep their links. Re-index PHP projects after upgrading.
A PHP function call written after => in an array, like 'count' => count($items), 'by' => user()->id or 'label' => trans('…'), is now read as a plain function call. It used to be taken for a method call and linked to whichever class had a method of that name. On BookStack, that meant 166 wrong links.
A PHP call written without a receiver, such as redirect($url), view('books.show'), auth() or basename($path), is a function call, and no longer links to a same-named method, field or class elsewhere in the project. These wrong links showed up in callers, impact and codegraph_explore answers wherever a Laravel helper or PHP built-in shared its name with a project member. Re-index PHP projects after upgrading.