[colbymchenry]

Summary

Fixes #2499. Both engines now index a named class expression as a class, with its methods, properties, extends and implements. That covers register(class Widget extends Base {…}), const Panel = class PanelImpl extends Base {…}, customElements.define('x-card', class XCard extends HTMLElement {…}) and module.exports = class Router {…}. Calls inside the class link as they do in a class declaration: this.run() to its own method, super.run() to the parent's (through #2818's matcher), and Widget.build() to the static method.

The name stays scoped as JavaScript scopes it:

• new Widget() outside the expression links nothing.
• A same-named class, constant or interface outside keeps its links.
• Code outside never reaches the class's methods by a name guess.

A class a CommonJS module exports is the exception: module.exports = class Router {…} or exports.Store = class Store {…}. That class is the module's value, and require hands it to every importer. So it reads as a declaration does, and a require of it reaches the class, its static methods and the methods called on its instances.

Root cause

Both extractors treated class_declaration (and TypeScript's abstract_class_declaration) as a class, but not tree-sitter's class node, which is what a class expression parses as. Its body was then walked as plain code, so:

• methods became free functions (function run), or, in a variable's initializer, weren't indexed at all (const Panel = class PanelImpl {…} gave only constant Panel);
• there were no extends or implements references;
• this, super and static calls had no class to start from.

The free functions were also targets for bare-name guesses from anywhere. For example, webpack's module.exports = class MultiCompiler {…} had its methods as functions, so a call to _runGraph's parameter run linked to MultiCompiler's run.

Fix

Extraction, in both engines (src/extraction/tree-sitter.ts, languages/typescript.ts, languages/javascript.ts, the kernel's tsjs/mod.rs and tsjs/extractors.rs):

• In TS, TSX, JS, JSX and ArkTS, a class node with a name is a class type. An anonymous one is passed over, as before.
• The class's signature is its head (class Widget extends Base), which marks it as an expression, since a declaration's signature is null. The class is never exported by itself.
• Members nest under it as in a declaration: Widget::run, and Panel::PanelImpl::go for an initializer, which keeps the variable's name in front as other initializer members do.

Resolution (src/resolution/js-class-expressions.ts, src/resolution/index.ts):

• Outside every class expression. A reference from a TS, TSX, JS, JSX, ArkTS, Vue, Svelte or Astro file resolves in a view of the graph that hides every scoped class expression and its members:
  • name, qualified-name, kind, in-file and method lookups filter;
  • the known-names pre-filter treats a name that only class expressions carry as unknown, which keeps the view as cheap as the full graph.
• Inside a class expression. A reference sees the whole graph, unless it names another class expression (by the name, or the head of a dotted name). Then it gets the outside view too.
• A class a CommonJS module exports isn't scoped. That's a class right after module.exports =, exports.X = or module.exports.X =, which the resolver reads from the source in front of it.
• Imports. The lookups the import resolver reads a module's exports by are left whole.
• Named CommonJS exports (src/resolution/alias-binding.ts): the reader of exports.X = … now takes exports.Store = class StoreImpl {…} too, so const { Store } = require('./store') reaches StoreImpl. Before, it took only functions and identifiers.

Validation

• New test __tests__/js-class-expressions.test.ts (13 tests). On main d5fc1fb, 11 fail. All 13 pass on the fix. The tests cover:

  • extraction in .ts, .tsx, .js and .jsx through the kernel and wasm, with kernel/wasm agreement on every node and reference;
  • scope in .js and .ts: new Widget() outside, another class expression's name inside one, a same-named declaration and constant, a static Tool.make(), and nitro's interface-and-class-expression shape;
  • lit's DOM-shim shape, where document.createElement(…) and container.appendChild(…) must not guess into the shim's methods;
  • CommonJS: module.exports = class Router with new Router(), Router.make() and r.route() on an instance; exports.Store = class StoreImpl with Store.open(); and a scoped register(class Hidden …) next to them.

  The 2 tests that pass on main are kernel/wasm agreement and the lit-shaped guard. Mutating each of 7 parts fails a test:

  • the view;
  • the inside check;
  • the name rule;
  • the expression marker;
  • the class node;
  • the CommonJS export rule;
  • the named-export reader.

• The issue's repro (V1's files, through both engines, which give identical edges):

  • class Widget with Widget::run and Widget::extra, extends Widget -> Base, super.run() -> Base::run and this.run() -> Widget::run;
  • Panel::PanelImpl with go and helper;
  • XCard with connectedCallback -> XCard::render;
  • new Gadget() outside its expression stays unresolved.

• Declaration parity: a fixture with the same class written as a declaration and as a class expression gives the same edges for super.run(), this.run(), this.base() and Widget.build(). Through require, the same holds for module.exports = class against module.exports = Foo, and for exports.Store = class against exports.Router = Router, for static and typed instance calls.

• A/B against main d5fc1fb on 22 repos (20 TS/JS, plus flask and gin), each arm indexed fresh:

  • 193 classes are added in 10 repos, with their members;
  • 801 edge sites change in 7 repos: jest 669, lit 75, webpack (lib) 38, nitro 7, memfs 6, webdriverio 5, vite 1;
  • each was bucketed by kind and cause, and samples from every bucket were checked by hand against the source.

  	sites	what
  jest's global test()	563	0.4 guesses that move from one wrong namesake to another. The old one, test() in an e2e fixture's module.exports = class Test {…}, is now a method, which a bare call doesn't reach.
  structure	85	new extends, implements and type references of class expressions: lit's SSR shim classes implements MediaListInterface, webpack's module.exports = class FallbackModuleFactory extends ModuleFactory, memfs's FileSystemObserver
  moved to the member	74	calls, news and references now come from the method they are written in, not the constant or file around it
  gained or changed	65	see below
  removed	14	11 guesses into scoped class-expression members from outside, like lit's import { render } from 'lit' landing on a shim's render, and webpack's call to the parameter run. Also 3 super calls whose parent the index can't name: nitro's class extending vite's DevEnvironment, and webpack's extends (ESMImportDependency.Template). Each had gone to the wrong method.

  The 65 that gain or change a target:

  • Inside class expressions, 24:
    • lit's shim Element.toggleAttribute calls its own hasAttribute, removeAttribute and setAttribute. The last went to ElementRenderer::setAttribute before.
    • The shim's Event.stopImmediatePropagation and CSSStyleSheet.replace call their own methods too.
    • webpack's CssIcssExportDependencyTemplate makes 12 calls to its own statics, and MultiCompiler.close calls this.watching.close(). One this.replaceCall() goes from 0.7 to 0.9.
    • nitro's and jest's this.#onInit?.(), this.devServer.close?.(), this.specFilter(spec) and this.it(…).
    • One is a guess: lit's scoped-registry mixin, whose superclass is a parameter, calls this.attachShadow(), which now reaches the SSR shim's Element.attachShadow, as it would were the shim a declaration.
  • Through require, 31:
    • SizeLimitsPlugin.isOverSizeLimit(…) reaches the static method.
    • compiler.setDependencies(…) on a new MultiCompiler(…) reaches MultiCompiler::setDependencies.
    • jest's 10 localClass.test() and scopedInstance.test() calls on a new TestClass() reach Test::test.
    • 18 new X() calls reach the class, 14 of them rather than the local constant require was assigned to.
  • Synthesized edges, 6: override edges of new subclasses, like TestClassA::constructor → Child::constructor, as declarations get.
  • Guess churn, 4: webpack's factory.create(…) calls on an untyped factory move from one 0.65 guess to another, ContextModuleFactory::create to ContainerEntryModuleFactory::create. Neither is the one called.

  Nodes and edges are unchanged in 12 repos, the controls among them, and their dumps are byte-identical. nuxt, social-app and outline gain only nodes.

• Kernel parity (scripts/kernel-parity.mjs): no file differs on 22 repos. On the final build, lit, webpack, memfs, nitro, webdriverio and jest give the same counts and deferrals as that sweep.

• Sync: three CLI scenarios match a fresh index:

  • a parent moving and gaining a method that a class expression's super call then reaches;
  • a shim class expression gaining a member while another file starts importing it;
  • one module starting to export its class expression while another stops, with the importer edited.

  One case stays stale, and it's pre-existing: an importer that isn't edited keeps what it resolved when only the other module's module.exports line changes. Declarations on main do the same (checked with module.exports = Store becoming module.exports = {}, and the reverse).

• Index time, median of 5 interleaved runs:

  repo	main	fix	change
  lit	9.17 s	9.24 s	+0.8%
  webpack (lib)	11.18 s	11.48 s	+2.7%
  jest	11.80 s	11.87 s	+0.6%
  insomnia	14.56 s	16.42 s	+12.8%

  insomnia's gap is other jobs' load on the machine, not this change. It holds no class expression and indexes byte-identically, and its resolver time, profiled twice per arm, is the same on both: 25.5 and 26.4 s on the fix against 25.5 and 25.9 s on main. The A/B's own 3 rounds gave lit +1.1%, webpack +0.8% and jest −5.1%.

• Base: the branch is on main 23a80a8. The A/B, parity and timing ran against d5fc1fb, and the two commits between, fix(kotlin): repository().pending() links the method of the type repository() declares #2822 and fix(python): a from-import of a module with no dot in its name links the module's file #2823, change Kotlin and Python resolution only.

• Full suite on this commit (CODEGRAPH_KERNEL_EXPECT=1, kernel rebuilt on the rebased branch): 735 test files passed and 6 skipped; 8,799 tests passed, 82 skipped, none failed.

Left out

• Class values beyond require. Resolution doesn't track values, and the issue scopes this out too. This covers:
  • export const Panel = class PanelImpl {…} used as Panel.make() from another module;
  • a class a factory returns;
  • X.Template = class XTemplate {…}.
• A heritage written as a member expression, like webpack's extends (ESMImportDependency.Template), gives no extends edge, for declarations and expressions alike. So a super call there links nothing.
• A pre-existing gap: an inherited this.run() with a same-named method elsewhere in the file links to that namesake at 0.4 rather than the parent's method. Class declarations do the same on main.

I read contributor PR #2500 by @Puma7, who also reported the issue, for guidance. This implementation and its tests are our own, and the CHANGELOG credits @Puma7 for both.

🤖 Generated with Claude Code