@optave/codegraph 3.11.0 → 3.11.2

package/src/extractors/r.ts

@@ -1,5 +1,13 @@
 import type { ExtractorOutput, SubDeclaration, TreeSitterNode, TreeSitterTree } from '../types.js';
-import { findChild, nodeEndLine } from './helpers.js';
+import {
+  findChild,
+  findFirstChildOfTypes,
+  nodeEndLine,
+  nodeStartLine,
+  pushCall,
+  pushImport,
+  stripQuotes,
+} from './helpers.js';
 
 /**
  * Extract symbols from R files.
@@ -58,7 +66,7 @@ function handleBinaryOp(node: TreeSitterNode, ctx: ExtractorOutput): void {
     ctx.definitions.push({
       name: lhs.text,
       kind: 'function',
-      line: node.startPosition.row + 1,
+      line: nodeStartLine(node),
       endLine: nodeEndLine(node),
       children: params.length > 0 ? params : undefined,
     });
@@ -68,7 +76,7 @@ function handleBinaryOp(node: TreeSitterNode, ctx: ExtractorOutput): void {
       ctx.definitions.push({
         name: lhs.text,
         kind: 'variable',
-        line: node.startPosition.row + 1,
+        line: nodeStartLine(node),
         endLine: nodeEndLine(node),
       });
     }
@@ -87,14 +95,14 @@ function extractRParams(funcDef: TreeSitterNode): SubDeclaration[] {
       // parameter node has name and possibly default value
       const nameNode = child.childForFieldName('name') || findChild(child, 'identifier');
       if (nameNode) {
-        params.push({ name: nameNode.text, kind: 'parameter', line: child.startPosition.row + 1 });
+        params.push({ name: nameNode.text, kind: 'parameter', line: nodeStartLine(child) });
       } else if (child.text && child.text !== ',' && child.text !== '(' && child.text !== ')') {
         // Some grammars have the param as plain text
-        params.push({ name: child.text, kind: 'parameter', line: child.startPosition.row + 1 });
+        params.push({ name: child.text, kind: 'parameter', line: nodeStartLine(child) });
       }
     }
     if (child.type === 'identifier') {
-      params.push({ name: child.text, kind: 'parameter', line: child.startPosition.row + 1 });
+      params.push({ name: child.text, kind: 'parameter', line: nodeStartLine(child) });
     }
   }
   return params;
@@ -137,15 +145,13 @@ function handleCall(node: TreeSitterNode, ctx: ExtractorOutput): void {
 
   // Regular call
   if (funcNode.type === 'identifier') {
-    ctx.calls.push({ name: funcName, line: node.startPosition.row + 1 });
+    pushCall(ctx, node, funcName);
   } else if (funcNode.type === 'namespace_operator') {
     // pkg::func
     const parts = funcName.split('::');
     if (parts.length >= 2) {
-      ctx.calls.push({
-        name: parts[parts.length - 1]!,
+      pushCall(ctx, node, parts[parts.length - 1]!, {
         receiver: parts.slice(0, -1).join('::'),
-        line: node.startPosition.row + 1,
       });
     }
   }
@@ -164,20 +170,12 @@ function handleLibraryCall(node: TreeSitterNode, ctx: ExtractorOutput): void {
         const arg = child.child(j);
         if (!arg) continue;
         if (arg.type === 'identifier') {
-          ctx.imports.push({
-            source: arg.text,
-            names: [arg.text],
-            line: node.startPosition.row + 1,
-          });
+          pushImport(ctx, node, arg.text, [arg.text]);
           return;
         }
         if (arg.type === 'string' || arg.type === 'string_content') {
-          const text = arg.text.replace(/^["']|["']$/g, '');
-          ctx.imports.push({
-            source: text,
-            names: [text],
-            line: node.startPosition.row + 1,
-          });
+          const text = stripQuotes(arg.text);
+          pushImport(ctx, node, text, [text]);
           return;
         }
         // Argument might be wrapped
@@ -202,12 +200,8 @@ function handleLibraryCall(node: TreeSitterNode, ctx: ExtractorOutput): void {
             }
           }
           if (pick) {
-            const text = pick.text.replace(/^["']|["']$/g, '');
-            ctx.imports.push({
-              source: text,
-              names: [text],
-              line: node.startPosition.row + 1,
-            });
+            const text = stripQuotes(pick.text);
+            pushImport(ctx, node, text, [text]);
             return;
           }
         }
@@ -220,11 +214,7 @@ function handleSourceCall(node: TreeSitterNode, ctx: ExtractorOutput): void {
   // source() only accepts string literals — `source(varname)` is not an import.
   const path = firstStringArgument(node);
   if (path === null) return;
-  ctx.imports.push({
-    source: path,
-    names: ['source'],
-    line: node.startPosition.row + 1,
-  });
+  pushImport(ctx, node, path, ['source']);
 }
 
 function handleSetClass(node: TreeSitterNode, ctx: ExtractorOutput): void {
@@ -233,7 +223,7 @@ function handleSetClass(node: TreeSitterNode, ctx: ExtractorOutput): void {
   ctx.definitions.push({
     name,
     kind: 'class',
-    line: node.startPosition.row + 1,
+    line: nodeStartLine(node),
     endLine: nodeEndLine(node),
   });
 }
@@ -244,7 +234,7 @@ function handleSetGeneric(node: TreeSitterNode, ctx: ExtractorOutput): void {
   ctx.definitions.push({
     name,
     kind: 'function',
-    line: node.startPosition.row + 1,
+    line: nodeStartLine(node),
     endLine: nodeEndLine(node),
   });
 }
@@ -258,7 +248,7 @@ function handleSetGeneric(node: TreeSitterNode, ctx: ExtractorOutput): void {
 function handleSetMethod(node: TreeSitterNode, ctx: ExtractorOutput): void {
   const name = firstStringArgument(node);
   if (name === null) return;
-  ctx.calls.push({ name, line: node.startPosition.row + 1 });
+  pushCall(ctx, node, name);
 }
 
 // tree-sitter-r wraps each positional argument in an `argument` node that
@@ -266,28 +256,20 @@ function handleSetMethod(node: TreeSitterNode, ctx: ExtractorOutput): void {
 // must be unwrapped — checking `child.type === 'string'` directly misses it.
 // Mirrors `first_argument_value` in the Rust extractor for parity.
 function firstStringArgument(node: TreeSitterNode): string | null {
-  for (let i = 0; i < node.childCount; i++) {
-    const child = node.child(i);
-    if (!child || child.type !== 'arguments') continue;
-    for (let j = 0; j < child.childCount; j++) {
-      const arg = child.child(j);
-      if (!arg) continue;
-      if (arg.type === 'string') {
-        return stripQuotes(arg.text);
-      }
-      if (arg.type === 'argument') {
-        const valueNode = arg.childForFieldName('value');
-        if (valueNode && valueNode.type === 'string') return stripQuotes(valueNode.text);
-        for (let k = 0; k < arg.childCount; k++) {
-          const inner = arg.child(k);
-          if (inner && inner.type === 'string') return stripQuotes(inner.text);
-        }
-      }
+  const args = findFirstChildOfTypes(node, ['arguments']);
+  if (!args) return null;
+  for (let j = 0; j < args.childCount; j++) {
+    const arg = args.child(j);
+    if (!arg) continue;
+    if (arg.type === 'string') {
+      return stripQuotes(arg.text);
+    }
+    if (arg.type === 'argument') {
+      const valueNode = arg.childForFieldName('value');
+      if (valueNode && valueNode.type === 'string') return stripQuotes(valueNode.text);
+      const innerStr = findFirstChildOfTypes(arg, ['string']);
+      if (innerStr) return stripQuotes(innerStr.text);
     }
   }
   return null;
 }
-
-function stripQuotes(text: string): string {
-  return text.replace(/^["']|["']$/g, '');
-}

package/src/extractors/solidity.ts

@@ -1,15 +1,14 @@
-import type {
-  Call,
-  ExtractorOutput,
-  SubDeclaration,
-  TreeSitterNode,
-  TreeSitterTree,
-} from '../types.js';
+import type { ExtractorOutput, SubDeclaration, TreeSitterNode, TreeSitterTree } from '../types.js';
 import {
   extractModifierVisibility,
+  extractSimpleParameters,
   findChild,
+  findFirstChildOfTypes,
   findParentNode,
   nodeEndLine,
+  nodeStartLine,
+  pushCall,
+  pushImport,
   stripQuotes,
 } from './helpers.js';
 
@@ -103,7 +102,7 @@ function handleContractDecl(
   ctx.definitions.push({
     name,
     kind,
-    line: node.startPosition.row + 1,
+    line: nodeStartLine(node),
     endLine: nodeEndLine(node),
     children: members.length > 0 ? members : undefined,
   });
@@ -125,7 +124,7 @@ function extractContractMembers(body: TreeSitterNode): SubDeclaration[] {
 
 /** Map a single contract body child to a SubDeclaration, or null if not a recognized member. */
 function extractContractMember(child: TreeSitterNode): SubDeclaration | null {
-  const line = child.startPosition.row + 1;
+  const line = nodeStartLine(child);
   switch (child.type) {
     case 'function_definition': {
       const fnName = child.childForFieldName('name');
@@ -172,7 +171,7 @@ function extractInheritance(node: TreeSitterNode, name: string, ctx: ExtractorOu
       const child = inheritance.child(j);
       if (!child) continue;
       if (child.type === 'user_defined_type' || child.type === 'identifier') {
-        ctx.classes.push({ name, extends: child.text, line: node.startPosition.row + 1 });
+        ctx.classes.push({ name, extends: child.text, line: nodeStartLine(node) });
       }
     }
   }
@@ -191,19 +190,16 @@ function handleStructDecl(node: TreeSitterNode, ctx: ExtractorOutput): void {
         members.push({
           name: memberName.text,
           kind: 'property',
-          line: child.startPosition.row + 1,
+          line: nodeStartLine(child),
         });
       }
     }
   }
 
-  const parent = findParentNode(node, SOL_PARENT_TYPES);
-  const fullName = parent ? `${parent}.${nameNode.text}` : nameNode.text;
-
   ctx.definitions.push({
-    name: fullName,
+    name: qualifyWithParent(node, nameNode.text),
     kind: 'struct',
-    line: node.startPosition.row + 1,
+    line: nodeStartLine(node),
     endLine: nodeEndLine(node),
     children: members.length > 0 ? members : undefined,
   });
@@ -217,17 +213,14 @@ function handleEnumDecl(node: TreeSitterNode, ctx: ExtractorOutput): void {
   for (let i = 0; i < node.childCount; i++) {
     const child = node.child(i);
     if (child && child.type === 'enum_value') {
-      members.push({ name: child.text, kind: 'constant', line: child.startPosition.row + 1 });
+      members.push({ name: child.text, kind: 'constant', line: nodeStartLine(child) });
     }
   }
 
-  const parent = findParentNode(node, SOL_PARENT_TYPES);
-  const fullName = parent ? `${parent}.${nameNode.text}` : nameNode.text;
-
   ctx.definitions.push({
-    name: fullName,
+    name: qualifyWithParent(node, nameNode.text),
     kind: 'enum',
-    line: node.startPosition.row + 1,
+    line: nodeStartLine(node),
     endLine: nodeEndLine(node),
     children: members.length > 0 ? members : undefined,
   });
@@ -244,7 +237,7 @@ function handleFunctionDef(node: TreeSitterNode, ctx: ExtractorOutput): void {
   ctx.definitions.push({
     name: fullName,
     kind,
-    line: node.startPosition.row + 1,
+    line: nodeStartLine(node),
     endLine: nodeEndLine(node),
     children: params.length > 0 ? params : undefined,
     visibility: extractSolVisibility(node),
@@ -254,13 +247,10 @@ function handleFunctionDef(node: TreeSitterNode, ctx: ExtractorOutput): void {
 function handleModifierDef(node: TreeSitterNode, ctx: ExtractorOutput): void {
   const nameNode = node.childForFieldName('name');
   if (!nameNode) return;
-  const parent = findParentNode(node, SOL_PARENT_TYPES);
-  const fullName = parent ? `${parent}.${nameNode.text}` : nameNode.text;
-
   ctx.definitions.push({
-    name: fullName,
+    name: qualifyWithParent(node, nameNode.text),
     kind: 'function',
-    line: node.startPosition.row + 1,
+    line: nodeStartLine(node),
     endLine: nodeEndLine(node),
     decorators: ['modifier'],
   });
@@ -269,13 +259,10 @@ function handleModifierDef(node: TreeSitterNode, ctx: ExtractorOutput): void {
 function handleEventDef(node: TreeSitterNode, ctx: ExtractorOutput): void {
   const nameNode = node.childForFieldName('name');
   if (!nameNode) return;
-  const parent = findParentNode(node, SOL_PARENT_TYPES);
-  const fullName = parent ? `${parent}.${nameNode.text}` : nameNode.text;
-
   ctx.definitions.push({
-    name: fullName,
+    name: qualifyWithParent(node, nameNode.text),
     kind: 'type',
-    line: node.startPosition.row + 1,
+    line: nodeStartLine(node),
     endLine: nodeEndLine(node),
     decorators: ['event'],
   });
@@ -284,13 +271,10 @@ function handleEventDef(node: TreeSitterNode, ctx: ExtractorOutput): void {
 function handleErrorDecl(node: TreeSitterNode, ctx: ExtractorOutput): void {
   const nameNode = node.childForFieldName('name');
   if (!nameNode) return;
-  const parent = findParentNode(node, SOL_PARENT_TYPES);
-  const fullName = parent ? `${parent}.${nameNode.text}` : nameNode.text;
-
   ctx.definitions.push({
-    name: fullName,
+    name: qualifyWithParent(node, nameNode.text),
     kind: 'type',
-    line: node.startPosition.row + 1,
+    line: nodeStartLine(node),
     endLine: nodeEndLine(node),
     decorators: ['error'],
   });
@@ -299,18 +283,21 @@ function handleErrorDecl(node: TreeSitterNode, ctx: ExtractorOutput): void {
 function handleStateVarDecl(node: TreeSitterNode, ctx: ExtractorOutput): void {
   const nameNode = node.childForFieldName('name');
   if (!nameNode) return;
-  const parent = findParentNode(node, SOL_PARENT_TYPES);
-  const fullName = parent ? `${parent}.${nameNode.text}` : nameNode.text;
-
   ctx.definitions.push({
-    name: fullName,
+    name: qualifyWithParent(node, nameNode.text),
     kind: 'variable',
-    line: node.startPosition.row + 1,
+    line: nodeStartLine(node),
     endLine: nodeEndLine(node),
     visibility: extractSolVisibility(node),
   });
 }
 
+/** Qualify `name` with the nearest contract/interface/library, if any. */
+function qualifyWithParent(node: TreeSitterNode, name: string): string {
+  const parent = findParentNode(node, SOL_PARENT_TYPES);
+  return parent ? `${parent}.${name}` : name;
+}
+
 function handleImportDirective(node: TreeSitterNode, ctx: ExtractorOutput): void {
   // import "path"; or import { X } from "path"; or import "path" as Alias;
   for (let i = 0; i < node.childCount; i++) {
@@ -328,22 +315,17 @@ function handleImportDirective(node: TreeSitterNode, ctx: ExtractorOutput): void
           if (id) names.push(id.text);
         }
       }
-      ctx.imports.push({
-        source,
-        names: names.length > 0 ? names : ['*'],
-        line: node.startPosition.row + 1,
-      });
+      // Preserve the explicit `['*']` fallback — pushImport's default uses the
+      // source basename, but Solidity's convention here is to mark unqualified
+      // imports as `*`.
+      pushImport(ctx, node, source, names.length > 0 ? names : ['*']);
       return;
     }
     // source_import: handles `import * as X from "path"`
     if (child.type === 'source_import' || child.type === 'import_clause') {
-      const strNode = findChild(child, 'string') || findChild(child, 'string_literal');
+      const strNode = findFirstChildOfTypes(child, ['string', 'string_literal']);
       if (strNode) {
-        ctx.imports.push({
-          source: stripQuotes(strNode.text),
-          names: ['*'],
-          line: node.startPosition.row + 1,
-        });
+        pushImport(ctx, node, stripQuotes(strNode.text), ['*']);
         return;
       }
     }
@@ -354,35 +336,25 @@ function handleCallExpression(node: TreeSitterNode, ctx: ExtractorOutput): void
   const funcNode = node.childForFieldName('function') || node.childForFieldName('callee');
   if (!funcNode) return;
 
-  const call: Call = { name: '', line: node.startPosition.row + 1 };
+  let name = '';
+  let receiver: string | undefined;
   if (funcNode.type === 'member_expression' || funcNode.type === 'member_access') {
     const prop = funcNode.childForFieldName('property') || funcNode.childForFieldName('member');
     const obj = funcNode.childForFieldName('object') || funcNode.childForFieldName('expression');
-    if (prop) call.name = prop.text;
-    if (obj) call.receiver = obj.text;
+    if (prop) name = prop.text;
+    if (obj) receiver = obj.text;
   } else {
-    call.name = funcNode.text;
+    name = funcNode.text;
   }
-  if (call.name) ctx.calls.push(call);
+  if (name) pushCall(ctx, node, name, receiver !== undefined ? { receiver } : {});
 }
 
 // ── Helpers ────────────────────────────────────────────────────────────────
 
 function extractSolParams(funcNode: TreeSitterNode): SubDeclaration[] {
-  const params: SubDeclaration[] = [];
   const paramList =
     funcNode.childForFieldName('parameters') || findChild(funcNode, 'parameter_list');
-  if (!paramList) return params;
-
-  for (let i = 0; i < paramList.childCount; i++) {
-    const param = paramList.child(i);
-    if (!param || param.type !== 'parameter') continue;
-    const nameNode = param.childForFieldName('name');
-    if (nameNode) {
-      params.push({ name: nameNode.text, kind: 'parameter', line: param.startPosition.row + 1 });
-    }
-  }
-  return params;
+  return extractSimpleParameters(paramList, { paramTypes: ['parameter'] });
 }
 
 function extractSolVisibility(

package/src/features/boundaries.ts

@@ -235,30 +235,23 @@ interface EvaluateBoundariesOpts {
   noTests?: boolean;
 }
 
-export function evaluateBoundaries(
-  db: BetterSqlite3Database,
-  boundaryConfig: BoundaryConfig | undefined,
-  opts: EvaluateBoundariesOpts = {},
-): { violations: BoundaryViolation[]; violationCount: number } {
-  if (!boundaryConfig) return { violations: [], violationCount: 0 };
-
-  const { valid, errors } = validateBoundaryConfig(boundaryConfig);
-  if (!valid) {
-    throw new BoundaryError(`Invalid boundary configuration: ${errors.join('; ')}`);
-  }
-
-  const modules = resolveModules(boundaryConfig);
-  if (modules.size === 0) return { violations: [], violationCount: 0 };
-
-  let allRules: BoundaryRule[] = [];
-  if (boundaryConfig.preset) {
-    allRules = generatePresetRules(modules, boundaryConfig.preset);
-  }
+function collectAllRules(
+  boundaryConfig: BoundaryConfig,
+  modules: Map<string, ResolvedModule>,
+): BoundaryRule[] {
+  const rules: BoundaryRule[] = boundaryConfig.preset
+    ? generatePresetRules(modules, boundaryConfig.preset)
+    : [];
   if (boundaryConfig.rules && Array.isArray(boundaryConfig.rules)) {
-    allRules = allRules.concat(boundaryConfig.rules);
+    return rules.concat(boundaryConfig.rules);
   }
-  if (allRules.length === 0) return { violations: [], violationCount: 0 };
+  return rules;
+}
 
+function loadImportEdges(
+  db: BetterSqlite3Database,
+  opts: EvaluateBoundariesOpts,
+): Array<{ source: string; target: string }> {
   let edges: Array<{ source: string; target: string }>;
   try {
     edges = db
@@ -281,38 +274,63 @@ export function evaluateBoundaries(
     const scope = new Set(opts.scopeFiles);
     edges = edges.filter((e) => scope.has(e.source));
   }
+  return edges;
+}
 
-  const violations: BoundaryViolation[] = [];
+function ruleViolated(rule: BoundaryRule, toModule: string): boolean {
+  if (rule.notTo?.includes(toModule)) return true;
+  if (rule.onlyTo && !rule.onlyTo.includes(toModule)) return true;
+  return false;
+}
 
-  for (const edge of edges) {
-    const fromModule = classifyFile(edge.source, modules);
-    const toModule = classifyFile(edge.target, modules);
+function emitEdgeViolations(
+  edge: { source: string; target: string },
+  fromModule: string,
+  toModule: string,
+  allRules: BoundaryRule[],
+  violations: BoundaryViolation[],
+): void {
+  for (const rule of allRules) {
+    if (rule.from !== fromModule) continue;
+    if (!ruleViolated(rule, toModule)) continue;
+    violations.push({
+      rule: 'boundaries',
+      name: `${fromModule} -> ${toModule}`,
+      file: edge.source,
+      targetFile: edge.target,
+      message: rule.message || `${fromModule} must not depend on ${toModule}`,
+      value: 1,
+      threshold: 0,
+    });
+  }
+}
 
-    if (!fromModule || !toModule) continue;
+export function evaluateBoundaries(
+  db: BetterSqlite3Database,
+  boundaryConfig: BoundaryConfig | undefined,
+  opts: EvaluateBoundariesOpts = {},
+): { violations: BoundaryViolation[]; violationCount: number } {
+  if (!boundaryConfig) return { violations: [], violationCount: 0 };
 
-    for (const rule of allRules) {
-      if (rule.from !== fromModule) continue;
+  const { valid, errors } = validateBoundaryConfig(boundaryConfig);
+  if (!valid) {
+    throw new BoundaryError(`Invalid boundary configuration: ${errors.join('; ')}`);
+  }
 
-      let isViolation = false;
+  const modules = resolveModules(boundaryConfig);
+  if (modules.size === 0) return { violations: [], violationCount: 0 };
 
-      if (rule.notTo?.includes(toModule)) {
-        isViolation = true;
-      } else if (rule.onlyTo && !rule.onlyTo.includes(toModule)) {
-        isViolation = true;
-      }
+  const allRules = collectAllRules(boundaryConfig, modules);
+  if (allRules.length === 0) return { violations: [], violationCount: 0 };
 
-      if (isViolation) {
-        violations.push({
-          rule: 'boundaries',
-          name: `${fromModule} -> ${toModule}`,
-          file: edge.source,
-          targetFile: edge.target,
-          message: rule.message || `${fromModule} must not depend on ${toModule}`,
-          value: 1,
-          threshold: 0,
-        });
-      }
-    }
+  const edges = loadImportEdges(db, opts);
+  const violations: BoundaryViolation[] = [];
+
+  for (const edge of edges) {
+    const fromModule = classifyFile(edge.source, modules);
+    const toModule = classifyFile(edge.target, modules);
+    if (!fromModule || !toModule) continue;
+    emitEdgeViolations(edge, fromModule, toModule, allRules, violations);
   }
 
   return { violations, violationCount: violations.length };