fix: class-scope field annotation typeMap keys to prevent cross-class collision

Field type annotations (`private repo: OrderRepository`) were seeded as bare
file-wide typeMap keys, causing `this.repo` inside `UserService` to resolve to
`OrderRepository` when both classes had a `repo` field (issue #1458).

Both extractors (TS `handleFieldDefTypeMap` and Rust `field_definition` branch)
now seed `ClassName.field` keys at confidence 0.9, matching the `CallerClass.X`
resolver fallback added in PR #1382. Bare keys are kept at confidence 0.6 as
fallbacks for single-class files or class expressions where no enclosing class
name is available.

Both engines change identically — parity preserved.

Author: carlos-alm

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

@@ -202,8 +202,13 @@ fn match_js_type_map(node: &Node, source: &[u8], symbols: &mut FileSymbols, _dep
             }
         }
         // TypeScript class field declarations: `private repo: Repository<User>`
-        // Seeds both "repo" and "this.repo" so that `this.repo.method()` calls
-        // can be resolved to the interface/class type via the type map.
+        // Seeds a class-scoped key `ClassName.field` (confidence 0.9) as the primary
+        // entry so that two classes with identically-named fields don't overwrite each
+        // other's typeMap entry (issue #1458). The resolver's `CallerClass.X` fallback
+        // looks up exactly this key.
+        // Bare `field` and `this.field` keys are kept at lower confidence (0.6) as
+        // fallbacks for single-class files where the resolver may lack callerClass context.
+        // Mirrors handleFieldDefTypeMap in src/extractors/javascript.ts.
         "public_field_definition" | "field_definition" => {
             let name_node = node.child_by_field_name("name")
                 .or_else(|| node.child_by_field_name("property"))
@@ -216,9 +221,33 @@ fn match_js_type_map(node: &Node, source: &[u8], symbols: &mut FileSymbols, _dep
                     let field_name = node_text(&name_node, source).to_string();
                     if let Some(type_anno) = find_child(node, "type_annotation") {
                         if let Some(type_name) = extract_simple_type_name(&type_anno, source) {
-                            push_type_map_entry(symbols, field_name.clone(), type_name.to_string());
-                            // "this.fieldName" key resolves `this.repo.method()` calls.
-                            push_type_map_entry(symbols, format!("this.{}", field_name), type_name.to_string());
+                            match enclosing_type_map_class(node, source) {
+                                Some(class_name) => {
+                                    // Primary: class-scoped key prevents cross-class collision.
+                                    push_type_map_entry(
+                                        symbols,
+                                        format!("{}.{}", class_name, field_name),
+                                        type_name.to_string(),
+                                    );
+                                    // Fallback bare keys at lower confidence.
+                                    symbols.type_map.push(TypeMapEntry {
+                                        name: field_name.clone(),
+                                        type_name: type_name.to_string(),
+                                        confidence: 0.6,
+                                    });
+                                    symbols.type_map.push(TypeMapEntry {
+                                        name: format!("this.{}", field_name),
+                                        type_name: type_name.to_string(),
+                                        confidence: 0.6,
+                                    });
+                                }
+                                None => {
+                                    // No enclosing class declaration (e.g. class expression)
+                                    // — use bare keys only at full confidence.
+                                    push_type_map_entry(symbols, field_name.clone(), type_name.to_string());
+                                    push_type_map_entry(symbols, format!("this.{}", field_name), type_name.to_string());
+                                }
+                            }
                         }
                     }
                 }

src/extractors/javascript.ts

@@ -1867,7 +1867,7 @@ function runContextCollectorWalk(rootNode: TreeSitterNode, out: ContextCollector
     } else if (t === 'required_parameter' || t === 'optional_parameter') {
       handleParamTypeMap(node, out.typeMap);
     } else if (t === 'public_field_definition' || t === 'field_definition') {
-      handleFieldDefTypeMap(node, out.typeMap);
+      handleFieldDefTypeMap(node, out.typeMap, typeMapClass);
     } else if (t === 'assignment_expression') {
       handlePropWriteTypeMap(node, out.typeMap, typeMapClass);
     } else if (t === 'call_expression') {
@@ -2094,11 +2094,23 @@ function handleParamTypeMap(node: TreeSitterNode, typeMap: Map<string, TypeMapEn
 
 /**
  * Extract type info from a class field declaration: `private repo: Repository<User>`.
- * Seeds both "repo" and "this.repo" so `this.repo.method()` calls resolve to the
- * declared type via the type map. Mirrors the field_definition branch of
- * match_js_type_map in crates/codegraph-core/src/extractors/javascript.rs.
+ *
+ * Seeds a class-scoped key `ClassName.field` (confidence 0.9) as the primary entry
+ * so that two classes with identically-named fields don't overwrite each other's
+ * typeMap entry (issue #1458). The resolver's `CallerClass.X` fallback (call-resolver.ts
+ * line 110) looks up exactly this key.
+ *
+ * Bare `field` and `this.field` keys are kept at lower confidence (0.6) as fallbacks
+ * for single-class files where the resolver may not have a callerClass context.
+ *
+ * Mirrors the field_definition branch of match_js_type_map in
+ * crates/codegraph-core/src/extractors/javascript.rs.
  */
-function handleFieldDefTypeMap(node: TreeSitterNode, typeMap: Map<string, TypeMapEntry>): void {
+function handleFieldDefTypeMap(
+  node: TreeSitterNode,
+  typeMap: Map<string, TypeMapEntry>,
+  currentClass: string | null,
+): void {
   const nameNode =
     node.childForFieldName('name') ||
     node.childForFieldName('property') ||
@@ -2115,9 +2127,18 @@ function handleFieldDefTypeMap(node: TreeSitterNode, typeMap: Map<string, TypeMa
   if (!typeAnno) return;
   const typeName = extractSimpleTypeName(typeAnno);
   if (!typeName) return;
-  setTypeMapEntry(typeMap, nameNode.text, typeName, 0.9);
-  // "this.fieldName" key resolves `this.repo.method()` calls.
-  setTypeMapEntry(typeMap, `this.${nameNode.text}`, typeName, 0.9);
+  if (currentClass) {
+    // Primary: class-scoped key prevents cross-class collision (issue #1458).
+    setTypeMapEntry(typeMap, `${currentClass}.${nameNode.text}`, typeName, 0.9);
+    // Fallback: bare keys at lower confidence for single-class files or when
+    // the resolver does not have a callerClass in scope.
+    setTypeMapEntry(typeMap, nameNode.text, typeName, 0.6);
+    setTypeMapEntry(typeMap, `this.${nameNode.text}`, typeName, 0.6);
+  } else {
+    // No enclosing class declaration (e.g. class expression) — use bare keys only.
+    setTypeMapEntry(typeMap, nameNode.text, typeName, 0.9);
+    setTypeMapEntry(typeMap, `this.${nameNode.text}`, typeName, 0.9);
+  }
 }
 
 /**

tests/parsers/javascript.test.ts

@@ -217,15 +217,34 @@ describe('JavaScript parser', () => {
       expect(symbols.typeMap.get('res')).toEqual({ type: 'Response', confidence: 0.9 });
     });
 
-    it('extracts class field annotations into typeMap with confidence 0.9', () => {
+    it('extracts class field annotations into class-scoped typeMap key (issue #1458)', () => {
       const symbols = parseTS(`
         class UserService {
           private repo: Repository;
           run() { this.repo.save(); }
         }
       `);
-      expect(symbols.typeMap.get('repo')).toEqual({ type: 'Repository', confidence: 0.9 });
-      expect(symbols.typeMap.get('this.repo')).toEqual({ type: 'Repository', confidence: 0.9 });
+      // Primary: class-scoped key at 0.9 — prevents cross-class collision.
+      expect(symbols.typeMap.get('UserService.repo')).toEqual({ type: 'Repository', confidence: 0.9 });
+      // Fallback bare keys at lower confidence for single-class files.
+      expect(symbols.typeMap.get('repo')).toEqual({ type: 'Repository', confidence: 0.6 });
+      expect(symbols.typeMap.get('this.repo')).toEqual({ type: 'Repository', confidence: 0.6 });
+    });
+
+    it('prevents cross-class collision for same-named fields (issue #1458)', () => {
+      const symbols = parseTS(`
+        class OrderService {
+          private repo: OrderRepository;
+        }
+        class UserService {
+          private repo: UserRepository;
+        }
+      `);
+      // Each class gets its own scoped key — no collision.
+      expect(symbols.typeMap.get('OrderService.repo')).toEqual({ type: 'OrderRepository', confidence: 0.9 });
+      expect(symbols.typeMap.get('UserService.repo')).toEqual({ type: 'UserRepository', confidence: 0.9 });
+      // Bare "repo" key should hold the first class's type at 0.6 (second write is same confidence, no overwrite).
+      expect(symbols.typeMap.get('repo')?.confidence).toBe(0.6);
     });
 
     it('returns empty typeMap when no annotations', () => {