feat(resolver): resolve super.method() dispatch via class expression + static block + field def (#1399)

* feat(resolver): resolve super.method() dispatch via class expression + static block + field def

- Add `(class name: ...)` query patterns for JS/TS class expressions so that
  `return class Foo extends Bar { ... }` records the extends relationship in
  ctx.classes — previously only class_declaration was captured, leaving class
  expressions invisible to resolveThisDispatch.

- Add `class_static_block` → `ClassName.<static>` synthetic method definition
  in both query path (extractClassMembersWalk) and walk path (walkJavaScriptNode).
  Calls inside `static { super.f(); }` blocks are now attributed to a method-kind
  node so the CHA parents map can resolve `super.f()` to the parent class.

- Add `field_definition`/`public_field_definition` → `ClassName.fieldName` method
  definition when the field value is an arrow function or function expression.
  `static f = () => { ... }` becomes a resolvable `A.f` node so
  `resolveThisDispatch` can emit the `B.<static> → A.f` edge.

- Mirror all three changes in the native Rust extractor for parity.

- Add 6 parser unit tests and import Jelly micro-test fixtures for super,
  super2, super3, super4, super5 as ground-truth benchmarks.

Benchmark result: super fixture 31% → 38% recall (B.<static> → A.f now resolved).

docs check acknowledged

Closes #1377

* fix(extractor): guard handleFieldDef to only emit callable field definitions (#1399)

Impact: 2 functions changed, 18 affected

* fix(extractor): remove unreachable duplicate match arms in Rust match_js_node (#1399)

The PR moved class_static_block and field_definition earlier in the match block
(lines 771/773) but left identical arms below (lines 786/787) as dead code.
Removing them eliminates Rust unreachable_patterns warnings.

Author: carlos-alm

crates/codegraph-core/src/extractors/javascript.rs

@@ -763,10 +763,14 @@ fn match_js_call_assignments(node: &Node, source: &[u8], symbols: &mut FileSymbo
 fn match_js_node(node: &Node, source: &[u8], symbols: &mut FileSymbols, _depth: usize) {
     match node.kind() {
         "function_declaration" | "generator_function_declaration" => handle_function_decl(node, source, symbols),
-        "class_declaration" | "abstract_class_declaration" => {
+        "class_declaration" | "abstract_class_declaration"
+        // class expressions: `return class Foo extends Bar { ... }` or `const X = class Foo { ... }`
+        | "class" => {
             handle_class_decl(node, source, symbols)
         }
+        "class_static_block" => handle_static_block(node, source, symbols),
         "method_definition" => handle_method_def(node, source, symbols),
+        "field_definition" | "public_field_definition" => handle_field_def(node, source, symbols),
         "interface_declaration" => handle_interface_decl(node, source, symbols),
         "type_alias_declaration" => handle_type_alias(node, source, symbols),
         "enum_declaration" => handle_enum_decl(node, source, symbols),
@@ -776,11 +780,6 @@ fn match_js_node(node: &Node, source: &[u8], symbols: &mut FileSymbols, _depth:
         "import_statement" => handle_import_stmt(node, source, symbols),
         "export_statement" => handle_export_stmt(node, source, symbols),
         "expression_statement" => handle_expr_stmt(node, source, symbols),
-        // Synthetic definitions for class field initializers and static blocks.
-        // These give `findCaller` a narrower span with a kind that passes the SQL
-        // call-edge filter (`kind IN ('function','method')`), matching WASM behaviour.
-        "field_definition" | "public_field_definition" => handle_field_def(node, source, symbols),
-        "class_static_block" => handle_static_block(node, source, symbols),
         _ => {}
     }
 }
@@ -864,6 +863,29 @@ fn handle_method_def(node: &Node, source: &[u8], symbols: &mut FileSymbols) {
     }
 }
 
+/// Create a synthetic `ClassName.<static:L:C>` definition for a class static block
+/// so that calls inside the block are attributed to a method-kind node and
+/// `super.method()` dispatch can walk up to the parent class.
+///
+/// The start line and column are appended to the name to ensure uniqueness when a
+/// class has multiple `static { }` blocks (each has a distinct start position even
+/// if on the same line).
+fn handle_static_block(node: &Node, source: &[u8], symbols: &mut FileSymbols) {
+    let Some(class_name) = find_parent_class(node, source) else { return };
+    let line = start_line(node);
+    let col = node.start_position().column;
+    symbols.definitions.push(Definition {
+        name: format!("{}.<static:{}:{}>", class_name, line, col),
+        kind: "method".to_string(),
+        line,
+        end_line: Some(end_line(node)),
+        decorators: None,
+        complexity: None,
+        cfg: None,
+        children: None,
+    });
+}
+
 /// Emit a `ClassName.fieldName` synthetic definition for each `class { field = ... }` node.
 /// Only fired when a value node is present (skips bare `x;` declarations), mirroring the WASM
 /// `handleFieldDef` guard.  The synthetic definition has `kind = "method"` so that the SQL
@@ -881,7 +903,12 @@ fn handle_field_def(node: &Node, source: &[u8], symbols: &mut FileSymbols) {
         return;
     }
     // Skip uninitialised fields (`class C { x; }`) — must have a value node.
-    let Some(_value_node) = node.child_by_field_name("value") else { return };
+    let Some(value_node) = node.child_by_field_name("value") else { return };
+    // Only emit a callable definition when the initializer is a function/arrow expression.
+    // Scalar fields like `static x = 42` should not appear as method-kind nodes.
+    if !matches!(value_node.kind(), "arrow_function" | "function_expression" | "generator_function") {
+        return;
+    }
     let field_name = node_text(&name_node, source);
     if field_name.is_empty() { return; }
     let Some(class_name) = find_parent_class(node, source) else { return };
@@ -897,23 +924,6 @@ fn handle_field_def(node: &Node, source: &[u8], symbols: &mut FileSymbols) {
     });
 }
 
-/// Emit a `ClassName.<static>` synthetic definition for each `static { }` block.
-/// Enables `findCaller` to attribute calls inside static initializer blocks to this
-/// synthetic node rather than to the enclosing class node, matching WASM behaviour.
-fn handle_static_block(node: &Node, source: &[u8], symbols: &mut FileSymbols) {
-    let Some(class_name) = find_parent_class(node, source) else { return };
-    symbols.definitions.push(Definition {
-        name: format!("{}.<static>", class_name),
-        kind: "function".to_string(),
-        line: start_line(node),
-        end_line: Some(end_line(node)),
-        decorators: None,
-        complexity: None,
-        cfg: None,
-        children: None,
-    });
-}
-
 fn handle_interface_decl(node: &Node, source: &[u8], symbols: &mut FileSymbols) {
     let Some(name_node) = node.child_by_field_name("name") else { return };
     let iface_name = node_text(&name_node, source).to_string();

src/extractors/javascript.ts

@@ -738,6 +738,13 @@ function walkJavaScriptNode(node: TreeSitterNode, ctx: ExtractorOutput): void {
     case 'class':
       handleClassDecl(node, ctx);
       break;
+    case 'class_static_block':
+      handleStaticBlock(node, ctx.definitions);
+      break;
+    case 'field_definition':
+    case 'public_field_definition':
+      handleFieldDef(node, ctx.definitions);
+      break;
     case 'method_definition':
       handleMethodDef(node, ctx);
       break;
@@ -769,13 +776,6 @@ function walkJavaScriptNode(node: TreeSitterNode, ctx: ExtractorOutput): void {
     case 'expression_statement':
       handleExpressionStmt(node, ctx);
       break;
-    case 'field_definition':
-    case 'public_field_definition':
-      handleFieldDef(node, ctx.definitions);
-      break;
-    case 'class_static_block':
-      handleStaticBlock(node, ctx.definitions);
-      break;
   }
 
   for (let i = 0; i < node.childCount; i++) {
@@ -843,39 +843,63 @@ function handleMethodDef(node: TreeSitterNode, ctx: ExtractorOutput): void {
   }
 }
 
+/**
+ * Create a synthetic `ClassName.<static:L:C>` definition for a class static block
+ * so that calls inside the block can be attributed to a method-kind node and
+ * `resolveThisDispatch` can walk up to the parent class for `super.method()`.
+ *
+ * The start line and column are appended to the name to ensure uniqueness when a
+ * class has multiple `static { }` blocks (each has a distinct start position even
+ * if on the same line).
+ *
+ * Tree-sitter uses `class_static_block` (not `static_block`) for `static { ... }`.
+ */
+function handleStaticBlock(node: TreeSitterNode, definitions: Definition[]): void {
+  const parentClass = findParentClass(node);
+  if (!parentClass) return;
+  const line = nodeStartLine(node);
+  const col = node.startPosition.column;
+  definitions.push({
+    name: `${parentClass}.<static:${line}:${col}>`,
+    kind: 'method',
+    line,
+    endLine: nodeEndLine(node),
+  });
+}
+
 /**
  * Emit a `ClassName.fieldName` definition for class fields that have an initializer.
  * This lets `findCaller` attribute calls inside field initializers (e.g. static field
  * side-effects) to the field rather than the enclosing class.
+ *
+ * JS `field_definition` uses the `'property'` field name; TS
+ * `public_field_definition` uses `'name'`. As a third fallback (Rust/TS parity) we
+ * also check for a positional `property_identifier` child.
  */
+const CALLABLE_FIELD_TYPES = new Set([
+  'arrow_function',
+  'function_expression',
+  'generator_function',
+]);
+
 function handleFieldDef(node: TreeSitterNode, definitions: Definition[]): void {
   // JS field_definition uses 'property' field; TS public_field_definition uses 'name' field
-  const nameNode = node.childForFieldName('name') || node.childForFieldName('property');
+  const nameNode =
+    node.childForFieldName('name') ||
+    node.childForFieldName('property') ||
+    findChild(node, 'property_identifier');
   const valueNode = node.childForFieldName('value');
   if (!nameNode || !valueNode) return;
   if (nameNode.type === 'computed_property_name') return;
+  // Only emit a callable definition when the initializer is a function/arrow expression.
+  // Scalar fields like `static x = 42` should not appear as method-kind nodes.
+  if (!CALLABLE_FIELD_TYPES.has(valueNode.type)) return;
   const fieldName = nameNode.text;
   if (!fieldName) return;
-  const className = findParentClass(node);
-  if (!className) return;
-  definitions.push({
-    name: `${className}.${fieldName}`,
-    kind: 'method',
-    line: nodeStartLine(node),
-    endLine: nodeEndLine(node),
-  });
-}
-
-/**
- * Emit a `ClassName.<static>` definition for each `static { }` block.
- * Enables `findCaller` to attribute calls inside static initializer blocks to
- * this synthetic node rather than to the enclosing class node.
- */
-function handleStaticBlock(node: TreeSitterNode, definitions: Definition[]): void {
-  const className = findParentClass(node);
-  if (!className) return;
+  const parentClass = findParentClass(node);
+  if (!parentClass) return;
   definitions.push({
-    name: `${className}.<static>`,
+    name: `${parentClass}.${fieldName}`,
     kind: 'method',
     line: nodeStartLine(node),
     endLine: nodeEndLine(node),

tests/benchmarks/resolution/fixtures/jelly-micro/classes/expected-edges.json

@@ -366,7 +366,7 @@
     },
     {
       "source": {
-        "name": "C6.<static>",
+        "name": "C6.<static:75:2>",
         "file": "classes.js"
       },
       "target": {
@@ -378,7 +378,7 @@
     },
     {
       "source": {
-        "name": "C6.<static>",
+        "name": "C6.<static:78:2>",
         "file": "classes.js"
       },
       "target": {

tests/benchmarks/resolution/fixtures/jelly-micro/super/expected-edges.json

@@ -78,7 +78,7 @@
     },
     {
       "source": {
-        "name": "B.<static>",
+        "name": "B.<static:36:2>",
         "file": "super.js"
       },
       "target": {

tests/parsers/javascript.test.ts

@@ -99,18 +99,27 @@ describe('JavaScript parser', () => {
   });
 
   it('extracts static class field definitions as method definitions', () => {
-    const symbols = parseJS(`class C6 { static staticProperty = (f1(), function() {}); }`);
+    const symbols = parseJS(`class C6 { static staticProperty = function() {}; }`);
     expect(symbols.definitions).toContainEqual(
       expect.objectContaining({ name: 'C6.staticProperty', kind: 'method' }),
     );
   });
 
-  it('extracts static blocks as method definitions', () => {
+  it('does not extract scalar static field definitions as method definitions', () => {
+    const symbols = parseJS(`class C7 { static x = 42; }`);
+    const names = symbols.definitions.map((d: { name: string }) => d.name);
+    expect(names).not.toContain('C7.x');
+  });
+
+  it('extracts static blocks as method definitions with unique names', () => {
     const symbols = parseJS(`class C6 { static { f1(); } static { f2(); } }`);
-    const staticDefs = symbols.definitions.filter((d) => d.name === 'C6.<static>');
+    // Each static block gets a unique name with line:column suffix to avoid collisions
+    const staticDefs = symbols.definitions.filter((d) => d.name.startsWith('C6.<static:'));
     expect(staticDefs).toHaveLength(2);
     expect(staticDefs[0]).toMatchObject({ kind: 'method' });
     expect(staticDefs[1]).toMatchObject({ kind: 'method' });
+    // Names must be distinct even on the same line
+    expect(staticDefs[0].name).not.toBe(staticDefs[1].name);
   });
 
   it('extracts import statements', () => {
@@ -1166,16 +1175,17 @@ describe('JavaScript parser', () => {
       expect(superCall).toBeDefined();
     });
 
-    it('creates ClassName.<static> definition for class static block', () => {
+    it('creates ClassName.<static:L:C> definition for class static block', () => {
       const symbols = parseJS(`class A extends B {\n  static {\n    super.init();\n  }\n}`);
-      expect(symbols.definitions).toContainEqual(
-        expect.objectContaining({ name: 'A.<static>', kind: 'method' }),
-      );
+      // Name includes line:column suffix for uniqueness
+      const staticDef = symbols.definitions.find((d) => d.name.startsWith('A.<static:'));
+      expect(staticDef).toBeDefined();
+      expect(staticDef).toMatchObject({ kind: 'method' });
     });
 
-    it('attributes super.method() call inside static block to ClassName.<static>', () => {
+    it('attributes super.method() call inside static block to ClassName.<static:L:C>', () => {
       const symbols = parseJS(`class A extends B {\n  static {\n    super.init();\n  }\n}`);
-      const staticDef = symbols.definitions.find((d) => d.name === 'A.<static>');
+      const staticDef = symbols.definitions.find((d) => d.name.startsWith('A.<static:'));
       expect(staticDef).toBeDefined();
       const superCall = symbols.calls.find((c) => c.name === 'init' && c.receiver === 'super');
       expect(superCall).toBeDefined();