fix(wasm): port computed methods, class expressions, array destructuring, prototype params to JS extractor

Closes #1471

Four extraction gaps in the WASM JS extractor caused 25 node diffs
against the native engine in the jelly-micro parity fixture:

1. Computed property method names (e.g. `['property7']`): the query
   patterns in both parser.ts and wasm-worker-entry.ts only matched
   `property_identifier` and `private_property_identifier` as the
   `name` field of `method_definition`; add a third pattern for
   `computed_property_name`.

2. Class expressions inside functions (`return class PostMixin …`):
   wasm-worker-entry.ts JS_CLASS_PATTERN was a single string matching
   only `class_declaration`; rename to JS_CLASS_PATTERNS array and add
   the `(class name: …)` pattern for anonymous class-expression nodes.
   Also add the matching `(class name: (type_identifier) …)` pattern
   to TS_EXTRA_PATTERNS so TS class expressions are covered too.

3. Array destructuring constants (`const [x, y] = …`): both
   `extractDestructuredBindingsWalk` (query path) and
   `handleVariableDecl` (walk path) only handled `object_pattern`; add
   an `array_pattern` branch that emits a single `constant` node whose
   name is the full array pattern text — matching native behaviour.

4. Parameters of prototype arrow/function methods
   (`Arit.prototype.sum = (x, y) => …`): `emitPrototypeMethod` emitted
   the definition node without calling `extractParameters`, so children
   were always absent; add the call and wire the result through.

After this fix `parity-compare.mjs --langs jelly-micro` reports
0 node diffs (was 25). 22 pre-existing edge diffs remain (tracked
in #1506) — those are out of scope.

Author: carlos-alm

src/domain/parser.ts

@@ -158,6 +158,7 @@ const COMMON_QUERY_PATTERNS: string[] = [
   '(variable_declarator name: (identifier) @varfn_name value: (generator_function) @varfn_value)',
   '(method_definition name: (property_identifier) @meth_name) @meth_node',
   '(method_definition name: (private_property_identifier) @meth_name) @meth_node',
+  '(method_definition name: (computed_property_name) @meth_name) @meth_node',
   '(import_statement source: (string) @imp_source) @imp_node',
   '(export_statement) @exp_node',
   '(call_expression function: (identifier) @callfn_name) @callfn_node',

src/domain/wasm-worker-entry.ts

@@ -115,6 +115,7 @@ const COMMON_QUERY_PATTERNS: string[] = [
   '(variable_declarator name: (identifier) @varfn_name value: (generator_function) @varfn_value)',
   '(method_definition name: (property_identifier) @meth_name) @meth_node',
   '(method_definition name: (private_property_identifier) @meth_name) @meth_node',
+  '(method_definition name: (computed_property_name) @meth_name) @meth_node',
   '(import_statement source: (string) @imp_source) @imp_node',
   '(export_statement) @exp_node',
   '(call_expression function: (identifier) @callfn_name) @callfn_node',
@@ -125,11 +126,17 @@ const COMMON_QUERY_PATTERNS: string[] = [
   '(expression_statement (assignment_expression left: (member_expression) @assign_left right: (_) @assign_right)) @assign_node',
 ];
 
-const JS_CLASS_PATTERN: string = '(class_declaration name: (identifier) @cls_name) @cls_node';
+const JS_CLASS_PATTERNS: string[] = [
+  '(class_declaration name: (identifier) @cls_name) @cls_node',
+  // class expressions: `return class Foo extends Bar { ... }` or `const X = class Foo { ... }`
+  '(class name: (identifier) @cls_name) @cls_node',
+];
 
 const TS_EXTRA_PATTERNS: string[] = [
   '(class_declaration name: (type_identifier) @cls_name) @cls_node',
   '(abstract_class_declaration name: (type_identifier) @cls_name) @cls_node',
+  // class expressions: `return class Foo extends Bar { ... }`
+  '(class name: (type_identifier) @cls_name) @cls_node',
   '(interface_declaration name: (type_identifier) @iface_name) @iface_node',
   '(type_alias_declaration name: (type_identifier) @type_name) @type_node',
 ];
@@ -433,7 +440,7 @@ async function loadLanguageLazy(entry: LanguageRegistryEntry): Promise<Parser |
       const isTS = entry.id === 'typescript' || entry.id === 'tsx';
       const patterns = isTS
         ? [...COMMON_QUERY_PATTERNS, ...TS_EXTRA_PATTERNS]
-        : [...COMMON_QUERY_PATTERNS, JS_CLASS_PATTERN];
+        : [...COMMON_QUERY_PATTERNS, ...JS_CLASS_PATTERNS];
       _queries.set(entry.id, new Query(lang, patterns.join('\n')));
     }
     return parser;

src/extractors/javascript.ts

@@ -507,6 +507,15 @@ function extractDestructuredBindingsWalk(node: TreeSitterNode, definitions: Defi
             nodeEndLine(declNode),
             definitions,
           );
+        } else if (nameN && nameN.type === 'array_pattern') {
+          // `const [x, y] = ...` — emit a single constant node whose name is the
+          // full array pattern text (e.g. `[x, y]`), matching native engine behaviour.
+          definitions.push({
+            name: nameN.text,
+            kind: 'constant',
+            line: nodeStartLine(declNode),
+            endLine: nodeEndLine(declNode),
+          });
         }
       }
     }
@@ -1017,6 +1026,16 @@ function handleVariableDecl(node: TreeSitterNode, ctx: ExtractorOutput): void {
             nodeEndLine(node),
             ctx.definitions,
           );
+        } else if (isConst && nameN.type === 'array_pattern' && !hasFunctionScopeAncestor(node)) {
+          // Array destructuring: `const [x, y] = ...` — emit a single constant node
+          // whose name is the full array pattern text (e.g. `[x, y]`), matching
+          // native engine behaviour. Scope guard mirrors the object_pattern branch above.
+          ctx.definitions.push({
+            name: nameN.text,
+            kind: 'constant',
+            line: nodeStartLine(node),
+            endLine: nodeEndLine(node),
+          });
         }
       }
     }
@@ -3359,11 +3378,13 @@ function emitPrototypeMethod(
 ): void {
   const fullName = `${className}.${methodName}`;
   if (rhs.type === 'function_expression' || rhs.type === 'arrow_function') {
+    const params = extractParameters(rhs);
     definitions.push({
       name: fullName,
       kind: 'method',
       line: nodeStartLine(rhs),
       endLine: nodeEndLine(rhs),
+      children: params.length > 0 ? params : undefined,
     });
   } else if (rhs.type === 'identifier' && !BUILTIN_GLOBALS.has(rhs.text)) {
     // Prototype alias: `A.prototype.t = f` → typeMap['A.t'] = { type: 'f' }

tests/parsers/javascript.test.ts

@@ -1265,4 +1265,118 @@ describe('JavaScript parser', () => {
       );
     });
   });
+
+  describe('computed method name extraction (#1471)', () => {
+    it('extracts computed getter method from object literal', () => {
+      const symbols = parseJS(`const obj = { get ['property7']() {} };`);
+      expect(symbols.definitions).toContainEqual(
+        expect.objectContaining({ name: "['property7']", kind: 'method' }),
+      );
+    });
+
+    it('extracts computed setter method with parameter from object literal', () => {
+      const symbols = parseJS(`const obj = { set ['property8'](value) {} };`);
+      const def = symbols.definitions.find((d) => d.name === "['property8']");
+      expect(def).toBeDefined();
+      expect(def).toMatchObject({ kind: 'method' });
+      expect(def!.children).toContainEqual(
+        expect.objectContaining({ name: 'value', kind: 'parameter' }),
+      );
+    });
+
+    it('extracts computed regular method with parameter from object literal', () => {
+      const symbols = parseJS(`const obj = { ['property9'](parameters) {} };`);
+      const def = symbols.definitions.find((d) => d.name === "['property9']");
+      expect(def).toBeDefined();
+      expect(def!.children).toContainEqual(
+        expect.objectContaining({ name: 'parameters', kind: 'parameter' }),
+      );
+    });
+
+    it('extracts computed generator method from object literal', () => {
+      const symbols = parseJS(`const obj = { *['generator10'](parameters) {} };`);
+      expect(symbols.definitions).toContainEqual(
+        expect.objectContaining({ name: "['generator10']", kind: 'method' }),
+      );
+    });
+
+    it('extracts computed async method from object literal', () => {
+      const symbols = parseJS(`const obj = { async ['property11'](parameters) {} };`);
+      expect(symbols.definitions).toContainEqual(
+        expect.objectContaining({ name: "['property11']", kind: 'method' }),
+      );
+    });
+  });
+
+  describe('class expression inside function extraction (#1471)', () => {
+    it('extracts named class expression returned from a function', () => {
+      const symbols = parseJS(
+        `function mixin() { return class PostMixin extends A { constructor() { super(); } }; }`,
+      );
+      expect(symbols.definitions).toContainEqual(
+        expect.objectContaining({ name: 'PostMixin', kind: 'class' }),
+      );
+    });
+
+    it('records extends relationship for class expression inside function', () => {
+      const symbols = parseJS(`function mixin() { return class PostMixin extends A { m() {} }; }`);
+      expect(symbols.classes).toContainEqual(
+        expect.objectContaining({ name: 'PostMixin', extends: 'A' }),
+      );
+    });
+
+    it('extracts class field properties as children of class expression', () => {
+      const symbols = parseJS(
+        `function mixin() { return class PostMixin extends A { w = 1; eee = this; }; }`,
+      );
+      const pm = symbols.definitions.find((d) => d.name === 'PostMixin');
+      expect(pm).toBeDefined();
+      expect(pm!.children).toContainEqual(expect.objectContaining({ name: 'w', kind: 'property' }));
+      expect(pm!.children).toContainEqual(
+        expect.objectContaining({ name: 'eee', kind: 'property' }),
+      );
+    });
+  });
+
+  describe('array destructuring constant extraction (#1471)', () => {
+    it('extracts const array pattern as a single constant node', () => {
+      const symbols = parseJS(`const [x, y] = new Set([() => {}, () => {}]);`);
+      expect(symbols.definitions).toContainEqual(
+        expect.objectContaining({ name: '[x, y]', kind: 'constant' }),
+      );
+    });
+
+    it('does not extract let or var array destructuring', () => {
+      const symbols = parseJS(`let [a, b] = [1, 2];`);
+      expect(symbols.definitions.every((d) => d.name !== '[a, b]')).toBe(true);
+    });
+  });
+
+  describe('prototype method parameter extraction (#1471)', () => {
+    it('extracts parameters from Foo.prototype.bar = (x, y) => arrow', () => {
+      const symbols = parseJS(`function Arit() {}\nArit.prototype.sum = (x, y) => x + y;`);
+      const def = symbols.definitions.find((d) => d.name === 'Arit.sum');
+      expect(def).toBeDefined();
+      expect(def!.children).toContainEqual(
+        expect.objectContaining({ name: 'x', kind: 'parameter' }),
+      );
+      expect(def!.children).toContainEqual(
+        expect.objectContaining({ name: 'y', kind: 'parameter' }),
+      );
+    });
+
+    it('extracts parameters from Foo.prototype.bar = function(key, value)', () => {
+      const symbols = parseJS(
+        `function Foo() {}\nFoo.prototype.add = function(key, value) { this[key] = value; };`,
+      );
+      const def = symbols.definitions.find((d) => d.name === 'Foo.add');
+      expect(def).toBeDefined();
+      expect(def!.children).toContainEqual(
+        expect.objectContaining({ name: 'key', kind: 'parameter' }),
+      );
+      expect(def!.children).toContainEqual(
+        expect.objectContaining({ name: 'value', kind: 'parameter' }),
+      );
+    });
+  });
 });