@optave/codegraph 3.11.2 → 3.13.0

package/src/extractors/elixir.ts

@@ -122,9 +122,9 @@ function collectModuleMembers(
 ): void {
   for (let i = 0; i < doBlock.childCount; i++) {
     const child = doBlock.child(i);
-    if (!child || child.type !== 'call') continue;
+    if (child?.type !== 'call') continue;
     const target = child.childForFieldName('target');
-    if (!target || target.type !== 'identifier') continue;
+    if (target?.type !== 'identifier') continue;
 
     if (target.text === 'def' || target.text === 'defp') {
       const fnName = extractFunctionName(child);
@@ -184,7 +184,7 @@ function extractElixirParams(defCallNode: TreeSitterNode): SubDeclaration[] {
 
   for (let i = 0; i < args.childCount; i++) {
     const child = args.child(i);
-    if (!child || child.type !== 'call') continue;
+    if (child?.type !== 'call') continue;
     const innerArgs = findChild(child, 'arguments');
     if (!innerArgs) continue;
     for (let j = 0; j < innerArgs.childCount; j++) {
@@ -277,13 +277,13 @@ function pushElixirMapValues(node: TreeSitterNode, stack: TreeSitterNode[]): voi
   const parts: TreeSitterNode[] = [];
   for (let i = 0; i < node.childCount; i++) {
     const content = node.child(i);
-    if (!content || content.type !== 'map_content') continue;
+    if (content?.type !== 'map_content') continue;
     for (let j = 0; j < content.childCount; j++) {
       const kws = content.child(j);
-      if (!kws || kws.type !== 'keywords') continue;
+      if (kws?.type !== 'keywords') continue;
       for (let k = 0; k < kws.childCount; k++) {
         const pair = kws.child(k);
-        if (!pair || pair.type !== 'pair') continue;
+        if (pair?.type !== 'pair') continue;
         for (let p = 0; p < pair.childCount; p++) {
           const part = pair.child(p);
           if (!part || part.type === 'keyword') continue;

package/src/extractors/fsharp.ts

@@ -303,7 +303,7 @@ function handleValueDefinition(
   currentModule: string | null,
 ): void {
   const first = node.child(0);
-  if (!first || first.type !== 'val') return;
+  if (first?.type !== 'val') return;
 
   const declLeft = findChild(node, 'value_declaration_left');
   if (!declLeft) return;

package/src/extractors/go.ts

@@ -111,7 +111,7 @@ function extractGoReceiverType(receiver: TreeSitterNode): string | null {
 function handleGoTypeDecl(node: TreeSitterNode, ctx: ExtractorOutput): void {
   for (let i = 0; i < node.childCount; i++) {
     const spec = node.child(i);
-    if (!spec || spec.type !== 'type_spec') continue;
+    if (spec?.type !== 'type_spec') continue;
     const nameNode = spec.childForFieldName('name');
     const typeNode = spec.childForFieldName('type');
     if (!nameNode || !typeNode) continue;
@@ -213,7 +213,7 @@ function extractGoImportSpec(spec: TreeSitterNode, ctx: ExtractorOutput): void {
 function handleGoConstDecl(node: TreeSitterNode, ctx: ExtractorOutput): void {
   for (let i = 0; i < node.childCount; i++) {
     const spec = node.child(i);
-    if (!spec || spec.type !== 'const_spec') continue;
+    if (spec?.type !== 'const_spec') continue;
     const constName = spec.childForFieldName('name');
     if (constName) {
       ctx.definitions.push({
@@ -288,7 +288,7 @@ function inferAddressOfComposite(
 ): boolean {
   if (rhs.type !== 'unary_expression') return false;
   const operand = rhs.childForFieldName('operand');
-  if (!operand || operand.type !== 'composite_literal') return false;
+  if (operand?.type !== 'composite_literal') return false;
   const typeNode = operand.childForFieldName('type');
   if (!typeNode) return false;
   const typeName = extractGoTypeName(typeNode);
@@ -409,7 +409,7 @@ function extractGoParameters(paramListNode: TreeSitterNode | null): SubDeclarati
   if (!paramListNode) return params;
   for (let i = 0; i < paramListNode.childCount; i++) {
     const param = paramListNode.child(i);
-    if (!param || param.type !== 'parameter_declaration') continue;
+    if (param?.type !== 'parameter_declaration') continue;
     // A parameter_declaration may have multiple identifiers (e.g., `a, b int`)
     for (let j = 0; j < param.childCount; j++) {
       const child = param.child(j);
@@ -494,7 +494,7 @@ function extractStructFields(structTypeNode: TreeSitterNode): SubDeclaration[] {
   if (!fieldList) return fields;
   for (let i = 0; i < fieldList.childCount; i++) {
     const field = fieldList.child(i);
-    if (!field || field.type !== 'field_declaration') continue;
+    if (field?.type !== 'field_declaration') continue;
     const nameNode = field.childForFieldName('name');
     if (nameNode) {
       fields.push({ name: nameNode.text, kind: 'property', line: field.startPosition.row + 1 });

package/src/extractors/haskell.ts

@@ -123,7 +123,7 @@ function collectHaskellPatternBindings(node: TreeSitterNode, out: SubDeclaration
     case 'record':
       for (let i = 0; i < node.childCount; i++) {
         const fp = node.child(i);
-        if (!fp || fp.type !== 'field_pattern') continue;
+        if (fp?.type !== 'field_pattern') continue;
         for (let j = 0; j < fp.childCount; j++) {
           const g = fp.child(j);
           if (g && g.type !== 'field_name') collectHaskellPatternBindings(g, out);

package/src/extractors/helpers.ts

@@ -305,6 +305,49 @@ export function pushImport(
   ctx.imports.push(entry);
 }
 
+// ── C-family primitive types ───────────────────────────────────────────────
+
+/**
+ * Primitive C/C++/CUDA types that are never class/struct receivers. Seeding
+ * these into typeMap would produce spurious receiver edges (e.g. `int x` → `int`).
+ * Shared between the C++ and CUDA extractors to prevent divergence.
+ */
+export const C_PRIMITIVE_TYPES: ReadonlySet<string> = new Set([
+  'int',
+  'long',
+  'short',
+  'unsigned',
+  'signed',
+  'float',
+  'double',
+  'char',
+  'bool',
+  'void',
+  'wchar_t',
+  'auto',
+  'size_t',
+  'uint8_t',
+  'uint16_t',
+  'uint32_t',
+  'uint64_t',
+  'int8_t',
+  'int16_t',
+  'int32_t',
+  'int64_t',
+  'ptrdiff_t',
+  'intptr_t',
+  'uintptr_t',
+]);
+
+/**
+ * Return true when `typeName` is a primitive C/C++/CUDA type.
+ * Strips leading qualifiers (`const int` → `int`) before checking.
+ */
+export function isCPrimitiveType(typeName: string): boolean {
+  const base = typeName.split(/\s+/).pop() ?? typeName;
+  return C_PRIMITIVE_TYPES.has(base) || C_PRIMITIVE_TYPES.has(typeName);
+}
+
 // ── Parameter extraction ───────────────────────────────────────────────────
 
 /**

package/src/extractors/java.ts

@@ -16,6 +16,7 @@ import {
   nodeStartLine,
   pushCall,
   pushImport,
+  setTypeMapEntry,
 } from './helpers.js';
 
 /**
@@ -273,13 +274,13 @@ function handleJavaLocalVarDecl(node: TreeSitterNode, ctx: ExtractorOutput): voi
     const child = node.child(i);
     if (child?.type === 'variable_declarator') {
       const nameNode = child.childForFieldName('name');
-      // Use direct Map.set (last-wins) for local variable declarations.
-      // Local variable types are method-scoped and should override any
-      // prior entry (e.g. a same-named constructor parameter). Using
-      // setTypeMapEntry (first-wins on tie) would let a constructor
-      // parameter type block a local variable's more-specific concrete type.
-      if (nameNode && ctx.typeMap)
-        ctx.typeMap.set(nameNode.text, { type: typeName, confidence: 0.9 });
+      // Use setTypeMapEntry (first-wins on tie) to match Rust extractor semantics.
+      // The typeMap is flat per-file without method scoping, so a local variable
+      // in one method (e.g. `InMemoryUserRepository repo` in `createDefault()`) must
+      // not override a parameter binding set by an earlier method
+      // (e.g. `UserRepository repo` constructor param). First-wins preserves the
+      // interface/abstract type annotation that drives correct CHA dispatch.
+      if (nameNode && ctx.typeMap) setTypeMapEntry(ctx.typeMap, nameNode.text, typeName, 0.9);
     }
   }
 }
@@ -330,7 +331,7 @@ function extractClassFields(classNode: TreeSitterNode): SubDeclaration[] {
   if (!body) return fields;
   for (let i = 0; i < body.childCount; i++) {
     const member = body.child(i);
-    if (!member || member.type !== 'field_declaration') continue;
+    if (member?.type !== 'field_declaration') continue;
     extractFieldDeclarators(member, fields);
   }
   return fields;
@@ -341,7 +342,7 @@ function extractFieldDeclarators(member: TreeSitterNode, fields: SubDeclaration[
   const vis = extractModifierVisibility(member);
   for (let j = 0; j < member.childCount; j++) {
     const child = member.child(j);
-    if (!child || child.type !== 'variable_declarator') continue;
+    if (child?.type !== 'variable_declarator') continue;
     const nameNode = child.childForFieldName('name');
     if (nameNode) {
       fields.push({