fix(resolver): seed all get/set accessors per descriptor and use qualified names for object literal defs (#1351)

Two fixes:

1. findDescriptorAccessors (TS) / find_descriptor_accessors (Rust): changed from
   returning the first accessor to returning all of them. For { get: getter, set: setter },
   both 'getter:this = obj' and 'setter:this = obj' are now seeded so both functions
   can resolve this-dispatch via Phase 8.3f.

2. extractObjectLiteralFunctions (TS) / extract_object_literal_functions (Rust): definitions
   are now emitted under qualified names ('obj.baz' instead of bare 'baz') to avoid
   polluting the global definition index with common property names that could produce
   false-positive edges via the broad exact-name fallback. The typeMap value for
   function/arrow entries is also updated to the qualified name so the resolver calls
   lookup.byName('obj.baz'). Also adds complexity metrics for method_definition nodes
   in the Rust branch (parity with the pair branch which already computed them).

Author: carlos-alm

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

@@ -242,8 +242,8 @@ fn seed_define_property_entries(node: &Node, source: &[u8], symbols: &mut FileSy
                 confidence: 0.85,
             });
         }
-        // Phase 8.3f: { get: getter } or { set: setter } → this inside getter/setter === obj
-        if let Some(accessor) = find_descriptor_accessor(&args[2], source) {
+        // Phase 8.3f: { get: getter } and/or { set: setter } → this inside each accessor === obj
+        for accessor in find_descriptor_accessors(&args[2], source) {
             symbols.type_map.push(TypeMapEntry {
                 name: format!("{}:this", accessor),
                 type_name: obj_name.to_string(),
@@ -357,10 +357,12 @@ fn find_descriptor_value<'a>(node: &Node<'a>, source: &'a [u8]) -> Option<&'a st
     None
 }
 
-/// Phase 8.3f: return the identifier text of a `get` or `set` accessor in a property descriptor.
-/// `{ get: getter }` → Some("getter"); `{ set: setter }` → Some("setter").
-fn find_descriptor_accessor<'a>(node: &Node<'a>, source: &'a [u8]) -> Option<&'a str> {
-    if node.kind() != "object" { return None; }
+/// Phase 8.3f: return the identifier texts of all `get` and `set` accessors in a property
+/// descriptor. `{ get: getter, set: setter }` → ["getter", "setter"].
+/// Returns all accessors so that each one gets a `callerName:this = obj` typeMap entry.
+fn find_descriptor_accessors<'a>(node: &Node<'a>, source: &'a [u8]) -> Vec<&'a str> {
+    if node.kind() != "object" { return Vec::new(); }
+    let mut result = Vec::new();
     for i in 0..node.child_count() {
         let Some(child) = node.child(i) else { continue };
         if child.kind() != "pair" { continue; }
@@ -369,18 +371,23 @@ fn find_descriptor_accessor<'a>(node: &Node<'a>, source: &'a [u8]) -> Option<&'a
         if key_text != "get" && key_text != "set" { continue; }
         let Some(val) = child.child_by_field_name("value") else { continue };
         if val.kind() == "identifier" {
-            return Some(node_text(&val, source));
+            result.push(node_text(&val, source));
         }
     }
-    None
+    result
 }
 
 /// Phase 8.3f: extract function/arrow properties from an object literal as standalone definitions
 /// and seed composite typeMap keys so that `this.method()` inside Object.defineProperty accessors
 /// can resolve them.
 ///
-/// `const obj = { baz: () => {} }` → Definition { name: "baz", kind: "function" }
-///                                  + TypeMapEntry { name: "obj.baz", type_name: "baz" }
+/// Definitions are emitted under qualified names (`obj.baz`) to avoid polluting the global
+/// definition index with common property names like `init`, `run`, or `render`. The typeMap
+/// value for function/arrow properties also uses the qualified name so the resolver calls
+/// `lookup.byName("obj.baz")` rather than `lookup.byName("baz")`.
+///
+/// `const obj = { baz: () => {} }` → Definition { name: "obj.baz", kind: "function" }
+///                                  + TypeMapEntry { name: "obj.baz", type_name: "obj.baz" }
 /// `const obj = { baz }` (shorthand) → TypeMapEntry { name: "obj.baz", type_name: "baz" }
 fn extract_object_literal_functions(
     obj_node: &Node,
@@ -408,10 +415,13 @@ fn extract_object_literal_functions(
                     Some(node_text(&key_n, source).to_string())
                 };
                 let Some(key) = key else { continue };
+                let qualified = format!("{}.{}", var_name, key);
                 match val_n.kind() {
                     "arrow_function" | "function_expression" | "function" => {
+                        // Use qualified name for the definition so it doesn't collide with
+                        // unrelated top-level functions sharing the same property name.
                         symbols.definitions.push(Definition {
-                            name: key.clone(),
+                            name: qualified.clone(),
                             kind: "function".to_string(),
                             line: start_line(&child),
                             end_line: Some(end_line(&val_n)),
@@ -420,16 +430,17 @@ fn extract_object_literal_functions(
                             cfg: build_function_cfg(&val_n, "javascript", source),
                             children: None,
                         });
+                        // Store qualified name as value so resolver looks up the qualified def.
                         symbols.type_map.push(TypeMapEntry {
-                            name: format!("{}.{}", var_name, key),
-                            type_name: key,
+                            name: qualified.clone(),
+                            type_name: qualified,
                             confidence: 0.85,
                         });
                     }
                     "identifier" => {
                         let target = node_text(&val_n, source);
                         symbols.type_map.push(TypeMapEntry {
-                            name: format!("{}.{}", var_name, key),
+                            name: qualified,
                             type_name: target.to_string(),
                             confidence: 0.85,
                         });
@@ -439,14 +450,16 @@ fn extract_object_literal_functions(
             }
             "method_definition" => {
                 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: node_text(&name_n, source).to_string(),
+                    name: qualified,
                     kind: "function".to_string(),
                     line: start_line(&child),
                     end_line: Some(end_line(&child)),
                     decorators: None,
-                    complexity: None,
-                    cfg: 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,
                 });
             }

src/extractors/javascript.ts

@@ -499,7 +499,7 @@ function extractConstDeclarators(declNode: TreeSitterNode, definitions: Definiti
       });
       // Phase 8.3f: extract function/arrow properties from object literals.
       if (valueN.type === 'object') {
-        extractObjectLiteralFunctions(valueN, definitions);
+        extractObjectLiteralFunctions(valueN, nameN.text, definitions);
       }
     }
   }
@@ -841,7 +841,7 @@ function handleVariableDecl(node: TreeSitterNode, ctx: ExtractorOutput): void {
           // Phase 8.3f: extract function/arrow properties from object literals so that
           // this.method() calls inside Object.defineProperty accessors can resolve them.
           if (valueN.type === 'object') {
-            extractObjectLiteralFunctions(valueN, ctx.definitions);
+            extractObjectLiteralFunctions(valueN, nameN.text, ctx.definitions);
           }
         } else if (isConst && nameN.type === 'object_pattern' && !hasFunctionScopeAncestor(node)) {
           // Destructured bindings: const { handleToken, checkPermissions } = initAuth(...)
@@ -866,11 +866,20 @@ function handleVariableDecl(node: TreeSitterNode, ctx: ExtractorOutput): void {
 /**
  * Phase 8.3f: extract function/arrow function properties from an object literal as standalone
  * definitions so that `this.method()` calls inside Object.defineProperty accessor functions can
- * resolve them via the normal same-file definition lookup.
+ * resolve them via the same-file definition lookup.
  *
- * `const obj = { baz: () => {} }` → emits Definition { name: 'baz', kind: 'function' }
+ * Definitions are emitted as qualified names (`obj.baz` rather than bare `baz`) to avoid
+ * polluting the global definition index with common property names like `init`, `run`, or
+ * `render`. The typeMap value stored by the caller also uses the qualified name so the resolver
+ * looks up `lookup.byName('obj.baz')` rather than `lookup.byName('baz')`.
+ *
+ * `const obj = { baz: () => {} }` → emits Definition { name: 'obj.baz', kind: 'function' }
  */
-function extractObjectLiteralFunctions(objNode: TreeSitterNode, definitions: Definition[]): void {
+function extractObjectLiteralFunctions(
+  objNode: TreeSitterNode,
+  varName: string,
+  definitions: Definition[],
+): void {
   for (let i = 0; i < objNode.childCount; i++) {
     const child = objNode.child(i);
     if (!child) continue;
@@ -887,7 +896,7 @@ function extractObjectLiteralFunctions(objNode: TreeSitterNode, definitions: Def
         valueNode.type === 'function'
       ) {
         definitions.push({
-          name: keyName,
+          name: `${varName}.${keyName}`,
           kind: 'function',
           line: nodeStartLine(child),
           endLine: nodeEndLine(valueNode),
@@ -897,7 +906,7 @@ function extractObjectLiteralFunctions(objNode: TreeSitterNode, definitions: Def
       const nameNode = child.childForFieldName('name');
       if (nameNode) {
         definitions.push({
-          name: nameNode.text,
+          name: `${varName}.${nameNode.text}`,
           kind: 'function',
           line: nodeStartLine(child),
           endLine: nodeEndLine(child),
@@ -1637,10 +1646,15 @@ function handleVarDeclaratorTypeMap(
   }
 
   // Phase 8.3f: seed composite pts keys for object literal properties.
-  // `const obj = { baz: () => {} }` → typeMap['obj.baz'] = 'baz'
-  // `const obj = { baz }` (shorthand) → typeMap['obj.baz'] = 'baz'
+  // `const obj = { baz: () => {} }` → typeMap['obj.baz'] = 'obj.baz'
+  // `const obj = { baz }` (shorthand) → typeMap['obj.baz'] = 'baz'  (bare identifier target)
+  // `const obj = { baz: otherFn }` → typeMap['obj.baz'] = 'otherFn'  (identifier alias)
+  //
+  // For function/arrow values, the value is the qualified name ('obj.baz') because
+  // extractObjectLiteralFunctions now registers definitions under that qualified name to avoid
+  // polluting the global index with bare property names like 'init', 'run', or 'render'.
   // Enables accessor this-dispatch: when typeMap['getter:this'] = 'obj',
-  // resolving this.baz() inside getter → typeMap['obj.baz'] → 'baz'.
+  // resolving this.baz() inside getter → typeMap['obj.baz'] → 'obj.baz' → lookup.byName('obj.baz').
   if (valueN.type === 'object') {
     for (let i = 0; i < valueN.childCount; i++) {
       const child = valueN.child(i);
@@ -1654,14 +1668,16 @@ function handleVarDeclaratorTypeMap(
         const keyName =
           keyNode.type === 'string' ? keyNode.text.replace(/^['"]|['"]$/g, '') : keyNode.text;
         if (!keyName) continue;
+        const qualifiedKey = `${nameN.text}.${keyName}`;
         if (
           valNode.type === 'arrow_function' ||
           valNode.type === 'function_expression' ||
           valNode.type === 'function'
         ) {
-          setTypeMapEntry(typeMap, `${nameN.text}.${keyName}`, keyName, 0.85);
+          // Store the qualified name so the resolver finds the qualified definition.
+          setTypeMapEntry(typeMap, qualifiedKey, qualifiedKey, 0.85);
         } else if (valNode.type === 'identifier') {
-          setTypeMapEntry(typeMap, `${nameN.text}.${keyName}`, valNode.text, 0.85);
+          setTypeMapEntry(typeMap, qualifiedKey, valNode.text, 0.85);
         }
       }
     }
@@ -1759,9 +1775,8 @@ function handleDefinePropertyTypeMap(
     if (target) {
       setTypeMapEntry(typeMap, `${arg0.text}.${key}`, target, 0.85);
     }
-    // Phase 8.3f: { get: getter } or { set: setter } → this inside getter/setter is arg0 (obj)
-    const accessor = findDescriptorAccessor(arg2);
-    if (accessor) {
+    // Phase 8.3f: { get: getter } and/or { set: setter } → this inside each accessor is arg0 (obj)
+    for (const accessor of findDescriptorAccessors(arg2)) {
       setTypeMapEntry(typeMap, `${accessor}:this`, arg0.text, 0.85);
     }
   } else {
@@ -1799,19 +1814,23 @@ function findDescriptorValue(desc: TreeSitterNode): string | undefined {
 }
 
 /**
- * Phase 8.3f: return the identifier text of a `get` or `set` accessor in a property descriptor.
- * `{ get: getter }` → 'getter'; `{ set: setter }` → 'setter'.
+ * Phase 8.3f: return the identifier texts of all `get` and `set` accessors in a property
+ * descriptor. `{ get: getter, set: setter }` → ['getter', 'setter'].
+ * Returns all accessors so that each one gets a `callerName:this = obj` typeMap entry.
  */
-function findDescriptorAccessor(desc: TreeSitterNode): string | undefined {
-  if (desc.type !== 'object') return undefined;
+function findDescriptorAccessors(desc: TreeSitterNode): string[] {
+  if (desc.type !== 'object') return [];
+  const result: string[] = [];
   for (let i = 0; i < desc.childCount; i++) {
     const pair = desc.child(i);
     if (pair?.type !== 'pair') continue;
     const key = pair.childForFieldName('key');
     const val = pair.childForFieldName('value');
-    if ((key?.text === 'get' || key?.text === 'set') && val?.type === 'identifier') return val.text;
+    if ((key?.text === 'get' || key?.text === 'set') && val?.type === 'identifier') {
+      result.push(val.text);
+    }
   }
-  return undefined;
+  return result;
 }
 
 /** Seed composite pts keys for each property in a prototype object literal. */