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

Impact: 2 functions changed, 18 affected

Author: carlos-alm

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

@@ -908,7 +908,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 };

src/extractors/javascript.ts

@@ -876,6 +876,12 @@ function handleStaticBlock(node: TreeSitterNode, definitions: Definition[]): voi
  * `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 =
@@ -885,6 +891,9 @@ function handleFieldDef(node: TreeSitterNode, definitions: Definition[]): void {
   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 parentClass = findParentClass(node);

tests/parsers/javascript.test.ts

@@ -99,12 +99,18 @@ 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('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(); } }`);
     // Each static block gets a unique name with line:column suffix to avoid collisions