fix(native): emit object-literal shorthand method definitions in two passes to match WASM ordering

For `const o1 = { f() {} }`, both engines produce a bare `f(method)` node
(from the top-level method_definition walker) and a qualified `o1.f(function)`
node (from the object literal scanner). In WASM, the query path inserts the bare
node first; findCaller's equal-span tie-break then correctly attributes call edges
to `f(method)`, matching the expected-edges manifests.

In native, handle_var_decl processes the lexical_declaration and calls
extract_object_literal_functions inline, inserting `o1.f(function)` before the
DFS walk descends into the method_definition child and calls handle_method_def to
insert `f(method)`. This reversed order caused the tie-break to pick the wrong
node, diverging from WASM.

Fix: remove the method_definition definition from extract_object_literal_functions
(keeping only the typeMap entry) and add a new match_js_objlit_qualified_method_defs
second-pass walk that emits the qualified definitions AFTER match_js_node. The bare
node now precedes the qualified node in definitions, matching WASM ordering.

Also adds a regression test asserting that f(method) precedes o1.f(function) in the
definitions vec for object literal shorthand methods.

Closes #1538

Author: carlos-alm

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

@@ -31,6 +31,13 @@ impl SymbolExtractor for JsExtractor {
     fn extract(&self, tree: &Tree, source: &[u8], file_path: &str) -> FileSymbols {
         let mut symbols = FileSymbols::new(file_path.to_string());
         walk_tree(&tree.root_node(), source, &mut symbols, match_js_node);
+        // Emit qualified `obj.method(function)` definitions for object-literal shorthand
+        // methods AFTER match_js_node so that the bare `f(method)` node created by
+        // handle_method_def comes first in definitions — matching WASM ordering where
+        // handleMethodCapture (query path) runs before extractObjectLiteralFunctions
+        // (runCollectorWalk). Equal-span tie-break in findCaller keeps the first entry,
+        // so bare `f(method)` wins for call attribution in both engines.
+        walk_tree(&tree.root_node(), source, &mut symbols, match_js_objlit_qualified_method_defs);
         walk_ast_nodes(&tree.root_node(), source, &mut symbols.ast_nodes);
         walk_tree(&tree.root_node(), source, &mut symbols, match_js_type_map);
         walk_tree(&tree.root_node(), source, &mut symbols, match_js_return_type_map);
@@ -524,24 +531,18 @@ fn extract_object_literal_functions(
                 }
             }
             "method_definition" => {
+                // The definition (`obj.baz(function)`) is emitted by the second-pass
+                // `match_js_objlit_qualified_method_defs` walker (runs after `match_js_node`)
+                // so that `handle_method_def`'s bare `baz(method)` node appears first in
+                // `definitions`. Only seed the typeMap entry here.
                 let Some(name_n) = child.child_by_field_name("name") else { continue };
-                let qualified = format!("{}.{}", var_name, node_text(&name_n, source));
-                let body = child.child_by_field_name("body");
-                symbols.definitions.push(Definition {
-                    name: qualified.clone(),
-                    kind: "function".to_string(),
-                    line: start_line(&child),
-                    end_line: Some(end_line(&child)),
-                    decorators: None,
-                    complexity: body.and_then(|b| compute_all_metrics(&b, source, "javascript")),
-                    cfg: body.and_then(|b| build_function_cfg(&b, "javascript", source)),
-                    children: None,
-                });
-                // Seed typeMap so the two-step accessor dispatch can find the qualified def.
-                // `const obj = { baz() {} }` → typeMap['obj.baz'] = 'obj.baz'
+                let method_name = node_text(&name_n, source);
+                let qualified = format!("{}.{}", var_name, method_name);
+                // typeMap['obj.baz'] = 'baz' — points to the bare-name definition so
+                // the two-step accessor dispatch resolves via the bare node.
                 symbols.type_map.push(TypeMapEntry {
-                    name: qualified.clone(),
-                    type_name: qualified,
+                    name: qualified,
+                    type_name: method_name.to_string(),
                     confidence: 0.85,
                 });
             }
@@ -550,6 +551,62 @@ fn extract_object_literal_functions(
     }
 }
 
+/// Second-pass walker: emit qualified `obj.method(function)` definitions for
+/// `method_definition` children of object literals.
+///
+/// This must run AFTER the main `match_js_node` walk so that the bare `f(method)` node
+/// created by `handle_method_def` appears BEFORE the qualified `obj.f(function)` node
+/// in `symbols.definitions`. `findCaller` picks the narrowest-span enclosing definition;
+/// when spans are equal it keeps the first inserted one (strict `<`), so `f(method)` wins
+/// and call-edge attribution matches WASM (which runs `handleMethodCapture` via the query
+/// path before `extractObjectLiteralFunctions` via `runCollectorWalk`).
+///
+/// WASM produces both nodes — the qualified one via `extractObjectLiteralFunctions` and the
+/// bare one via `handleMethodCapture`. This pass mirrors that by adding only the qualified
+/// definitions, deferred so ordering is correct.
+fn match_js_objlit_qualified_method_defs(
+    node: &Node,
+    source: &[u8],
+    symbols: &mut FileSymbols,
+    _depth: usize,
+) {
+    // Only lexical/variable declarations at non-function scope.
+    if !matches!(node.kind(), "lexical_declaration" | "variable_declaration") { return; }
+    if find_parent_of_types(node, &[
+        "function_declaration", "arrow_function", "function_expression",
+        "method_definition", "generator_function_declaration", "generator_function",
+    ]).is_some() {
+        return;
+    }
+    let is_const = node.child(0).map(|c| node_text(&c, source) == "const").unwrap_or(false);
+    if !is_const { return; }
+    for i in 0..node.child_count() {
+        let Some(declarator) = node.child(i) else { continue };
+        if declarator.kind() != "variable_declarator" { continue; }
+        let Some(name_n) = declarator.child_by_field_name("name") else { continue };
+        let Some(value_n) = declarator.child_by_field_name("value") else { continue };
+        if value_n.kind() != "object" || name_n.kind() != "identifier" { continue; }
+        let var_name = node_text(&name_n, source);
+        for j in 0..value_n.child_count() {
+            let Some(child) = value_n.child(j) else { continue };
+            if child.kind() != "method_definition" { continue; }
+            let Some(meth_name_n) = child.child_by_field_name("name") else { continue };
+            let qualified = format!("{}.{}", var_name, node_text(&meth_name_n, source));
+            let body = child.child_by_field_name("body");
+            symbols.definitions.push(Definition {
+                name: qualified,
+                kind: "function".to_string(),
+                line: start_line(&child),
+                end_line: Some(end_line(&child)),
+                decorators: None,
+                complexity: body.and_then(|b| compute_all_metrics(&b, source, "javascript")),
+                cfg: body.and_then(|b| build_function_cfg(&b, "javascript", source)),
+                children: None,
+            });
+        }
+    }
+}
+
 // ── Return-type map extraction (Phase 8.2 parity) ───────────────────────────
 
 /// Walk the AST collecting function/method return types into `symbols.return_type_map`.
@@ -3966,6 +4023,45 @@ mod tests {
         assert_eq!(e2.unwrap().type_name, "f2");
     }
 
+    /// Object literal shorthand method `{ f() {} }` must produce BOTH a bare `f(method)` node
+    /// (from handle_method_def, main walk) AND a qualified `o1.f(function)` node (from the
+    /// second-pass match_js_objlit_qualified_method_defs), with the bare node appearing FIRST.
+    /// findCaller's equal-span tie-break keeps the first entry, so `f(method)` wins for call
+    /// attribution — matching WASM where handleMethodCapture runs before extractObjectLiteralFunctions.
+    /// Issue #1538.
+    #[test]
+    fn object_literal_shorthand_method_bare_node_precedes_qualified() {
+        let s = parse_js(
+            "const o1 = {\n\
+               f() { this.g(); },\n\
+               g() { return 1; },\n\
+             };",
+        );
+        let names: Vec<_> = s.definitions.iter().map(|d| (&d.name, &d.kind)).collect();
+        let f_bare_pos = s.definitions.iter().position(|d| d.name == "f" && d.kind == "method");
+        let g_bare_pos = s.definitions.iter().position(|d| d.name == "g" && d.kind == "method");
+        let f_qual_pos = s.definitions.iter().position(|d| d.name == "o1.f" && d.kind == "function");
+        let g_qual_pos = s.definitions.iter().position(|d| d.name == "o1.g" && d.kind == "function");
+        assert!(f_bare_pos.is_some(), "bare f(method) missing; got: {:?}", names);
+        assert!(g_bare_pos.is_some(), "bare g(method) missing; got: {:?}", names);
+        assert!(f_qual_pos.is_some(), "qualified o1.f(function) missing; got: {:?}", names);
+        assert!(g_qual_pos.is_some(), "qualified o1.g(function) missing; got: {:?}", names);
+        assert!(
+            f_bare_pos.unwrap() < f_qual_pos.unwrap(),
+            "f(method) at {} must precede o1.f(function) at {} — equal-span tie-break",
+            f_bare_pos.unwrap(), f_qual_pos.unwrap()
+        );
+        assert!(
+            g_bare_pos.unwrap() < g_qual_pos.unwrap(),
+            "g(method) at {} must precede o1.g(function) at {}",
+            g_bare_pos.unwrap(), g_qual_pos.unwrap()
+        );
+        // typeMap entry must point to bare name for two-step accessor dispatch.
+        let tm_f = s.type_map.iter().find(|e| e.name == "o1.f");
+        assert!(tm_f.is_some(), "typeMap o1.f missing");
+        assert_eq!(tm_f.unwrap().type_name, "f");
+    }
+
     /// Phase 8.3e: call receiver is correctly recorded for obj.f() inside defProp body.
     #[test]
     fn call_receiver_for_define_property() {