@grafema/core 0.1.0-alpha.5 → 0.1.1-alpha

package/dist/plugins/analysis/ast/visitors/CallExpressionVisitor.js

@@ -9,9 +9,22 @@
  */
 import { ASTVisitor } from './ASTVisitor.js';
 import { ExpressionEvaluator } from '../ExpressionEvaluator.js';
+import { computeSemanticId } from '../../../../core/SemanticId.js';
+import { IdGenerator } from '../IdGenerator.js';
+import { NodeFactory } from '../../../../core/NodeFactory.js';
+import { ObjectLiteralNode } from '../../../../core/nodes/ObjectLiteralNode.js';
+import { ArrayLiteralNode } from '../../../../core/nodes/ArrayLiteralNode.js';
+import { getLine, getColumn } from '../utils/location.js';
 export class CallExpressionVisitor extends ASTVisitor {
-    constructor(module, collections) {
+    scopeTracker;
+    /**
+     * @param module - Current module being analyzed
+     * @param collections - Must contain arrays and counter refs
+     * @param scopeTracker - Optional ScopeTracker for semantic ID generation
+     */
+    constructor(module, collections, scopeTracker) {
         super(module, collections);
+        this.scopeTracker = scopeTracker;
     }
     /**
      * Extract argument information for PASSES_ARGUMENT edges
@@ -31,104 +44,157 @@ export class CallExpressionVisitor extends ASTVisitor {
                 argInfo.isSpread = true;
                 actualArg = arg.argument; // Get the actual argument
             }
-            // Literal value
-            const literalValue = ExpressionEvaluator.extractLiteralValue(actualArg);
-            if (literalValue !== null) {
-                const literalId = `LITERAL#arg${index}#${module.file}#${argInfo.line}:${argInfo.column}:${literalCounterRef.value++}`;
-                literals.push({
-                    id: literalId,
-                    type: 'LITERAL',
-                    value: literalValue,
-                    valueType: typeof literalValue,
-                    file: module.file,
-                    line: argInfo.line,
-                    column: argInfo.column,
-                    parentCallId: callId,
-                    argIndex: index
-                });
-                argInfo.targetType = 'LITERAL';
-                argInfo.targetId = literalId;
-                argInfo.literalValue = literalValue;
-            }
-            // Variable reference
-            else if (actualArg.type === 'Identifier') {
-                argInfo.targetType = 'VARIABLE';
-                argInfo.targetName = actualArg.name; // Will be resolved in GraphBuilder
-            }
-            // Function expression (callback)
-            else if (actualArg.type === 'ArrowFunctionExpression' || actualArg.type === 'FunctionExpression') {
-                argInfo.targetType = 'FUNCTION';
-                argInfo.functionLine = actualArg.loc?.start.line;
-                argInfo.functionColumn = actualArg.loc?.start.column;
-            }
-            // Call expression (nested call)
-            else if (actualArg.type === 'CallExpression') {
-                argInfo.targetType = 'CALL';
-                // Nested calls will be processed separately, link by position
-                argInfo.nestedCallLine = actualArg.loc?.start.line;
-                argInfo.nestedCallColumn = actualArg.loc?.start.column;
-            }
-            // Member expression: obj.prop or obj[x]
-            else if (actualArg.type === 'MemberExpression') {
-                const memberExpr = actualArg;
-                argInfo.targetType = 'EXPRESSION';
-                argInfo.expressionType = 'MemberExpression';
-                if (memberExpr.object.type === 'Identifier') {
-                    argInfo.objectName = memberExpr.object.name;
-                }
-                if (!memberExpr.computed && memberExpr.property.type === 'Identifier') {
-                    argInfo.propertyName = memberExpr.property.name;
-                }
-            }
-            // Binary/Logical expression: a + b, a && b
-            else if (actualArg.type === 'BinaryExpression' || actualArg.type === 'LogicalExpression') {
-                const expr = actualArg;
-                const operator = expr.operator || '?';
-                const exprName = `<${actualArg.type}:${operator}>`;
-                const expressionId = `EXPRESSION#${exprName}#${module.file}#${argInfo.line}:${argInfo.column}:${literalCounterRef.value++}`;
-                // Create EXPRESSION node
-                literals.push({
-                    id: expressionId,
-                    type: 'EXPRESSION',
-                    expressionType: actualArg.type,
-                    operator: operator,
-                    name: exprName,
-                    file: module.file,
-                    line: argInfo.line,
-                    column: argInfo.column,
+            // Object literal - check BEFORE extractLiteralValue to handle object-typed args properly
+            if (actualArg.type === 'ObjectExpression') {
+                const objectExpr = actualArg;
+                // Initialize collections if not exist (must assign back to this.collections!)
+                if (!this.collections.objectLiteralCounterRef) {
+                    this.collections.objectLiteralCounterRef = { value: 0 };
+                }
+                if (!this.collections.objectLiterals) {
+                    this.collections.objectLiterals = [];
+                }
+                if (!this.collections.objectProperties) {
+                    this.collections.objectProperties = [];
+                }
+                const objectLiteralCounterRef = this.collections.objectLiteralCounterRef;
+                // Use factory to create OBJECT_LITERAL node
+                const objectNode = ObjectLiteralNode.create(module.file, argInfo.line, argInfo.column, {
                     parentCallId: callId,
-                    argIndex: index
+                    argIndex: index,
+                    counter: objectLiteralCounterRef.value++
                 });
-                argInfo.targetType = 'EXPRESSION';
-                argInfo.targetId = expressionId;
-                argInfo.expressionType = actualArg.type;
-                // Track DERIVES_FROM edges for identifiers in expression
-                const identifiers = this.extractIdentifiers(actualArg);
-                const { variableAssignments } = this.collections;
-                if (variableAssignments) {
-                    for (const identName of identifiers) {
-                        variableAssignments.push({
-                            variableId: expressionId,
-                            sourceId: null,
-                            sourceName: identName,
-                            sourceType: 'DERIVES_FROM_VARIABLE',
-                            file: module.file
-                        });
-                    }
-                }
-            }
-            // Object literal
-            else if (actualArg.type === 'ObjectExpression') {
+                // Factory guarantees line is set, cast to ObjectLiteralInfo
+                this.collections.objectLiterals.push(objectNode);
+                const objectId = objectNode.id;
+                // Extract properties
+                this.extractObjectProperties(objectExpr, objectId, module, this.collections.objectProperties, this.collections.objectLiterals, objectLiteralCounterRef, literals, literalCounterRef);
                 argInfo.targetType = 'OBJECT_LITERAL';
+                argInfo.targetId = objectId;
             }
-            // Array literal
+            // Array literal - check BEFORE extractLiteralValue to handle array-typed args properly
             else if (actualArg.type === 'ArrayExpression') {
+                const arrayExpr = actualArg;
+                // Initialize collections if not exist (must assign back to this.collections!)
+                if (!this.collections.arrayLiteralCounterRef) {
+                    this.collections.arrayLiteralCounterRef = { value: 0 };
+                }
+                if (!this.collections.arrayLiterals) {
+                    this.collections.arrayLiterals = [];
+                }
+                if (!this.collections.arrayElements) {
+                    this.collections.arrayElements = [];
+                }
+                if (!this.collections.objectLiteralCounterRef) {
+                    this.collections.objectLiteralCounterRef = { value: 0 };
+                }
+                if (!this.collections.objectLiterals) {
+                    this.collections.objectLiterals = [];
+                }
+                if (!this.collections.objectProperties) {
+                    this.collections.objectProperties = [];
+                }
+                const arrayLiteralCounterRef = this.collections.arrayLiteralCounterRef;
+                // Use factory to create ARRAY_LITERAL node
+                const arrayNode = ArrayLiteralNode.create(module.file, argInfo.line, argInfo.column, {
+                    parentCallId: callId,
+                    argIndex: index,
+                    counter: arrayLiteralCounterRef.value++
+                });
+                // Factory guarantees line is set, cast to ArrayLiteralInfo
+                this.collections.arrayLiterals.push(arrayNode);
+                const arrayId = arrayNode.id;
+                // Extract elements
+                this.extractArrayElements(arrayExpr, arrayId, module, this.collections.arrayElements, this.collections.arrayLiterals, arrayLiteralCounterRef, this.collections.objectLiterals, this.collections.objectLiteralCounterRef, this.collections.objectProperties, literals, literalCounterRef);
                 argInfo.targetType = 'ARRAY_LITERAL';
+                argInfo.targetId = arrayId;
             }
-            // Other expression types
+            // Literal value (primitives only - objects/arrays handled above)
             else {
-                argInfo.targetType = 'EXPRESSION';
-                argInfo.expressionType = actualArg.type;
+                const literalValue = ExpressionEvaluator.extractLiteralValue(actualArg);
+                if (literalValue !== null) {
+                    const literalId = `LITERAL#arg${index}#${module.file}#${argInfo.line}:${argInfo.column}:${literalCounterRef.value++}`;
+                    literals.push({
+                        id: literalId,
+                        type: 'LITERAL',
+                        value: literalValue,
+                        valueType: typeof literalValue,
+                        file: module.file,
+                        line: argInfo.line,
+                        column: argInfo.column,
+                        parentCallId: callId,
+                        argIndex: index
+                    });
+                    argInfo.targetType = 'LITERAL';
+                    argInfo.targetId = literalId;
+                    argInfo.literalValue = literalValue;
+                }
+                // Variable reference
+                else if (actualArg.type === 'Identifier') {
+                    argInfo.targetType = 'VARIABLE';
+                    argInfo.targetName = actualArg.name; // Will be resolved in GraphBuilder
+                }
+                // Function expression (callback)
+                else if (actualArg.type === 'ArrowFunctionExpression' || actualArg.type === 'FunctionExpression') {
+                    argInfo.targetType = 'FUNCTION';
+                    argInfo.functionLine = actualArg.loc?.start.line;
+                    argInfo.functionColumn = actualArg.loc?.start.column;
+                }
+                // Call expression (nested call)
+                else if (actualArg.type === 'CallExpression') {
+                    argInfo.targetType = 'CALL';
+                    // Nested calls will be processed separately, link by position
+                    argInfo.nestedCallLine = actualArg.loc?.start.line;
+                    argInfo.nestedCallColumn = actualArg.loc?.start.column;
+                }
+                // Member expression: obj.prop or obj[x]
+                else if (actualArg.type === 'MemberExpression') {
+                    const memberExpr = actualArg;
+                    argInfo.targetType = 'EXPRESSION';
+                    argInfo.expressionType = 'MemberExpression';
+                    if (memberExpr.object.type === 'Identifier') {
+                        argInfo.objectName = memberExpr.object.name;
+                    }
+                    if (!memberExpr.computed && memberExpr.property.type === 'Identifier') {
+                        argInfo.propertyName = memberExpr.property.name;
+                    }
+                }
+                // Binary/Logical expression: a + b, a && b
+                else if (actualArg.type === 'BinaryExpression' || actualArg.type === 'LogicalExpression') {
+                    const expr = actualArg;
+                    const operator = expr.operator || '?';
+                    const counter = literalCounterRef.value++;
+                    // Create EXPRESSION node via NodeFactory
+                    const expressionNode = NodeFactory.createArgumentExpression(actualArg.type, module.file, argInfo.line, argInfo.column, {
+                        parentCallId: callId,
+                        argIndex: index,
+                        operator,
+                        counter
+                    });
+                    literals.push(expressionNode);
+                    argInfo.targetType = 'EXPRESSION';
+                    argInfo.targetId = expressionNode.id;
+                    argInfo.expressionType = actualArg.type;
+                    // Track DERIVES_FROM edges for identifiers in expression
+                    const identifiers = this.extractIdentifiers(actualArg);
+                    const { variableAssignments } = this.collections;
+                    if (variableAssignments) {
+                        for (const identName of identifiers) {
+                            variableAssignments.push({
+                                variableId: expressionNode.id,
+                                sourceId: null,
+                                sourceName: identName,
+                                sourceType: 'DERIVES_FROM_VARIABLE',
+                                file: module.file
+                            });
+                        }
+                    }
+                }
+                // Other expression types (fallback for unhandled expression types)
+                else {
+                    argInfo.targetType = 'EXPRESSION';
+                    argInfo.expressionType = actualArg.type;
+                }
             }
             callArguments.push(argInfo);
         });
@@ -186,28 +252,435 @@ export class CallExpressionVisitor extends ASTVisitor {
         return Array.from(identifiers);
     }
     /**
-     * Get a stable scope ID for a function parent
-     * Format must match what FunctionVisitor creates:
-     * - FunctionDeclaration: FUNCTION#name#file#line
-     * - ArrowFunctionExpression: FUNCTION#name#file#line:col:counter
+     * Extract object properties and create ObjectPropertyInfo records
+     */
+    extractObjectProperties(objectExpr, objectId, module, objectProperties, objectLiterals, objectLiteralCounterRef, literals, literalCounterRef) {
+        for (const prop of objectExpr.properties) {
+            const propLine = prop.loc?.start.line || 0;
+            const propColumn = prop.loc?.start.column || 0;
+            // Handle spread properties: { ...other }
+            if (prop.type === 'SpreadElement') {
+                const spreadArg = prop.argument;
+                const propertyInfo = {
+                    objectId,
+                    propertyName: '<spread>',
+                    valueType: 'SPREAD',
+                    file: module.file,
+                    line: propLine,
+                    column: propColumn
+                };
+                if (spreadArg.type === 'Identifier') {
+                    propertyInfo.valueName = spreadArg.name;
+                    propertyInfo.valueType = 'VARIABLE';
+                }
+                objectProperties.push(propertyInfo);
+                continue;
+            }
+            // Handle regular properties
+            if (prop.type === 'ObjectProperty') {
+                const objProp = prop;
+                let propertyName;
+                // Get property name
+                if (objProp.key.type === 'Identifier') {
+                    propertyName = objProp.key.name;
+                }
+                else if (objProp.key.type === 'StringLiteral') {
+                    propertyName = objProp.key.value;
+                }
+                else if (objProp.key.type === 'NumericLiteral') {
+                    propertyName = String(objProp.key.value);
+                }
+                else {
+                    propertyName = '<computed>';
+                }
+                const propertyInfo = {
+                    objectId,
+                    propertyName,
+                    file: module.file,
+                    line: propLine,
+                    column: propColumn,
+                    valueType: 'EXPRESSION'
+                };
+                const value = objProp.value;
+                // Nested object literal - check BEFORE extractLiteralValue
+                if (value.type === 'ObjectExpression') {
+                    // Use factory - do NOT pass argIndex for nested literals (uses 'obj' suffix)
+                    const nestedObjectNode = ObjectLiteralNode.create(module.file, value.loc?.start.line || 0, value.loc?.start.column || 0, {
+                        counter: objectLiteralCounterRef.value++
+                    });
+                    objectLiterals.push(nestedObjectNode);
+                    const nestedObjectId = nestedObjectNode.id;
+                    // Recursively extract nested properties
+                    this.extractObjectProperties(value, nestedObjectId, module, objectProperties, objectLiterals, objectLiteralCounterRef, literals, literalCounterRef);
+                    propertyInfo.valueType = 'OBJECT_LITERAL';
+                    propertyInfo.nestedObjectId = nestedObjectId;
+                    propertyInfo.valueNodeId = nestedObjectId;
+                }
+                // Nested array literal - check BEFORE extractLiteralValue
+                else if (value.type === 'ArrayExpression') {
+                    const arrayLiteralCounterRef = (this.collections.arrayLiteralCounterRef ?? { value: 0 });
+                    const arrayLiterals = this.collections.arrayLiterals ?? [];
+                    const arrayElements = this.collections.arrayElements ?? [];
+                    // Use factory - do NOT pass argIndex for nested literals (uses 'arr' suffix)
+                    const nestedArrayNode = ArrayLiteralNode.create(module.file, value.loc?.start.line || 0, value.loc?.start.column || 0, {
+                        counter: arrayLiteralCounterRef.value++
+                    });
+                    arrayLiterals.push(nestedArrayNode);
+                    const nestedArrayId = nestedArrayNode.id;
+                    // Recursively extract array elements
+                    this.extractArrayElements(value, nestedArrayId, module, arrayElements, arrayLiterals, arrayLiteralCounterRef, objectLiterals, objectLiteralCounterRef, objectProperties, literals, literalCounterRef);
+                    propertyInfo.valueType = 'ARRAY_LITERAL';
+                    propertyInfo.nestedArrayId = nestedArrayId;
+                    propertyInfo.valueNodeId = nestedArrayId;
+                }
+                // Literal value (primitives only - objects/arrays handled above)
+                else {
+                    const literalValue = ExpressionEvaluator.extractLiteralValue(value);
+                    if (literalValue !== null) {
+                        const literalId = `LITERAL#${propertyName}#${module.file}#${propLine}:${propColumn}:${literalCounterRef.value++}`;
+                        literals.push({
+                            id: literalId,
+                            type: 'LITERAL',
+                            value: literalValue,
+                            valueType: typeof literalValue,
+                            file: module.file,
+                            line: propLine,
+                            column: propColumn,
+                            parentCallId: objectId,
+                            argIndex: 0
+                        });
+                        propertyInfo.valueType = 'LITERAL';
+                        propertyInfo.valueNodeId = literalId;
+                        propertyInfo.literalValue = literalValue;
+                    }
+                    // Variable reference
+                    else if (value.type === 'Identifier') {
+                        propertyInfo.valueType = 'VARIABLE';
+                        propertyInfo.valueName = value.name;
+                    }
+                    // Call expression
+                    else if (value.type === 'CallExpression') {
+                        propertyInfo.valueType = 'CALL';
+                        propertyInfo.callLine = value.loc?.start.line;
+                        propertyInfo.callColumn = value.loc?.start.column;
+                    }
+                    // Other expressions
+                    else {
+                        propertyInfo.valueType = 'EXPRESSION';
+                    }
+                }
+                objectProperties.push(propertyInfo);
+            }
+            // Handle object methods: { foo() {} }
+            else if (prop.type === 'ObjectMethod') {
+                const propertyName = prop.key.type === 'Identifier' ? prop.key.name : '<computed>';
+                objectProperties.push({
+                    objectId,
+                    propertyName,
+                    valueType: 'EXPRESSION',
+                    file: module.file,
+                    line: propLine,
+                    column: propColumn
+                });
+            }
+        }
+    }
+    /**
+     * Extract array elements and create ArrayElementInfo records
+     */
+    extractArrayElements(arrayExpr, arrayId, module, arrayElements, arrayLiterals, arrayLiteralCounterRef, objectLiterals, objectLiteralCounterRef, objectProperties, literals, literalCounterRef) {
+        arrayExpr.elements.forEach((element, index) => {
+            if (!element)
+                return; // Skip holes in arrays
+            const elemLine = element.loc?.start.line || 0;
+            const elemColumn = element.loc?.start.column || 0;
+            const elementInfo = {
+                arrayId,
+                index,
+                file: module.file,
+                line: elemLine,
+                column: elemColumn,
+                valueType: 'EXPRESSION'
+            };
+            // Handle spread elements: [...arr]
+            if (element.type === 'SpreadElement') {
+                const spreadArg = element.argument;
+                elementInfo.valueType = 'SPREAD';
+                if (spreadArg.type === 'Identifier') {
+                    elementInfo.valueName = spreadArg.name;
+                }
+                arrayElements.push(elementInfo);
+                return;
+            }
+            // Nested object literal - check BEFORE extractLiteralValue
+            if (element.type === 'ObjectExpression') {
+                // Use factory - do NOT pass argIndex for nested literals (uses 'obj' suffix)
+                const nestedObjectNode = ObjectLiteralNode.create(module.file, elemLine, elemColumn, {
+                    counter: objectLiteralCounterRef.value++
+                });
+                objectLiterals.push(nestedObjectNode);
+                const nestedObjectId = nestedObjectNode.id;
+                // Recursively extract properties
+                this.extractObjectProperties(element, nestedObjectId, module, objectProperties, objectLiterals, objectLiteralCounterRef, literals, literalCounterRef);
+                elementInfo.valueType = 'OBJECT_LITERAL';
+                elementInfo.nestedObjectId = nestedObjectId;
+                elementInfo.valueNodeId = nestedObjectId;
+            }
+            // Nested array literal - check BEFORE extractLiteralValue
+            else if (element.type === 'ArrayExpression') {
+                // Use factory - do NOT pass argIndex for nested literals (uses 'arr' suffix)
+                const nestedArrayNode = ArrayLiteralNode.create(module.file, elemLine, elemColumn, {
+                    counter: arrayLiteralCounterRef.value++
+                });
+                arrayLiterals.push(nestedArrayNode);
+                const nestedArrayId = nestedArrayNode.id;
+                // Recursively extract elements
+                this.extractArrayElements(element, nestedArrayId, module, arrayElements, arrayLiterals, arrayLiteralCounterRef, objectLiterals, objectLiteralCounterRef, objectProperties, literals, literalCounterRef);
+                elementInfo.valueType = 'ARRAY_LITERAL';
+                elementInfo.nestedArrayId = nestedArrayId;
+                elementInfo.valueNodeId = nestedArrayId;
+            }
+            // Literal value (primitives only - objects/arrays handled above)
+            else {
+                const literalValue = ExpressionEvaluator.extractLiteralValue(element);
+                if (literalValue !== null) {
+                    const literalId = `LITERAL#elem${index}#${module.file}#${elemLine}:${elemColumn}:${literalCounterRef.value++}`;
+                    literals.push({
+                        id: literalId,
+                        type: 'LITERAL',
+                        value: literalValue,
+                        valueType: typeof literalValue,
+                        file: module.file,
+                        line: elemLine,
+                        column: elemColumn,
+                        parentCallId: arrayId,
+                        argIndex: index
+                    });
+                    elementInfo.valueType = 'LITERAL';
+                    elementInfo.valueNodeId = literalId;
+                    elementInfo.literalValue = literalValue;
+                }
+                // Variable reference
+                else if (element.type === 'Identifier') {
+                    elementInfo.valueType = 'VARIABLE';
+                    elementInfo.valueName = element.name;
+                }
+                // Call expression
+                else if (element.type === 'CallExpression') {
+                    elementInfo.valueType = 'CALL';
+                    elementInfo.callLine = element.loc?.start.line;
+                    elementInfo.callColumn = element.loc?.start.column;
+                }
+                // Other expressions
+                else {
+                    elementInfo.valueType = 'EXPRESSION';
+                }
+            }
+            arrayElements.push(elementInfo);
+        });
+    }
+    /**
+     * Detect array mutation calls (push, unshift, splice) and collect mutation info
+     * for later FLOWS_INTO edge creation in GraphBuilder
+     *
+     * REG-117: Added isNested, baseObjectName, propertyName for nested mutations
+     */
+    detectArrayMutation(callNode, arrayName, method, module, isNested, baseObjectName, propertyName) {
+        // Initialize collection if not exists
+        if (!this.collections.arrayMutations) {
+            this.collections.arrayMutations = [];
+        }
+        const arrayMutations = this.collections.arrayMutations;
+        const mutationArgs = [];
+        // For splice, only arguments from index 2 onwards are insertions
+        // splice(start, deleteCount, item1, item2, ...)
+        callNode.arguments.forEach((arg, index) => {
+            // Skip start and deleteCount for splice
+            if (method === 'splice' && index < 2)
+                return;
+            const argInfo = {
+                argIndex: method === 'splice' ? index - 2 : index,
+                isSpread: arg.type === 'SpreadElement',
+                valueType: 'EXPRESSION' // Default
+            };
+            let actualArg = arg;
+            if (arg.type === 'SpreadElement') {
+                actualArg = arg.argument;
+            }
+            // Determine value type
+            const literalValue = ExpressionEvaluator.extractLiteralValue(actualArg);
+            if (literalValue !== null) {
+                argInfo.valueType = 'LITERAL';
+                argInfo.literalValue = literalValue;
+            }
+            else if (actualArg.type === 'Identifier') {
+                argInfo.valueType = 'VARIABLE';
+                argInfo.valueName = actualArg.name;
+            }
+            else if (actualArg.type === 'ObjectExpression') {
+                argInfo.valueType = 'OBJECT_LITERAL';
+            }
+            else if (actualArg.type === 'ArrayExpression') {
+                argInfo.valueType = 'ARRAY_LITERAL';
+            }
+            else if (actualArg.type === 'CallExpression') {
+                argInfo.valueType = 'CALL';
+                argInfo.callLine = actualArg.loc?.start.line;
+                argInfo.callColumn = actualArg.loc?.start.column;
+            }
+            mutationArgs.push(argInfo);
+        });
+        // Only record if there are actual insertions
+        if (mutationArgs.length > 0) {
+            const line = callNode.loc?.start.line ?? 0;
+            const column = callNode.loc?.start.column ?? 0;
+            // Generate semantic ID for array mutation if scopeTracker available
+            const scopeTracker = this.scopeTracker;
+            let mutationId;
+            if (scopeTracker) {
+                const discriminator = scopeTracker.getItemCounter(`ARRAY_MUTATION:${arrayName}.${method}`);
+                mutationId = computeSemanticId('ARRAY_MUTATION', `${arrayName}.${method}`, scopeTracker.getContext(), { discriminator });
+            }
+            arrayMutations.push({
+                id: mutationId,
+                arrayName,
+                mutationMethod: method,
+                file: module.file,
+                line,
+                column,
+                insertedValues: mutationArgs,
+                // REG-117: Nested mutation fields
+                isNested,
+                baseObjectName,
+                propertyName
+            });
+        }
+    }
+    /**
+     * Detect Object.assign(target, source1, source2, ...) calls
+     * Creates ObjectMutationInfo for FLOWS_INTO edge generation in GraphBuilder
+     *
+     * @param callNode - The call expression node
+     * @param module - Current module being analyzed
+     */
+    detectObjectAssign(callNode, module) {
+        // Need at least 2 arguments: target and at least one source
+        if (callNode.arguments.length < 2)
+            return;
+        // Initialize object mutations collection if not exists
+        if (!this.collections.objectMutations) {
+            this.collections.objectMutations = [];
+        }
+        const objectMutations = this.collections.objectMutations;
+        // First argument is target
+        const targetArg = callNode.arguments[0];
+        let targetName;
+        if (targetArg.type === 'Identifier') {
+            targetName = targetArg.name;
+        }
+        else if (targetArg.type === 'ObjectExpression') {
+            targetName = '<anonymous>';
+        }
+        else {
+            return;
+        }
+        const line = callNode.loc?.start.line ?? 0;
+        const column = callNode.loc?.start.column ?? 0;
+        for (let i = 1; i < callNode.arguments.length; i++) {
+            let arg = callNode.arguments[i];
+            let isSpread = false;
+            if (arg.type === 'SpreadElement') {
+                isSpread = true;
+                arg = arg.argument;
+            }
+            const valueInfo = {
+                valueType: 'EXPRESSION',
+                argIndex: i - 1,
+                isSpread
+            };
+            const literalValue = ExpressionEvaluator.extractLiteralValue(arg);
+            if (literalValue !== null) {
+                valueInfo.valueType = 'LITERAL';
+                valueInfo.literalValue = literalValue;
+            }
+            else if (arg.type === 'Identifier') {
+                valueInfo.valueType = 'VARIABLE';
+                valueInfo.valueName = arg.name;
+            }
+            else if (arg.type === 'ObjectExpression') {
+                valueInfo.valueType = 'OBJECT_LITERAL';
+            }
+            else if (arg.type === 'ArrayExpression') {
+                valueInfo.valueType = 'ARRAY_LITERAL';
+            }
+            else if (arg.type === 'CallExpression') {
+                valueInfo.valueType = 'CALL';
+                valueInfo.callLine = arg.loc?.start.line;
+                valueInfo.callColumn = arg.loc?.start.column;
+            }
+            let mutationId;
+            if (this.scopeTracker) {
+                const discriminator = this.scopeTracker.getItemCounter(`OBJECT_MUTATION:Object.assign:${targetName}`);
+                mutationId = computeSemanticId('OBJECT_MUTATION', `Object.assign:${targetName}`, this.scopeTracker.getContext(), { discriminator });
+            }
+            objectMutations.push({
+                id: mutationId,
+                objectName: targetName,
+                propertyName: '<assign>',
+                mutationType: 'assign',
+                file: module.file,
+                line,
+                column,
+                value: valueInfo
+            });
+        }
+    }
+    /**
+     * Get a stable scope ID for a function parent.
+     *
+     * Format must match what FunctionVisitor/ClassVisitor creates (semantic ID):
+     * - Module-level function: {file}->global->FUNCTION->{name}
+     * - Class method: {file}->{className}->FUNCTION->{methodName}
      *
-     * NOTE: We don't have access to the counter here, so for arrow functions
-     * we try to match by name+file+line:col. This may not always work for
-     * multiple arrow functions on the same line.
+     * Reconstructs scope path by walking up the AST.
      */
     getFunctionScopeId(functionParent, module) {
         const funcNode = functionParent.node;
-        const line = funcNode.loc?.start.line || 0;
-        const col = funcNode.loc?.start.column || 0;
-        // FunctionDeclaration with name
+        // Get function name
+        let funcName;
         if (funcNode.type === 'FunctionDeclaration' && funcNode.id?.name) {
-            return `FUNCTION#${funcNode.id.name}#${module.file}#${line}`;
+            funcName = funcNode.id.name;
+        }
+        else if (funcNode.type === 'ClassMethod' && funcNode.key?.type === 'Identifier') {
+            funcName = funcNode.key.name;
+        }
+        if (!funcName) {
+            // Anonymous function - fall back to module scope
+            return module.id;
+        }
+        // Build scope path by walking up the AST
+        const scopePath = [];
+        let current = functionParent.parentPath;
+        while (current) {
+            const node = current.node;
+            if (node.type === 'ClassDeclaration' && node.id?.name) {
+                scopePath.unshift(node.id.name);
+                break; // Class is the outermost scope we need
+            }
+            else if (node.type === 'ClassBody') {
+                // Continue up to ClassDeclaration
+            }
+            else if (node.type === 'Program') {
+                break;
+            }
+            current = current.parentPath;
+        }
+        // If no class found, it's at module level (global scope)
+        if (scopePath.length === 0) {
+            scopePath.push('global');
         }
-        // For arrow functions and other cases, we can't perfectly match the ID
-        // because FunctionVisitor uses a counter. For now, use module.id as fallback
-        // to avoid creating invalid edges. The CALL node will be connected to MODULE
-        // instead of the specific function.
-        return module.id;
+        // Compute semantic ID: {file}->{scopePath}->FUNCTION->{name}
+        return `${module.file}->${scopePath.join('->')}->FUNCTION->${funcName}`;
     }
     getHandlers() {
         const { module } = this;
@@ -220,6 +693,7 @@ export class CallExpressionVisitor extends ASTVisitor {
         const callSiteCounterRef = (this.collections.callSiteCounterRef ?? { value: 0 });
         const literalCounterRef = (this.collections.literalCounterRef ?? { value: 0 });
         const processedNodes = this.collections.processedNodes ?? { callSites: new Set(), methodCalls: new Set(), eventListeners: new Set() };
+        const scopeTracker = this.scopeTracker;
         return {
             CallExpression: (path) => {
                 const callNode = path.node;
@@ -227,16 +701,24 @@ export class CallExpressionVisitor extends ASTVisitor {
                 // Determine parent scope - if inside a function, use function's scope, otherwise module
                 const parentScopeId = functionParent ? this.getFunctionScopeId(functionParent, module) : module.id;
                 // Identifier calls (direct function calls)
+                // Skip if inside function - they will be processed by analyzeFunctionBody with proper scope tracking
                 if (callNode.callee.type === 'Identifier') {
+                    if (functionParent) {
+                        return;
+                    }
                     const callee = callNode.callee;
-                    const callId = `CALL#${callee.name}#${module.file}#${callNode.loc.start.line}:${callNode.loc.start.column}:${callSiteCounterRef.value++}`;
+                    const line = getLine(callNode);
+                    const column = getColumn(callNode);
+                    // Generate ID using centralized IdGenerator
+                    const idGenerator = new IdGenerator(scopeTracker);
+                    const callId = idGenerator.generate('CALL', callee.name, module.file, line, column, callSiteCounterRef, { useDiscriminator: true, discriminatorKey: `CALL:${callee.name}` });
                     callSites.push({
                         id: callId,
                         type: 'CALL',
                         name: callee.name,
                         file: module.file,
-                        line: callNode.loc.start.line,
-                        column: callNode.loc.start.column,
+                        line,
+                        column,
                         parentScopeId,
                         targetFunctionName: callee.name
                     });
@@ -245,8 +727,12 @@ export class CallExpressionVisitor extends ASTVisitor {
                         this.extractArguments(callNode.arguments, callId, module, callArguments, literals, literalCounterRef);
                     }
                 }
-                // MemberExpression calls (method calls at module level)
+                // MemberExpression calls (method calls)
+                // Skip if inside function - they will be processed by analyzeFunctionBody with proper scope tracking
                 else if (callNode.callee.type === 'MemberExpression') {
+                    if (functionParent) {
+                        return;
+                    }
                     const memberCallee = callNode.callee;
                     const object = memberCallee.object;
                     const property = memberCallee.property;
@@ -268,13 +754,15 @@ export class CallExpressionVisitor extends ASTVisitor {
                                     return;
                                 }
                                 processedNodes.eventListeners.add(nodeKey);
+                                const eventLine = getLine(callNode);
+                                const eventColumn = getColumn(callNode);
                                 eventListeners.push({
-                                    id: `event:listener#${eventName}#${module.file}#${callNode.loc.start.line}:${callNode.loc.start.column}:${callSiteCounterRef.value++}`,
+                                    id: `event:listener#${eventName}#${module.file}#${eventLine}:${eventColumn}:${callSiteCounterRef.value++}`,
                                     type: 'event:listener',
                                     name: eventName,
                                     object: objectName,
                                     file: module.file,
-                                    line: callNode.loc.start.line,
+                                    line: eventLine,
                                     parentScopeId,
                                     callbackArg: secondArg
                                 });
@@ -288,7 +776,11 @@ export class CallExpressionVisitor extends ASTVisitor {
                             }
                             processedNodes.methodCalls.add(nodeKey);
                             const fullName = `${objectName}.${methodName}`;
-                            const methodCallId = `CALL#${fullName}#${module.file}#${callNode.loc.start.line}:${callNode.loc.start.column}:${callSiteCounterRef.value++}`;
+                            const methodLine = getLine(callNode);
+                            const methodColumn = getColumn(callNode);
+                            // Generate ID using centralized IdGenerator
+                            const idGenerator = new IdGenerator(scopeTracker);
+                            const methodCallId = idGenerator.generate('CALL', fullName, module.file, methodLine, methodColumn, callSiteCounterRef, { useDiscriminator: true, discriminatorKey: `CALL:${fullName}` });
                             methodCalls.push({
                                 id: methodCallId,
                                 type: 'CALL',
@@ -298,10 +790,19 @@ export class CallExpressionVisitor extends ASTVisitor {
                                 computed: isComputed,
                                 computedPropertyVar, // Variable name used in obj[x]() calls
                                 file: module.file,
-                                line: callNode.loc.start.line,
-                                column: callNode.loc.start.column,
+                                line: methodLine,
+                                column: methodColumn,
                                 parentScopeId
                             });
+                            // Check for array mutation methods (push, unshift, splice)
+                            const ARRAY_MUTATION_METHODS = ['push', 'unshift', 'splice'];
+                            if (ARRAY_MUTATION_METHODS.includes(methodName)) {
+                                this.detectArrayMutation(callNode, objectName, methodName, module);
+                            }
+                            // Check for Object.assign() calls
+                            if (objectName === 'Object' && methodName === 'assign') {
+                                this.detectObjectAssign(callNode, module);
+                            }
                             // Extract arguments for PASSES_ARGUMENT edges
                             if (callNode.arguments.length > 0) {
                                 this.extractArguments(callNode.arguments, methodCallId, module, callArguments, literals, literalCounterRef);
@@ -310,8 +811,8 @@ export class CallExpressionVisitor extends ASTVisitor {
                                     if (arg.type === 'ArrowFunctionExpression' || arg.type === 'FunctionExpression') {
                                         methodCallbacks.push({
                                             methodCallId,
-                                            callbackLine: arg.loc.start.line,
-                                            callbackColumn: arg.loc.start.column,
+                                            callbackLine: getLine(arg),
+                                            callbackColumn: getColumn(arg),
                                             callbackType: arg.type
                                         });
                                     }
@@ -319,13 +820,40 @@ export class CallExpressionVisitor extends ASTVisitor {
                             }
                         }
                     }
+                    // REG-117: Nested array mutations like obj.arr.push(item)
+                    // object is MemberExpression, property is the method name
+                    else if (object.type === 'MemberExpression' && property.type === 'Identifier') {
+                        const nestedMember = object;
+                        const methodName = property.name;
+                        const ARRAY_MUTATION_METHODS = ['push', 'unshift', 'splice'];
+                        if (ARRAY_MUTATION_METHODS.includes(methodName)) {
+                            // Extract base object and property from nested MemberExpression
+                            const base = nestedMember.object;
+                            const prop = nestedMember.property;
+                            // Only handle single-level nesting: obj.arr.push() or this.items.push()
+                            if ((base.type === 'Identifier' || base.type === 'ThisExpression') &&
+                                !nestedMember.computed &&
+                                prop.type === 'Identifier') {
+                                const baseObjectName = base.type === 'Identifier' ? base.name : 'this';
+                                const propertyName = prop.name;
+                                this.detectArrayMutation(callNode, `${baseObjectName}.${propertyName}`, // arrayName for ID purposes
+                                methodName, module, true, // isNested
+                                baseObjectName, propertyName);
+                            }
+                        }
+                    }
                 }
             },
             // NewExpression: new Foo(), new Function(), new Map(), etc.
+            // Skip if inside function - they will be processed by analyzeFunctionBody with proper scope tracking
             NewExpression: (path) => {
                 const newNode = path.node;
                 const functionParent = path.getFunctionParent();
-                const parentScopeId = functionParent ? this.getFunctionScopeId(functionParent, module) : module.id;
+                // Skip if inside function - handled by analyzeFunctionBody
+                if (functionParent) {
+                    return;
+                }
+                const parentScopeId = module.id;
                 // Dedup check
                 const nodeKey = `new:${newNode.start}:${newNode.end}`;
                 if (processedNodes.methodCalls.has(nodeKey)) {
@@ -336,13 +864,18 @@ export class CallExpressionVisitor extends ASTVisitor {
                 if (newNode.callee.type === 'Identifier') {
                     const callee = newNode.callee;
                     const constructorName = callee.name;
+                    const newLine = getLine(newNode);
+                    const newColumn = getColumn(newNode);
+                    // Generate ID using centralized IdGenerator
+                    const idGenerator = new IdGenerator(scopeTracker);
+                    const newCallId = idGenerator.generate('CALL', `new:${constructorName}`, module.file, newLine, newColumn, callSiteCounterRef, { useDiscriminator: true, discriminatorKey: `CALL:new:${constructorName}` });
                     callSites.push({
-                        id: `CALL#new:${constructorName}#${module.file}#${newNode.loc.start.line}:${newNode.loc.start.column}:${callSiteCounterRef.value++}`,
+                        id: newCallId,
                         type: 'CALL',
                         name: constructorName,
                         file: module.file,
-                        line: newNode.loc.start.line,
-                        column: newNode.loc.start.column,
+                        line: newLine,
+                        column: newColumn,
                         parentScopeId,
                         targetFunctionName: constructorName,
                         isNew: true // Mark as constructor call
@@ -357,15 +890,20 @@ export class CallExpressionVisitor extends ASTVisitor {
                         const objectName = object.name;
                         const constructorName = property.name;
                         const fullName = `${objectName}.${constructorName}`;
+                        const memberNewLine = getLine(newNode);
+                        const memberNewColumn = getColumn(newNode);
+                        // Generate ID using centralized IdGenerator
+                        const idGenerator = new IdGenerator(scopeTracker);
+                        const newMethodCallId = idGenerator.generate('CALL', `new:${fullName}`, module.file, memberNewLine, memberNewColumn, callSiteCounterRef, { useDiscriminator: true, discriminatorKey: `CALL:new:${fullName}` });
                         methodCalls.push({
-                            id: `CALL#new:${fullName}#${module.file}#${newNode.loc.start.line}:${newNode.loc.start.column}:${callSiteCounterRef.value++}`,
+                            id: newMethodCallId,
                             type: 'CALL',
                             name: fullName,
                             object: objectName,
                             method: constructorName,
                             file: module.file,
-                            line: newNode.loc.start.line,
-                            column: newNode.loc.start.column,
+                            line: memberNewLine,
+                            column: memberNewColumn,
                             parentScopeId,
                             isNew: true // Mark as constructor call
                         });