@grafema/core 0.2.5-beta → 0.2.7

package/src/plugins/analysis/ast/handlers/CallExpressionHandler.ts

@@ -0,0 +1,347 @@
+/** CallExpressionHandler — handles CallExpression nodes. (REG-422, lines ~4348-4677) */
+import type { Visitor, NodePath } from '@babel/traverse';
+import * as t from '@babel/types';
+import { getLine, getColumn } from '../utils/location.js';
+import { ExpressionEvaluator } from '../ExpressionEvaluator.js';
+import type { CallArgumentInfo } from '../types.js';
+import { FunctionBodyHandler } from './FunctionBodyHandler.js';
+
+export class CallExpressionHandler extends FunctionBodyHandler {
+  getHandlers(): Visitor {
+    const ctx = this.ctx;
+    const analyzer = this.analyzer;
+
+    return {
+      // Function call expressions
+      CallExpression: (callPath: NodePath<t.CallExpression>) => {
+        // REG-311: Detect isAwaited (parent is AwaitExpression)
+        const parent = callPath.parentPath;
+        const isAwaited = parent?.isAwaitExpression() ?? false;
+
+        // REG-311: Detect isInsideTry (O(1) via depth counter)
+        const isInsideTry = ctx.controlFlowState.tryBlockDepth > 0;
+
+        // REG-298: Detect isInsideLoop (O(1) via depth counter)
+        const isInsideLoop = ctx.controlFlowState.loopDepth > 0;
+
+        analyzer.handleCallExpression(
+          callPath.node,
+          ctx.processedCallSites,
+          ctx.processedMethodCalls,
+          ctx.callSites,
+          ctx.methodCalls,
+          ctx.module,
+          ctx.callSiteCounterRef,
+          ctx.scopeTracker,
+          ctx.getCurrentScopeId(),
+          ctx.collections,
+          isAwaited,
+          isInsideTry,
+          isInsideLoop
+        );
+
+        // REG-401: Detect parameter invocation for user-defined HOF tracking
+        // If callee is an Identifier matching a parameter name or alias (REG-416),
+        // record the param index.
+        // REG-417: Also detect rest param array access: fns[0]() via MemberExpression callee.
+        // Nested functions are already skipped by FunctionDeclaration/FunctionExpression/ArrowFunction
+        // handlers calling path.skip(), so shadowed names won't be falsely matched.
+        const callNodeForParam = callPath.node;
+        if (ctx.paramNameToIndex.size > 0 || ctx.aliasToParamIndex.size > 0) {
+          if (t.isIdentifier(callNodeForParam.callee)) {
+            const calleeName = callNodeForParam.callee.name;
+            const paramIndex = ctx.paramNameToIndex.get(calleeName) ?? ctx.aliasToParamIndex.get(calleeName);
+            if (paramIndex !== undefined) {
+              ctx.invokedParamIndexes.add(paramIndex);
+              // REG-417: Record property path for destructured param bindings
+              const propertyPath = ctx.paramNameToPropertyPath.get(calleeName);
+              if (propertyPath) {
+                ctx.invokesParamBindings.push({ paramIndex, propertyPath });
+              }
+            }
+          } else if (
+            t.isMemberExpression(callNodeForParam.callee) &&
+            t.isIdentifier(callNodeForParam.callee.object) &&
+            ctx.restParamNames.has(callNodeForParam.callee.object.name)
+          ) {
+            // REG-417: Rest param invoked via array access, e.g. fns[0]()
+            const paramIndex = ctx.paramNameToIndex.get(callNodeForParam.callee.object.name);
+            if (paramIndex !== undefined) {
+              ctx.invokedParamIndexes.add(paramIndex);
+            }
+          }
+        }
+
+        // REG-334: Check for resolve/reject calls inside Promise executors
+        const callNode = callPath.node;
+        if (t.isIdentifier(callNode.callee)) {
+          const calleeName = callNode.callee.name;
+
+          // Walk up function parents to find Promise executor context
+          // This handles nested callbacks like: new Promise((resolve) => { db.query((err, data) => { resolve(data); }); });
+          let funcParent = callPath.getFunctionParent();
+          while (funcParent) {
+            const funcNode = funcParent.node;
+            const funcKey = `${funcNode.start}:${funcNode.end}`;
+            const context = ctx.promiseExecutorContexts.get(funcKey);
+
+            if (context) {
+              const isResolve = calleeName === context.resolveName;
+              const isReject = calleeName === context.rejectName;
+
+              if (isResolve || isReject) {
+                // Find the CALL node ID for this resolve/reject call
+                // It was just added by handleCallExpression
+                const callLine = getLine(callNode);
+                const callColumn = getColumn(callNode);
+
+                // Find matching call site that was just added
+                const resolveCall = ctx.callSites.find(cs =>
+                  cs.name === calleeName &&
+                  cs.file === ctx.module.file &&
+                  cs.line === callLine &&
+                  cs.column === callColumn
+                );
+
+                if (resolveCall) {
+                  ctx.promiseResolutions.push({
+                    callId: resolveCall.id,
+                    constructorCallId: context.constructorCallId,
+                    isReject,
+                    file: ctx.module.file,
+                    line: callLine
+                  });
+
+                  // REG-334: Collect arguments for resolve/reject calls
+                  // This enables traceValues to follow PASSES_ARGUMENT edges
+                  if (!ctx.collections.callArguments) {
+                    ctx.collections.callArguments = [];
+                  }
+                  const callArgumentsArr = ctx.collections.callArguments as CallArgumentInfo[];
+
+                  // Process arguments (typically just one: resolve(value))
+                  callNode.arguments.forEach((arg, argIndex) => {
+                    const argInfo: CallArgumentInfo = {
+                      callId: resolveCall.id,
+                      argIndex,
+                      file: ctx.module.file,
+                      line: getLine(arg),
+                      column: getColumn(arg)
+                    };
+
+                    // Handle different argument types
+                    if (t.isIdentifier(arg)) {
+                      argInfo.targetType = 'VARIABLE';
+                      argInfo.targetName = arg.name;
+                    } else if (t.isLiteral(arg) && !t.isTemplateLiteral(arg)) {
+                      // Create LITERAL node for the argument value
+                      const literalValue = ExpressionEvaluator.extractLiteralValue(arg as t.Literal);
+                      if (literalValue !== null) {
+                        const argLine = getLine(arg);
+                        const argColumn = getColumn(arg);
+                        const literalId = `LITERAL#arg${argIndex}#${ctx.module.file}#${argLine}:${argColumn}:${ctx.literalCounterRef.value++}`;
+                        ctx.literals.push({
+                          id: literalId,
+                          type: 'LITERAL',
+                          value: literalValue,
+                          valueType: typeof literalValue,
+                          file: ctx.module.file,
+                          line: argLine,
+                          column: argColumn,
+                          parentCallId: resolveCall.id,
+                          argIndex
+                        });
+                        argInfo.targetType = 'LITERAL';
+                        argInfo.targetId = literalId;
+                        argInfo.literalValue = literalValue;
+                      }
+                    } else if (t.isCallExpression(arg)) {
+                      argInfo.targetType = 'CALL';
+                      argInfo.nestedCallLine = getLine(arg);
+                      argInfo.nestedCallColumn = getColumn(arg);
+                    } else {
+                      argInfo.targetType = 'EXPRESSION';
+                      argInfo.expressionType = arg.type;
+                    }
+
+                    callArgumentsArr.push(argInfo);
+                  });
+                }
+
+                break; // Found context, stop searching
+              }
+            }
+
+            funcParent = funcParent.getFunctionParent();
+          }
+
+          // REG-311: Detect executor_reject pattern - reject(new Error()) inside Promise executor
+          // Walk up to find Promise executor context and check if this is reject call with NewExpression arg
+          funcParent = callPath.getFunctionParent();
+          while (funcParent && ctx.currentFunctionId) {
+            const funcNode = funcParent.node;
+            const funcKey = `${funcNode.start}:${funcNode.end}`;
+            const context = ctx.promiseExecutorContexts.get(funcKey);
+
+            if (context && calleeName === context.rejectName && callNode.arguments.length > 0) {
+              // REG-311: Use the creator function's ID (the function that created the Promise),
+              // not the executor's ID
+              const targetFunctionId = context.creatorFunctionId || ctx.currentFunctionId;
+              const arg = callNode.arguments[0];
+              const callLine = getLine(callNode);
+              const callColumn = getColumn(callNode);
+
+              // Case 1: reject(new Error())
+              if (t.isNewExpression(arg) && t.isIdentifier(arg.callee)) {
+                ctx.rejectionPatterns.push({
+                  functionId: targetFunctionId,
+                  errorClassName: arg.callee.name,
+                  rejectionType: 'executor_reject',
+                  isAsync: true,
+                  file: ctx.module.file,
+                  line: callLine,
+                  column: callColumn
+                });
+              }
+              // Case 2: reject(err) where err is variable
+              else if (t.isIdentifier(arg)) {
+                const varName = arg.name;
+                // Check if it's a parameter of ANY containing function (executor, outer, etc.)
+                // Walk up the function chain to find if varName is a parameter
+                let isParameter = false;
+                let checkParent: NodePath<t.Node> | null = funcParent;
+                while (checkParent) {
+                  if (t.isFunction(checkParent.node)) {
+                    if (checkParent.node.params.some(p =>
+                      t.isIdentifier(p) && p.name === varName
+                    )) {
+                      isParameter = true;
+                      break;
+                    }
+                  }
+                  checkParent = checkParent.getFunctionParent();
+                }
+
+                if (isParameter) {
+                  ctx.rejectionPatterns.push({
+                    functionId: targetFunctionId,
+                    errorClassName: null,
+                    rejectionType: 'variable_parameter',
+                    isAsync: true,
+                    file: ctx.module.file,
+                    line: callLine,
+                    column: callColumn,
+                    sourceVariableName: varName
+                  });
+                } else {
+                  // Try micro-trace
+                  const { errorClassName, tracePath } = analyzer.microTraceToErrorClass(
+                    varName,
+                    funcParent as NodePath<t.Function>,
+                    ctx.variableDeclarations
+                  );
+
+                  ctx.rejectionPatterns.push({
+                    functionId: targetFunctionId,
+                    errorClassName,
+                    rejectionType: errorClassName ? 'variable_traced' : 'variable_unknown',
+                    isAsync: true,
+                    file: ctx.module.file,
+                    line: callLine,
+                    column: callColumn,
+                    sourceVariableName: varName,
+                    tracePath
+                  });
+                }
+              }
+              break;
+            }
+            funcParent = funcParent.getFunctionParent();
+          }
+        }
+
+        // REG-311: Detect Promise.reject(new Error()) pattern
+        if (t.isMemberExpression(callNode.callee) && ctx.currentFunctionId) {
+          const memberCallee = callNode.callee;
+          if (t.isIdentifier(memberCallee.object) &&
+              memberCallee.object.name === 'Promise' &&
+              t.isIdentifier(memberCallee.property) &&
+              memberCallee.property.name === 'reject' &&
+              callNode.arguments.length > 0) {
+            const arg = callNode.arguments[0];
+            const callLine = getLine(callNode);
+            const callColumn = getColumn(callNode);
+
+            // Case 1: Promise.reject(new Error())
+            if (t.isNewExpression(arg) && t.isIdentifier(arg.callee)) {
+              ctx.rejectionPatterns.push({
+                functionId: ctx.currentFunctionId,
+                errorClassName: arg.callee.name,
+                rejectionType: 'promise_reject',
+                isAsync: true,
+                file: ctx.module.file,
+                line: callLine,
+                column: callColumn
+              });
+            }
+            // Case 2: Promise.reject(err) where err is variable
+            else if (t.isIdentifier(arg)) {
+              const varName = arg.name;
+              // Check if it's a parameter of containing function
+              const isParameter = ctx.functionNode
+                ? ctx.functionNode.params.some(param => t.isIdentifier(param) && param.name === varName)
+                : false;
+
+              if (isParameter) {
+                ctx.rejectionPatterns.push({
+                  functionId: ctx.currentFunctionId,
+                  errorClassName: null,
+                  rejectionType: 'variable_parameter',
+                  isAsync: true,
+                  file: ctx.module.file,
+                  line: callLine,
+                  column: callColumn,
+                  sourceVariableName: varName
+                });
+              } else {
+                // Try micro-trace
+                if (!ctx.functionPath) {
+                  ctx.rejectionPatterns.push({
+                    functionId: ctx.currentFunctionId,
+                    errorClassName: null,
+                    rejectionType: 'variable_unknown',
+                    isAsync: true,
+                    file: ctx.module.file,
+                    line: callLine,
+                    column: callColumn,
+                    sourceVariableName: varName,
+                    tracePath: [varName]
+                  });
+                  return;
+                }
+
+                const { errorClassName, tracePath } = analyzer.microTraceToErrorClass(
+                  varName,
+                  ctx.functionPath,
+                  ctx.variableDeclarations
+                );
+
+                ctx.rejectionPatterns.push({
+                  functionId: ctx.currentFunctionId,
+                  errorClassName,
+                  rejectionType: errorClassName ? 'variable_traced' : 'variable_unknown',
+                  isAsync: true,
+                  file: ctx.module.file,
+                  line: callLine,
+                  column: callColumn,
+                  sourceVariableName: varName,
+                  tracePath
+                });
+              }
+            }
+          }
+        }
+      },
+    };
+  }
+}

package/src/plugins/analysis/ast/handlers/FunctionBodyHandler.ts

@@ -0,0 +1,24 @@
+/**
+ * FunctionBodyHandler — abstract base class for all extracted
+ * analyzeFunctionBody() visitor handlers.
+ *
+ * Each subclass implements getHandlers() returning a Babel Visitor
+ * fragment that covers a specific AST node type (e.g., VariableDeclaration,
+ * ReturnStatement, CallExpression).
+ *
+ * Handlers receive:
+ * - ctx: FunctionBodyContext with all local state for the traversal
+ * - analyzer: AnalyzerDelegate to call methods still on JSASTAnalyzer
+ */
+import type { Visitor } from '@babel/traverse';
+import type { FunctionBodyContext } from '../FunctionBodyContext.js';
+import type { AnalyzerDelegate } from './AnalyzerDelegate.js';
+
+export abstract class FunctionBodyHandler {
+  constructor(
+    protected readonly ctx: FunctionBodyContext,
+    protected readonly analyzer: AnalyzerDelegate,
+  ) {}
+
+  abstract getHandlers(): Visitor;
+}

package/src/plugins/analysis/ast/handlers/LoopHandler.ts

@@ -0,0 +1,240 @@
+/**
+ * LoopHandler -- handles loop control flow nodes: for, for-in, for-of,
+ * while, and do-while statements.
+ *
+ * Inlines the createLoopScopeHandler logic from JSASTAnalyzer (REG-422).
+ */
+import type { Visitor, NodePath } from '@babel/traverse';
+import * as t from '@babel/types';
+import { getLine, getColumn } from '../utils/location.js';
+import { computeSemanticId } from '../../../../core/SemanticId.js';
+import { ExpressionNode } from '../../../../core/nodes/ExpressionNode.js';
+import { FunctionBodyHandler } from './FunctionBodyHandler.js';
+
+export class LoopHandler extends FunctionBodyHandler {
+  getHandlers(): Visitor {
+    return {
+      ForStatement: this.createLoopHandler('for', 'for-loop', 'for'),
+      ForInStatement: this.createLoopHandler('for-in', 'for-in-loop', 'for-in'),
+      ForOfStatement: this.createLoopHandler('for-of', 'for-of-loop', 'for-of'),
+      WhileStatement: this.createLoopHandler('while', 'while-loop', 'while'),
+      DoWhileStatement: this.createLoopHandler('do-while', 'do-while-loop', 'do-while'),
+    };
+  }
+
+  private createLoopHandler(
+    trackerScopeType: string,
+    scopeType: string,
+    loopType: 'for' | 'for-in' | 'for-of' | 'while' | 'do-while',
+  ): { enter: (path: NodePath<t.Loop>) => void; exit: () => void } {
+    const ctx = this.ctx;
+    const analyzer = this.analyzer;
+
+    return {
+      enter: (path: NodePath<t.Loop>) => {
+        const node = path.node;
+
+        // Phase 6 (REG-267): Increment loop count for cyclomatic complexity
+        if (ctx.controlFlowState) {
+          ctx.controlFlowState.loopCount++;
+          // REG-298: Track loop nesting depth for isInsideLoop detection
+          ctx.controlFlowState.loopDepth++;
+        }
+
+        // 1. Create LOOP node
+        const loopCounter = ctx.loopCounterRef.value++;
+        const legacyLoopId = `${ctx.module.file}:LOOP:${loopType}:${getLine(node)}:${loopCounter}`;
+        const loopId = ctx.scopeTracker
+          ? computeSemanticId('LOOP', loopType, ctx.scopeTracker.getContext(), { discriminator: loopCounter })
+          : legacyLoopId;
+
+        // 2. Extract iteration target for for-in/for-of
+        let iteratesOverName: string | undefined;
+        let iteratesOverLine: number | undefined;
+        let iteratesOverColumn: number | undefined;
+
+        if (loopType === 'for-in' || loopType === 'for-of') {
+          const loopNode = node as t.ForInStatement | t.ForOfStatement;
+          if (t.isIdentifier(loopNode.right)) {
+            iteratesOverName = loopNode.right.name;
+            iteratesOverLine = getLine(loopNode.right);
+            iteratesOverColumn = getColumn(loopNode.right);
+          } else if (t.isMemberExpression(loopNode.right)) {
+            iteratesOverName = analyzer.memberExpressionToString(loopNode.right);
+            iteratesOverLine = getLine(loopNode.right);
+            iteratesOverColumn = getColumn(loopNode.right);
+          }
+        }
+
+        // 2b. Extract init/test/update for classic for loops and test for while/do-while (REG-282)
+        let initVariableName: string | undefined;
+        let initLine: number | undefined;
+
+        let testExpressionId: string | undefined;
+        let testExpressionType: string | undefined;
+        let testLine: number | undefined;
+        let testColumn: number | undefined;
+
+        let updateExpressionId: string | undefined;
+        let updateExpressionType: string | undefined;
+        let updateLine: number | undefined;
+        let updateColumn: number | undefined;
+
+        if (loopType === 'for') {
+          const forNode = node as t.ForStatement;
+
+          // Extract init: let i = 0
+          if (forNode.init) {
+            initLine = getLine(forNode.init);
+            if (t.isVariableDeclaration(forNode.init)) {
+              // Get name of first declared variable
+              const firstDeclarator = forNode.init.declarations[0];
+              if (t.isIdentifier(firstDeclarator.id)) {
+                initVariableName = firstDeclarator.id.name;
+              }
+            }
+          }
+
+          // Extract test: i < 10
+          if (forNode.test) {
+            testLine = getLine(forNode.test);
+            testColumn = getColumn(forNode.test);
+            testExpressionType = forNode.test.type;
+            testExpressionId = ExpressionNode.generateId(forNode.test.type, ctx.module.file, testLine, testColumn);
+          }
+
+          // Extract update: i++
+          if (forNode.update) {
+            updateLine = getLine(forNode.update);
+            updateColumn = getColumn(forNode.update);
+            updateExpressionType = forNode.update.type;
+            updateExpressionId = ExpressionNode.generateId(forNode.update.type, ctx.module.file, updateLine, updateColumn);
+          }
+        }
+
+        // Extract test condition for while and do-while loops
+        if (loopType === 'while' || loopType === 'do-while') {
+          const condLoop = node as t.WhileStatement | t.DoWhileStatement;
+          if (condLoop.test) {
+            testLine = getLine(condLoop.test);
+            testColumn = getColumn(condLoop.test);
+            testExpressionType = condLoop.test.type;
+            testExpressionId = ExpressionNode.generateId(condLoop.test.type, ctx.module.file, testLine, testColumn);
+          }
+        }
+
+        // Extract async flag for for-await-of (REG-284)
+        let isAsync: boolean | undefined;
+        if (loopType === 'for-of') {
+          const forOfNode = node as t.ForOfStatement;
+          isAsync = forOfNode.await === true ? true : undefined;
+        }
+
+        // 3. Determine actual parent - use stack for nested loops, otherwise original parentScopeId
+        const actualParentScopeId = (ctx.scopeIdStack && ctx.scopeIdStack.length > 0)
+          ? ctx.scopeIdStack[ctx.scopeIdStack.length - 1]
+          : ctx.parentScopeId;
+
+        // 3.5. Extract condition expression for while/do-while/for loops (REG-280)
+        // Note: for-in and for-of don't have test expressions (they use ITERATES_OVER instead)
+        let conditionExpressionId: string | undefined;
+        let conditionExpressionType: string | undefined;
+        let conditionLine: number | undefined;
+        let conditionColumn: number | undefined;
+
+        if (loopType === 'while' || loopType === 'do-while') {
+          const testNode = (node as t.WhileStatement | t.DoWhileStatement).test;
+          if (testNode) {
+            const condResult = analyzer.extractDiscriminantExpression(testNode, ctx.module);
+            conditionExpressionId = condResult.id;
+            conditionExpressionType = condResult.expressionType;
+            conditionLine = condResult.line;
+            conditionColumn = condResult.column;
+          }
+        } else if (loopType === 'for') {
+          const forNode = node as t.ForStatement;
+          // for loop test may be null (infinite loop: for(;;))
+          if (forNode.test) {
+            const condResult = analyzer.extractDiscriminantExpression(forNode.test, ctx.module);
+            conditionExpressionId = condResult.id;
+            conditionExpressionType = condResult.expressionType;
+            conditionLine = condResult.line;
+            conditionColumn = condResult.column;
+          }
+        }
+
+        // 4. Push LOOP info
+        ctx.loops.push({
+          id: loopId,
+          semanticId: loopId,
+          type: 'LOOP',
+          loopType,
+          file: ctx.module.file,
+          line: getLine(node),
+          column: getColumn(node),
+          parentScopeId: actualParentScopeId,
+          iteratesOverName,
+          iteratesOverLine,
+          iteratesOverColumn,
+          conditionExpressionId,
+          conditionExpressionType,
+          conditionLine,
+          conditionColumn,
+          // REG-282: init/test/update for classic for loops
+          initVariableName,
+          initLine,
+          testExpressionId,
+          testExpressionType,
+          testLine,
+          testColumn,
+          updateExpressionId,
+          updateExpressionType,
+          updateLine,
+          updateColumn,
+          // REG-284: async flag for for-await-of
+          async: isAsync
+        });
+
+        // 5. Create body SCOPE (backward compatibility)
+        const scopeId = `SCOPE#${scopeType}#${ctx.module.file}#${getLine(node)}:${ctx.scopeCounterRef.value++}`;
+        const semanticId = analyzer.generateSemanticId(scopeType, ctx.scopeTracker);
+        ctx.scopes.push({
+          id: scopeId,
+          type: 'SCOPE',
+          scopeType,
+          semanticId,
+          file: ctx.module.file,
+          line: getLine(node),
+          parentScopeId: loopId  // Parent is LOOP, not original parentScopeId
+        });
+
+        // 6. Push body SCOPE to scopeIdStack (for CONTAINS edges to nested items)
+        // The body scope is the container for nested loops, not the LOOP itself
+        if (ctx.scopeIdStack) {
+          ctx.scopeIdStack.push(scopeId);
+        }
+
+        // Enter scope for semantic ID generation
+        if (ctx.scopeTracker) {
+          ctx.scopeTracker.enterCountedScope(trackerScopeType);
+        }
+      },
+      exit: () => {
+        // REG-298: Decrement loop depth counter
+        if (ctx.controlFlowState) {
+          ctx.controlFlowState.loopDepth--;
+        }
+
+        // Pop loop scope from stack
+        if (ctx.scopeIdStack) {
+          ctx.scopeIdStack.pop();
+        }
+
+        // Exit scope
+        if (ctx.scopeTracker) {
+          ctx.scopeTracker.exitScope();
+        }
+      }
+    };
+  }
+}