@grafema/core 0.2.4-beta → 0.2.6-beta

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

@@ -8,643 +8,68 @@
  * - Constructor calls: new Foo(), new Function()
  */
 import { ASTVisitor } from './ASTVisitor.js';
-import { ExpressionEvaluator } from '../ExpressionEvaluator.js';
-import { computeSemanticId } from '../../../../core/SemanticId.js';
+import { MutationDetector } from './MutationDetector.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 { ExpressionEvaluator } from '../ExpressionEvaluator.js';
 import { getLine, getColumn } from '../utils/location.js';
+import { getGrafemaIgnore } from './call-expression-helpers.js';
+import { ArgumentExtractor } from './ArgumentExtractor.js';
+/**
+ * Extract the first literal argument value from a CallExpression for content hash hints.
+ */
+function extractFirstLiteralArg(node) {
+    if (node.arguments.length === 0)
+        return undefined;
+    const firstArg = node.arguments[0];
+    if (!firstArg)
+        return undefined;
+    const actualArg = firstArg.type === 'SpreadElement' ? firstArg.argument : firstArg;
+    const literalValue = ExpressionEvaluator.extractLiteralValue(actualArg);
+    if (literalValue !== null) {
+        return String(literalValue);
+    }
+    return undefined;
+}
 export class CallExpressionVisitor extends ASTVisitor {
     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) {
+    sharedIdGenerator;
+    constructor(module, collections, scopeTracker, sharedIdGenerator) {
         super(module, collections);
         this.scopeTracker = scopeTracker;
+        this.sharedIdGenerator = sharedIdGenerator;
     }
     /**
-     * Extract argument information for PASSES_ARGUMENT edges
-     */
-    extractArguments(args, callId, module, callArguments, literals, literalCounterRef) {
-        args.forEach((arg, index) => {
-            const argInfo = {
-                callId,
-                argIndex: index,
-                file: module.file,
-                line: arg.loc?.start.line || 0,
-                column: arg.loc?.start.column || 0
-            };
-            // Check for spread: ...arg
-            let actualArg = arg;
-            if (arg.type === 'SpreadElement') {
-                argInfo.isSpread = true;
-                actualArg = arg.argument; // Get the actual argument
-            }
-            // 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,
-                    counter: objectLiteralCounterRef.value++
-                });
-                // 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 - 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;
-            }
-            // Literal value (primitives only - objects/arrays handled above)
-            else {
-                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);
-        });
-    }
-    /**
-     * Extract all Identifier names from an expression (recursively)
-     * Used for BinaryExpression/LogicalExpression to track DERIVES_FROM edges
-     */
-    extractIdentifiers(node, identifiers = new Set()) {
-        if (!node)
-            return Array.from(identifiers);
-        if (node.type === 'Identifier') {
-            identifiers.add(node.name);
-        }
-        else if (node.type === 'BinaryExpression' || node.type === 'LogicalExpression') {
-            const expr = node;
-            this.extractIdentifiers(expr.left, identifiers);
-            this.extractIdentifiers(expr.right, identifiers);
-        }
-        else if (node.type === 'UnaryExpression') {
-            const expr = node;
-            this.extractIdentifiers(expr.argument, identifiers);
-        }
-        else if (node.type === 'ConditionalExpression') {
-            const expr = node;
-            this.extractIdentifiers(expr.test, identifiers);
-            this.extractIdentifiers(expr.consequent, identifiers);
-            this.extractIdentifiers(expr.alternate, identifiers);
-        }
-        else if (node.type === 'MemberExpression') {
-            const memberExpr = node;
-            // For obj.prop - track obj (but not prop as it's a property name)
-            if (memberExpr.object.type === 'Identifier') {
-                identifiers.add(memberExpr.object.name);
-            }
-            else {
-                this.extractIdentifiers(memberExpr.object, identifiers);
-            }
-        }
-        else if (node.type === 'CallExpression') {
-            const callExpr = node;
-            // For func() - track func if identifier, and all arguments
-            if (callExpr.callee.type === 'Identifier') {
-                identifiers.add(callExpr.callee.name);
-            }
-            for (const arg of callExpr.arguments) {
-                if (arg.type !== 'SpreadElement') {
-                    this.extractIdentifiers(arg, identifiers);
-                }
-                else {
-                    this.extractIdentifiers(arg.argument, identifiers);
-                }
-            }
-        }
-        return Array.from(identifiers);
-    }
-    /**
-     * 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';
-                    // REG-329: Capture scope path for spread variable resolution
-                    propertyInfo.valueScopePath = this.scopeTracker?.getContext().scopePath ?? [];
-                }
-                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);
-                    // Handle both non-null literals AND explicit null literals (NullLiteral)
-                    if (literalValue !== null || value.type === 'NullLiteral') {
-                        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;
-                        // REG-329: Capture scope path for scope-aware variable resolution
-                        propertyInfo.valueScopePath = this.scopeTracker?.getContext().scopePath ?? [];
-                    }
-                    // 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
+     * Extract full dotted name from a MemberExpression chain.
+     * For `a.b.c` returns "a.b.c". Returns null for complex expressions.
      *
-     * REG-117: Added isNested, baseObjectName, propertyName for nested mutations
+     * Used by REG-395 to create CALL nodes for nested method calls like a.b.c().
      */
-    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;
-            // Capture scope path for scope-aware lookup (REG-309)
-            const scopePath = scopeTracker?.getContext().scopePath ?? [];
-            if (scopeTracker) {
-                const discriminator = scopeTracker.getItemCounter(`ARRAY_MUTATION:${arrayName}.${method}`);
-                mutationId = computeSemanticId('ARRAY_MUTATION', `${arrayName}.${method}`, scopeTracker.getContext(), { discriminator });
-            }
-            arrayMutations.push({
-                id: mutationId,
-                arrayName,
-                mutationScopePath: scopePath,
-                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;
+    static extractMemberExpressionName(node) {
+        const parts = [];
+        let current = node;
+        // Walk the chain collecting property names
+        while (current) {
+            if (current.computed)
+                return null; // Can't statically resolve computed access
+            if (current.property.type !== 'Identifier')
+                return null;
+            parts.unshift(current.property.name);
+            if (current.object.type === 'Identifier') {
+                parts.unshift(current.object.name);
+                return parts.join('.');
+            }
+            else if (current.object.type === 'ThisExpression') {
+                parts.unshift('this');
+                return parts.join('.');
+            }
+            else if (current.object.type === 'MemberExpression') {
+                current = current.object;
             }
-            // Capture scope path for scope-aware lookup (REG-309)
-            const scopePath = this.scopeTracker?.getContext().scopePath ?? [];
-            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 });
+            else {
+                return null; // Complex expression
             }
-            objectMutations.push({
-                id: mutationId,
-                objectName: targetName,
-                mutationScopePath: scopePath,
-                propertyName: '<assign>',
-                mutationType: 'assign',
-                file: module.file,
-                line,
-                column,
-                value: valueInfo
-            });
         }
+        return null;
     }
     /**
      * Get a stable scope ID for a function parent.
@@ -694,233 +119,306 @@ export class CallExpressionVisitor extends ASTVisitor {
         return `${module.file}->${scopePath.join('->')}->FUNCTION->${funcName}`;
     }
     getHandlers() {
-        const { module } = this;
-        const callSites = this.collections.callSites ?? [];
-        const methodCalls = this.collections.methodCalls ?? [];
-        const eventListeners = this.collections.eventListeners ?? [];
-        const methodCallbacks = this.collections.methodCallbacks ?? [];
-        const literals = this.collections.literals ?? [];
-        const callArguments = this.collections.callArguments ?? [];
-        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;
+        const s = {
+            module: this.module,
+            callSites: (this.collections.callSites ?? []),
+            methodCalls: (this.collections.methodCalls ?? []),
+            eventListeners: (this.collections.eventListeners ?? []),
+            methodCallbacks: (this.collections.methodCallbacks ?? []),
+            literals: (this.collections.literals ?? []),
+            callArguments: (this.collections.callArguments ?? []),
+            callSiteCounterRef: (this.collections.callSiteCounterRef ?? { value: 0 }),
+            literalCounterRef: (this.collections.literalCounterRef ?? { value: 0 }),
+            processedNodes: this.collections.processedNodes ?? { callSites: new Set(), methodCalls: new Set(), eventListeners: new Set() },
+            scopeTracker: this.scopeTracker,
+        };
         return {
             CallExpression: (path) => {
                 const callNode = path.node;
                 const functionParent = path.getFunctionParent();
-                // 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
+                // Skip if inside function - handled by analyzeFunctionBody
+                if (functionParent)
+                    return;
+                const parentScopeId = s.module.id;
+                const isAwaited = path.parentPath?.isAwaitExpression() ?? false;
                 if (callNode.callee.type === 'Identifier') {
-                    if (functionParent) {
-                        return;
-                    }
-                    const callee = callNode.callee;
-                    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,
-                        column,
-                        parentScopeId,
-                        targetFunctionName: callee.name
-                    });
-                    // Extract arguments for PASSES_ARGUMENT edges
-                    if (callNode.arguments.length > 0) {
-                        this.extractArguments(callNode.arguments, callId, module, callArguments, literals, literalCounterRef);
-                    }
+                    this.handleDirectCall(callNode, s, parentScopeId, isAwaited);
                 }
-                // 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;
-                    const isComputed = memberCallee.computed;
-                    if ((object.type === 'Identifier' || object.type === 'ThisExpression') && property.type === 'Identifier') {
-                        const objectName = object.type === 'Identifier' ? object.name : 'this';
-                        // For computed access obj[x](), methodName is '<computed>' but we save the variable name
-                        const methodName = isComputed ? '<computed>' : property.name;
-                        const computedPropertyVar = isComputed ? property.name : null;
-                        // Special handling for .on() event handlers
-                        if (methodName === 'on' && callNode.arguments.length >= 2) {
-                            const firstArg = callNode.arguments[0];
-                            const secondArg = callNode.arguments[1];
-                            if (firstArg.type === 'StringLiteral') {
-                                const eventName = firstArg.value;
-                                // Dedup check
-                                const nodeKey = `${callNode.start}:${callNode.end}`;
-                                if (processedNodes.eventListeners.has(nodeKey)) {
-                                    return;
-                                }
-                                processedNodes.eventListeners.add(nodeKey);
-                                const eventLine = getLine(callNode);
-                                const eventColumn = getColumn(callNode);
-                                eventListeners.push({
-                                    id: `event:listener#${eventName}#${module.file}#${eventLine}:${eventColumn}:${callSiteCounterRef.value++}`,
-                                    type: 'event:listener',
-                                    name: eventName,
-                                    object: objectName,
-                                    file: module.file,
-                                    line: eventLine,
-                                    parentScopeId,
-                                    callbackArg: secondArg
-                                });
-                            }
-                        }
-                        else {
-                            // Regular method call
-                            const nodeKey = `${callNode.start}:${callNode.end}`;
-                            if (processedNodes.methodCalls.has(nodeKey)) {
-                                return;
-                            }
-                            processedNodes.methodCalls.add(nodeKey);
-                            const fullName = `${objectName}.${methodName}`;
-                            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',
-                                name: fullName,
-                                object: objectName,
-                                method: methodName,
-                                computed: isComputed,
-                                computedPropertyVar, // Variable name used in obj[x]() calls
-                                file: module.file,
-                                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);
-                                // Also track callbacks for HAS_CALLBACK edges
-                                callNode.arguments.forEach((arg) => {
-                                    if (arg.type === 'ArrowFunctionExpression' || arg.type === 'FunctionExpression') {
-                                        methodCallbacks.push({
-                                            methodCallId,
-                                            callbackLine: getLine(arg),
-                                            callbackColumn: getColumn(arg),
-                                            callbackType: arg.type
-                                        });
-                                    }
-                                });
-                            }
-                        }
-                    }
-                    // 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);
-                            }
-                        }
-                    }
+                    this.handleMemberCall(path, callNode, s, parentScopeId, isAwaited);
                 }
             },
-            // 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();
-                // Skip if inside function - handled by analyzeFunctionBody
-                if (functionParent) {
+            NewExpression: (path) => this.handleNewExpression(path, s),
+        };
+    }
+    /** Handle direct function calls: foo() */
+    handleDirectCall(callNode, s, parentScopeId, isAwaited) {
+        const callee = callNode.callee;
+        const line = getLine(callNode);
+        const column = getColumn(callNode);
+        const callInfo = {
+            id: '', // Placeholder — resolved by generateV2 or set below
+            type: 'CALL',
+            name: callee.name,
+            file: s.module.file,
+            line,
+            column,
+            parentScopeId,
+            targetFunctionName: callee.name,
+            isAwaited: isAwaited || undefined
+        };
+        if (this.sharedIdGenerator) {
+            const contentHints = {
+                arity: callNode.arguments.length,
+                firstLiteralArg: extractFirstLiteralArg(callNode)
+            };
+            this.sharedIdGenerator.generateV2('CALL', callee.name, s.module.file, contentHints, callInfo);
+        }
+        else {
+            const idGenerator = new IdGenerator(s.scopeTracker);
+            callInfo.id = idGenerator.generate('CALL', callee.name, s.module.file, line, column, s.callSiteCounterRef, { useDiscriminator: true, discriminatorKey: `CALL:${callee.name}` });
+        }
+        const callId = callInfo.id;
+        s.callSites.push(callInfo);
+        if (callNode.arguments.length > 0) {
+            ArgumentExtractor.extract(callNode.arguments, callId, s.module, s.callArguments, s.literals, s.literalCounterRef, this.collections, s.scopeTracker);
+        }
+    }
+    /** Handle method calls: obj.method(), obj.on('event', handler), obj.arr.push() */
+    handleMemberCall(path, callNode, s, parentScopeId, isAwaited) {
+        const memberCallee = callNode.callee;
+        const object = memberCallee.object;
+        const property = memberCallee.property;
+        const isComputed = memberCallee.computed;
+        if ((object.type === 'Identifier' || object.type === 'ThisExpression') && property.type === 'Identifier') {
+            this.handleSimpleMethodCall(path, callNode, s, parentScopeId, isAwaited, memberCallee, object, property, isComputed);
+        }
+        // REG-117/REG-395: Nested method calls like obj.arr.push() or a.b.c()
+        else if (object.type === 'MemberExpression' && property.type === 'Identifier') {
+            this.handleNestedMethodCall(path, callNode, s, parentScopeId, object, property, isComputed);
+        }
+    }
+    /** Handle simple method calls: obj.method() or obj.on('event', handler) */
+    handleSimpleMethodCall(path, callNode, s, parentScopeId, isAwaited, memberCallee, object, property, isComputed) {
+        const objectName = object.type === 'Identifier' ? object.name : 'this';
+        const methodName = isComputed ? '<computed>' : property.name;
+        const computedPropertyVar = isComputed ? property.name : null;
+        // Special handling for .on() event handlers
+        if (methodName === 'on' && callNode.arguments.length >= 2) {
+            const firstArg = callNode.arguments[0];
+            const secondArg = callNode.arguments[1];
+            if (firstArg.type === 'StringLiteral') {
+                const nodeKey = `${callNode.start}:${callNode.end}`;
+                if (s.processedNodes.eventListeners.has(nodeKey))
                     return;
+                s.processedNodes.eventListeners.add(nodeKey);
+                const eventLine = getLine(callNode);
+                const eventColumn = getColumn(callNode);
+                s.eventListeners.push({
+                    id: `event:listener#${firstArg.value}#${s.module.file}#${eventLine}:${eventColumn}:${s.callSiteCounterRef.value++}`,
+                    type: 'event:listener',
+                    name: firstArg.value,
+                    object: objectName,
+                    file: s.module.file,
+                    line: eventLine,
+                    parentScopeId,
+                    callbackArg: secondArg
+                });
+            }
+            return;
+        }
+        // Regular method call
+        const nodeKey = `${callNode.start}:${callNode.end}`;
+        if (s.processedNodes.methodCalls.has(nodeKey))
+            return;
+        s.processedNodes.methodCalls.add(nodeKey);
+        const fullName = `${objectName}.${methodName}`;
+        const methodLine = getLine(callNode);
+        const methodColumn = getColumn(callNode);
+        const grafemaIgnore = getGrafemaIgnore(path);
+        const methodCallInfo = {
+            id: '', // Placeholder — resolved by generateV2 or set below
+            type: 'CALL',
+            name: fullName,
+            object: objectName,
+            method: methodName,
+            computed: isComputed,
+            computedPropertyVar,
+            file: s.module.file,
+            line: methodLine,
+            column: methodColumn,
+            parentScopeId,
+            grafemaIgnore: grafemaIgnore ?? undefined,
+            isAwaited: isAwaited || undefined,
+        };
+        if (this.sharedIdGenerator) {
+            const contentHints = {
+                arity: callNode.arguments.length,
+                firstLiteralArg: extractFirstLiteralArg(callNode)
+            };
+            this.sharedIdGenerator.generateV2('CALL', fullName, s.module.file, contentHints, methodCallInfo);
+        }
+        else {
+            const idGenerator = new IdGenerator(s.scopeTracker);
+            methodCallInfo.id = idGenerator.generate('CALL', fullName, s.module.file, methodLine, methodColumn, s.callSiteCounterRef, { useDiscriminator: true, discriminatorKey: `CALL:${fullName}` });
+        }
+        const methodCallId = methodCallInfo.id;
+        s.methodCalls.push(methodCallInfo);
+        // Check for array mutation methods (push, unshift, splice)
+        const ARRAY_MUTATION_METHODS = ['push', 'unshift', 'splice'];
+        if (ARRAY_MUTATION_METHODS.includes(methodName)) {
+            MutationDetector.detectArrayMutation(callNode, objectName, methodName, s.module, this.collections, s.scopeTracker);
+        }
+        // Check for Object.assign() calls
+        if (objectName === 'Object' && methodName === 'assign') {
+            MutationDetector.detectObjectAssign(callNode, s.module, this.collections, s.scopeTracker);
+        }
+        // Extract arguments for PASSES_ARGUMENT edges
+        if (callNode.arguments.length > 0) {
+            ArgumentExtractor.extract(callNode.arguments, methodCallId, s.module, s.callArguments, s.literals, s.literalCounterRef, this.collections, s.scopeTracker);
+            // Also track callbacks for HAS_CALLBACK edges
+            callNode.arguments.forEach((arg) => {
+                if (arg.type === 'ArrowFunctionExpression' || arg.type === 'FunctionExpression') {
+                    s.methodCallbacks.push({
+                        methodCallId,
+                        callbackLine: getLine(arg),
+                        callbackColumn: getColumn(arg),
+                        callbackType: arg.type
+                    });
                 }
-                const parentScopeId = module.id;
-                // Dedup check
-                const nodeKey = `new:${newNode.start}:${newNode.end}`;
-                if (processedNodes.methodCalls.has(nodeKey)) {
-                    return;
+            });
+        }
+    }
+    /** Handle nested method calls: obj.arr.push(), a.b.c() (REG-117, REG-395) */
+    handleNestedMethodCall(path, callNode, s, parentScopeId, nestedMember, property, isComputed) {
+        const methodName = isComputed ? '<computed>' : property.name;
+        const ARRAY_MUTATION_METHODS = ['push', 'unshift', 'splice'];
+        if (ARRAY_MUTATION_METHODS.includes(methodName)) {
+            const base = nestedMember.object;
+            const prop = nestedMember.property;
+            if ((base.type === 'Identifier' || base.type === 'ThisExpression') &&
+                !nestedMember.computed && prop.type === 'Identifier') {
+                const baseObjectName = base.type === 'Identifier' ? base.name : 'this';
+                const propertyName = prop.name;
+                MutationDetector.detectArrayMutation(callNode, `${baseObjectName}.${propertyName}`, methodName, s.module, this.collections, s.scopeTracker, true, baseObjectName, propertyName);
+            }
+        }
+        // REG-395: Create CALL node for nested method calls like a.b.c()
+        const objectName = CallExpressionVisitor.extractMemberExpressionName(nestedMember);
+        if (objectName) {
+            const nodeKey = `${callNode.start}:${callNode.end}`;
+            if (!s.processedNodes.methodCalls.has(nodeKey)) {
+                s.processedNodes.methodCalls.add(nodeKey);
+                const fullName = `${objectName}.${methodName}`;
+                const methodLine = getLine(callNode);
+                const methodColumn = getColumn(callNode);
+                const grafemaIgnore = getGrafemaIgnore(path);
+                const methodCallInfo = {
+                    id: '', // Placeholder — resolved by generateV2 or set below
+                    type: 'CALL',
+                    name: fullName,
+                    object: objectName,
+                    method: methodName,
+                    file: s.module.file,
+                    line: methodLine,
+                    column: methodColumn,
+                    parentScopeId,
+                    grafemaIgnore: grafemaIgnore ?? undefined,
+                };
+                if (this.sharedIdGenerator) {
+                    const contentHints = {
+                        arity: callNode.arguments.length,
+                        firstLiteralArg: extractFirstLiteralArg(callNode)
+                    };
+                    this.sharedIdGenerator.generateV2('CALL', fullName, s.module.file, contentHints, methodCallInfo);
                 }
-                processedNodes.methodCalls.add(nodeKey);
-                // new Foo() - Identifier callee
-                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: newCallId,
-                        type: 'CALL',
-                        name: constructorName,
-                        file: module.file,
-                        line: newLine,
-                        column: newColumn,
-                        parentScopeId,
-                        targetFunctionName: constructorName,
-                        isNew: true // Mark as constructor call
-                    });
+                else {
+                    const idGenerator = new IdGenerator(s.scopeTracker);
+                    methodCallInfo.id = idGenerator.generate('CALL', fullName, s.module.file, methodLine, methodColumn, s.callSiteCounterRef, { useDiscriminator: true, discriminatorKey: `CALL:${fullName}` });
+                }
+                s.methodCalls.push(methodCallInfo);
+            }
+        }
+    }
+    /** Handle new expressions: new Foo(), new obj.Constructor() */
+    handleNewExpression(path, s) {
+        const newNode = path.node;
+        const functionParent = path.getFunctionParent();
+        // Skip if inside function - handled by analyzeFunctionBody
+        if (functionParent)
+            return;
+        const parentScopeId = s.module.id;
+        // Dedup check
+        const nodeKey = `new:${newNode.start}:${newNode.end}`;
+        if (s.processedNodes.methodCalls.has(nodeKey))
+            return;
+        s.processedNodes.methodCalls.add(nodeKey);
+        if (newNode.callee.type === 'Identifier') {
+            const constructorName = newNode.callee.name;
+            const newLine = getLine(newNode);
+            const newColumn = getColumn(newNode);
+            const callInfo = {
+                id: '', // Placeholder — resolved by generateV2 or set below
+                type: 'CALL',
+                name: constructorName,
+                file: s.module.file,
+                line: newLine,
+                column: newColumn,
+                parentScopeId,
+                targetFunctionName: constructorName,
+                isNew: true
+            };
+            if (this.sharedIdGenerator) {
+                const contentHints = {
+                    arity: newNode.arguments.length,
+                    firstLiteralArg: undefined // constructor args not used for hash
+                };
+                this.sharedIdGenerator.generateV2('CALL', `new:${constructorName}`, s.module.file, contentHints, callInfo);
+            }
+            else {
+                const idGenerator = new IdGenerator(s.scopeTracker);
+                callInfo.id = idGenerator.generate('CALL', `new:${constructorName}`, s.module.file, newLine, newColumn, s.callSiteCounterRef, { useDiscriminator: true, discriminatorKey: `CALL:new:${constructorName}` });
+            }
+            s.callSites.push(callInfo);
+        }
+        else if (newNode.callee.type === 'MemberExpression') {
+            const memberCallee = newNode.callee;
+            const object = memberCallee.object;
+            const property = memberCallee.property;
+            if (object.type === 'Identifier' && property.type === 'Identifier') {
+                const objectName = object.name;
+                const constructorName = property.name;
+                const fullName = `${objectName}.${constructorName}`;
+                const memberNewLine = getLine(newNode);
+                const memberNewColumn = getColumn(newNode);
+                const grafemaIgnore = getGrafemaIgnore(path);
+                const methodCallInfo = {
+                    id: '', // Placeholder — resolved by generateV2 or set below
+                    type: 'CALL',
+                    name: fullName,
+                    object: objectName,
+                    method: constructorName,
+                    file: s.module.file,
+                    line: memberNewLine,
+                    column: memberNewColumn,
+                    parentScopeId,
+                    isNew: true,
+                    grafemaIgnore: grafemaIgnore ?? undefined,
+                };
+                if (this.sharedIdGenerator) {
+                    const contentHints = {
+                        arity: newNode.arguments.length,
+                        firstLiteralArg: undefined // constructor args not used for hash
+                    };
+                    this.sharedIdGenerator.generateV2('CALL', `new:${fullName}`, s.module.file, contentHints, methodCallInfo);
                 }
-                // new obj.Constructor() - MemberExpression callee
-                else if (newNode.callee.type === 'MemberExpression') {
-                    const memberCallee = newNode.callee;
-                    const object = memberCallee.object;
-                    const property = memberCallee.property;
-                    if (object.type === 'Identifier' && property.type === 'Identifier') {
-                        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: newMethodCallId,
-                            type: 'CALL',
-                            name: fullName,
-                            object: objectName,
-                            method: constructorName,
-                            file: module.file,
-                            line: memberNewLine,
-                            column: memberNewColumn,
-                            parentScopeId,
-                            isNew: true // Mark as constructor call
-                        });
-                    }
+                else {
+                    const idGenerator = new IdGenerator(s.scopeTracker);
+                    methodCallInfo.id = idGenerator.generate('CALL', `new:${fullName}`, s.module.file, memberNewLine, memberNewColumn, s.callSiteCounterRef, { useDiscriminator: true, discriminatorKey: `CALL:new:${fullName}` });
                 }
+                s.methodCalls.push(methodCallInfo);
             }
-        };
+        }
     }
 }
+//# sourceMappingURL=CallExpressionVisitor.js.map