fix(rust): require a same-file struct definition for the unit-struct heuristic

The `^[A-Z]` guard on a bare-identifier let-value (`let x = TypeName;`)
matched unit enum variants too — `None`/`Ok` (Option/Result, always in
scope) and any custom fieldless variant brought in via `use Enum::Variant`
parse identically to a unit-struct reference. `x` was typed as `None`
rather than recognized as untyped, since nothing distinguished the two
shapes. Now requires a matching `kind === 'struct'` definition in the same
file before seeding the typeMap entry — mirrored in both the WASM
(rust.ts) and native (rust_lang.rs) extractors, with a regression test in
each mirroring the existing seeds_unit_struct_value_type_map coverage.

Impact: 2 functions changed, 3 affected

Author: carlos-alm

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

@@ -397,6 +397,11 @@ fn extract_scoped_use_list(node: &Node, source: &[u8]) -> Vec<(String, Vec<Strin
     vec![(prefix, names)]
 }
 
+/// True if `name` matches a struct defined in this file (match_rust_node runs before this).
+fn is_known_unit_struct(name: &str, symbols: &FileSymbols) -> bool {
+    symbols.definitions.iter().any(|d| d.kind == "struct" && d.name == name)
+}
+
 fn extract_rust_type_name<'a>(type_node: &Node<'a>, source: &'a [u8]) -> Option<&'a str> {
     match type_node.kind() {
         "type_identifier" | "identifier" | "scoped_type_identifier" => Some(node_text(type_node, source)),
@@ -432,9 +437,17 @@ fn match_rust_type_map(node: &Node, source: &[u8], symbols: &mut FileSymbols, _d
                         // let x = TypeName;  — a bare capitalized identifier value binds
                         // a unit-struct instance (e.g. `let v = NameValidator;` for
                         // `struct NameValidator;`), not a reference to another variable (#1876).
+                        // Requiring a same-file `struct` definition excludes unit enum variants
+                        // like `None`/`Ok` (Option/Result, always in scope) and any custom
+                        // fieldless variant brought into scope via `use Enum::Variant` — those
+                        // also parse as a bare capitalized identifier but are values, not types
+                        // (Greptile review). A struct defined elsewhere in the crate is missed,
+                        // same as every other same-file-only heuristic in this extractor.
                         if value_node.kind() == "identifier" {
                             let type_name = node_text(&value_node, source);
-                            if type_name.starts_with(|c: char| c.is_uppercase()) {
+                            if type_name.starts_with(|c: char| c.is_uppercase())
+                                && is_known_unit_struct(type_name, symbols)
+                            {
                                 symbols.type_map.push(TypeMapEntry {
                                     name: node_text(&pattern, source).to_string(),
                                     type_name: type_name.to_string(),
@@ -649,6 +662,15 @@ mod tests {
         assert_eq!(entry.type_name, "NameValidator");
     }
 
+    #[test]
+    fn does_not_type_unit_enum_variant_as_unit_struct() {
+        // `None` (Option::None) parses identically to a unit-struct reference — a bare
+        // capitalized identifier — but is an enum variant, not a struct. Without a same-file
+        // `struct` definition for the name, it must not be typed (#1876 review).
+        let s = parse_rust("fn f() { let x = None; }");
+        assert!(s.type_map.iter().all(|e| e.name != "x"));
+    }
+
     #[test]
     fn does_not_type_lowercase_bare_identifier_binding() {
         let s = parse_rust("fn f() { let a = 1; let b = a; }");

src/extractors/rust.ts

@@ -295,6 +295,11 @@ function extractRustTypeMap(node: TreeSitterNode, ctx: ExtractorOutput): void {
   extractRustTypeMapDepth(node, ctx, 0);
 }
 
+/** True if `name` matches a struct defined in this file (walkRustNode runs before this). */
+function isKnownUnitStruct(name: string, ctx: ExtractorOutput): boolean {
+  return ctx.definitions.some((d) => d.kind === 'struct' && d.name === name);
+}
+
 function extractRustTypeMapDepth(node: TreeSitterNode, ctx: ExtractorOutput, depth: number): void {
   if (depth >= MAX_WALK_DEPTH) return;
 
@@ -309,8 +314,19 @@ function extractRustTypeMapDepth(node: TreeSitterNode, ctx: ExtractorOutput, dep
       // let x = TypeName;  — a bare capitalized identifier value binds a
       // unit-struct instance (e.g. `let v = NameValidator;` for `struct
       // NameValidator;`), not a reference to another variable (#1876).
+      // Requiring a same-file `struct` definition excludes unit enum variants
+      // like `None`/`Ok` (Option/Result, always in scope) and any custom
+      // fieldless variant brought into scope via `use Enum::Variant` — those
+      // also parse as a bare capitalized identifier but are values, not types
+      // (Greptile review). A struct defined elsewhere in the crate is missed,
+      // same as every other same-file-only heuristic in this extractor.
       const valueNode = node.childForFieldName('value');
-      if (valueNode?.type === 'identifier' && /^[A-Z]/.test(valueNode.text) && ctx.typeMap) {
+      if (
+        valueNode?.type === 'identifier' &&
+        /^[A-Z]/.test(valueNode.text) &&
+        ctx.typeMap &&
+        isKnownUnitStruct(valueNode.text, ctx)
+      ) {
         setTypeMapEntry(ctx.typeMap, pattern.text, valueNode.text, 0.7);
       }
     }

tests/parsers/rust.test.ts

@@ -119,6 +119,14 @@ impl Display for Foo {}`);
     expect(symbols.typeMap?.get('v')).toEqual(expect.objectContaining({ type: 'NameValidator' }));
   });
 
+  it('does not type a unit enum variant as a unit struct (Greptile review)', () => {
+    // `None` (Option::None) parses identically to a unit-struct reference — a bare
+    // capitalized identifier — but is an enum variant, not a struct. Without a
+    // same-file `struct` definition for the name, it must not be typed.
+    const symbols = parseRust(`fn f() { let x = None; }`);
+    expect(symbols.typeMap?.has('x')).toBe(false);
+  });
+
   it('does not type a lowercase bare identifier assignment', () => {
     const symbols = parseRust(`fn f() { let a = 1; let b = a; }`);
     expect(symbols.typeMap?.has('b')).toBe(false);