@grafema/core 0.2.5-beta → 0.2.7

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

@@ -0,0 +1,201 @@
+/**
+ * NestedFunctionHandler — handles FunctionDeclaration, FunctionExpression,
+ * and ArrowFunctionExpression nodes found inside a function body.
+ *
+ * Mechanical extraction from analyzeFunctionBody() (REG-422).
+ * Original source: JSASTAnalyzer.ts lines ~4108-4285.
+ */
+import type { Visitor, NodePath } from '@babel/traverse';
+import * as t from '@babel/types';
+import { getLine, getColumn } from '../utils/location.js';
+import { computeSemanticId } from '../../../../core/SemanticId.js';
+import type { ReturnStatementInfo } from '../types.js';
+import { FunctionBodyHandler } from './FunctionBodyHandler.js';
+
+export class NestedFunctionHandler extends FunctionBodyHandler {
+  getHandlers(): Visitor {
+    const ctx = this.ctx;
+    const analyzer = this.analyzer;
+
+    return {
+      FunctionDeclaration: (funcDeclPath: NodePath<t.FunctionDeclaration>) => {
+        const node = funcDeclPath.node;
+        const funcName = node.id ? node.id.name : analyzer.generateAnonymousName(ctx.scopeTracker);
+        // Use semantic ID as primary ID when scopeTracker available
+        const legacyId = `FUNCTION#${funcName}#${ctx.module.file}#${getLine(node)}:${getColumn(node)}:${ctx.functionCounterRef.value++}`;
+        const functionId = ctx.scopeTracker
+          ? computeSemanticId('FUNCTION', funcName, ctx.scopeTracker.getContext())
+          : legacyId;
+
+        ctx.functions.push({
+          id: functionId,
+          type: 'FUNCTION',
+          name: funcName,
+          file: ctx.module.file,
+          line: getLine(node),
+          column: getColumn(node),
+          async: node.async || false,
+          generator: node.generator || false,
+          parentScopeId: ctx.parentScopeId
+        });
+
+        const nestedScopeId = `SCOPE#${funcName}:body#${ctx.module.file}#${getLine(node)}`;
+        const closureSemanticId = analyzer.generateSemanticId('closure', ctx.scopeTracker);
+        ctx.scopes.push({
+          id: nestedScopeId,
+          type: 'SCOPE',
+          scopeType: 'closure',
+          name: `${funcName}:body`,
+          semanticId: closureSemanticId,
+          conditional: false,
+          file: ctx.module.file,
+          line: getLine(node),
+          parentFunctionId: functionId,
+          capturesFrom: ctx.parentScopeId
+        });
+
+        // Enter nested function scope for semantic ID generation
+        if (ctx.scopeTracker) {
+          ctx.scopeTracker.enterScope(funcName, 'function');
+        }
+        analyzer.analyzeFunctionBody(funcDeclPath, nestedScopeId, ctx.module, ctx.collections);
+        if (ctx.scopeTracker) {
+          ctx.scopeTracker.exitScope();
+        }
+        funcDeclPath.skip();
+      },
+
+      FunctionExpression: (funcPath: NodePath<t.FunctionExpression>) => {
+        const node = funcPath.node;
+        const funcName = node.id ? node.id.name : analyzer.generateAnonymousName(ctx.scopeTracker);
+        // Use semantic ID as primary ID when scopeTracker available
+        const legacyId = `FUNCTION#${funcName}#${ctx.module.file}#${getLine(node)}:${getColumn(node)}:${ctx.functionCounterRef.value++}`;
+        const functionId = ctx.scopeTracker
+          ? computeSemanticId('FUNCTION', funcName, ctx.scopeTracker.getContext())
+          : legacyId;
+
+        ctx.functions.push({
+          id: functionId,
+          type: 'FUNCTION',
+          name: funcName,
+          file: ctx.module.file,
+          line: getLine(node),
+          column: getColumn(node),
+          async: node.async || false,
+          generator: node.generator || false,
+          parentScopeId: ctx.parentScopeId
+        });
+
+        const nestedScopeId = `SCOPE#${funcName}:body#${ctx.module.file}#${getLine(node)}`;
+        const closureSemanticId = analyzer.generateSemanticId('closure', ctx.scopeTracker);
+        ctx.scopes.push({
+          id: nestedScopeId,
+          type: 'SCOPE',
+          scopeType: 'closure',
+          name: `${funcName}:body`,
+          semanticId: closureSemanticId,
+          conditional: false,
+          file: ctx.module.file,
+          line: getLine(node),
+          parentFunctionId: functionId,
+          capturesFrom: ctx.parentScopeId
+        });
+
+        // Enter nested function scope for semantic ID generation
+        if (ctx.scopeTracker) {
+          ctx.scopeTracker.enterScope(funcName, 'function');
+        }
+        analyzer.analyzeFunctionBody(funcPath, nestedScopeId, ctx.module, ctx.collections);
+        if (ctx.scopeTracker) {
+          ctx.scopeTracker.exitScope();
+        }
+        funcPath.skip();
+      },
+
+      ArrowFunctionExpression: (arrowPath: NodePath<t.ArrowFunctionExpression>) => {
+        const node = arrowPath.node;
+        const line = getLine(node);
+        const column = getColumn(node);
+
+        // Determine name (anonymous if not assigned to variable)
+        const parent = arrowPath.parent;
+        let funcName: string;
+        if (t.isVariableDeclarator(parent) && t.isIdentifier(parent.id)) {
+          funcName = parent.id.name;
+        } else {
+          // Use scope-level counter for stable semanticId
+          funcName = analyzer.generateAnonymousName(ctx.scopeTracker);
+        }
+
+        // Use semantic ID as primary ID when scopeTracker available
+        const legacyId = `FUNCTION#${funcName}:${line}:${column}:${ctx.functionCounterRef.value++}`;
+        const functionId = ctx.scopeTracker
+          ? computeSemanticId('FUNCTION', funcName, ctx.scopeTracker.getContext())
+          : legacyId;
+
+        ctx.functions.push({
+          id: functionId,
+          type: 'FUNCTION',
+          name: funcName,
+          file: ctx.module.file,
+          line,
+          column,
+          async: node.async || false,
+          arrowFunction: true,
+          parentScopeId: ctx.parentScopeId
+        });
+
+        if (node.body.type === 'BlockStatement') {
+          const nestedScopeId = `SCOPE#${funcName}:body#${ctx.module.file}#${line}`;
+          const arrowSemanticId = analyzer.generateSemanticId('arrow_body', ctx.scopeTracker);
+          ctx.scopes.push({
+            id: nestedScopeId,
+            type: 'SCOPE',
+            scopeType: 'arrow_body',
+            name: `${funcName}:body`,
+            semanticId: arrowSemanticId,
+            conditional: false,
+            file: ctx.module.file,
+            line,
+            parentFunctionId: functionId,
+            capturesFrom: ctx.parentScopeId
+          });
+
+          // Enter arrow function scope for semantic ID generation
+          if (ctx.scopeTracker) {
+            ctx.scopeTracker.enterScope(funcName, 'arrow');
+          }
+          analyzer.analyzeFunctionBody(arrowPath, nestedScopeId, ctx.module, ctx.collections);
+          if (ctx.scopeTracker) {
+            ctx.scopeTracker.exitScope();
+          }
+        } else {
+          // Arrow function with expression body (implicit return)
+          // e.g., x => x * 2, () => 42
+          const bodyExpr = node.body;
+          const bodyLine = getLine(bodyExpr);
+          const bodyColumn = getColumn(bodyExpr);
+
+          // Extract expression-specific info using shared method
+          const exprInfo = analyzer.extractReturnExpressionInfo(
+            bodyExpr, ctx.module, ctx.literals, ctx.literalCounterRef, line, column, 'implicit_return'
+          );
+
+          const returnInfo: ReturnStatementInfo = {
+            parentFunctionId: functionId,
+            file: ctx.module.file,
+            line: bodyLine,
+            column: bodyColumn,
+            returnValueType: 'NONE',
+            isImplicitReturn: true,
+            ...exprInfo,
+          };
+
+          ctx.returnStatements.push(returnInfo);
+        }
+
+        arrowPath.skip();
+      },
+    };
+  }
+}

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

@@ -0,0 +1,159 @@
+/**
+ * NewExpressionHandler — handles NewExpression nodes (constructor calls).
+ *
+ * Mechanical extraction from analyzeFunctionBody() (REG-422).
+ * Original source: JSASTAnalyzer.ts lines ~4679-4816.
+ */
+import type { Visitor, NodePath } from '@babel/traverse';
+import * as t from '@babel/types';
+import { getLine, getColumn } from '../utils/location.js';
+import { computeSemanticId } from '../../../../core/SemanticId.js';
+import { ConstructorCallNode } from '../../../../core/nodes/ConstructorCallNode.js';
+import { FunctionBodyHandler } from './FunctionBodyHandler.js';
+
+export class NewExpressionHandler extends FunctionBodyHandler {
+  getHandlers(): Visitor {
+    const ctx = this.ctx;
+
+    return {
+      // NewExpression (constructor calls)
+      NewExpression: (newPath: NodePath<t.NewExpression>) => {
+        const newNode = newPath.node;
+        const nodeKey = `new:${newNode.start}:${newNode.end}`;
+
+        // Determine className from callee
+        let className: string | null = null;
+        if (newNode.callee.type === 'Identifier') {
+          className = newNode.callee.name;
+        } else if (newNode.callee.type === 'MemberExpression' && newNode.callee.property.type === 'Identifier') {
+          className = newNode.callee.property.name;
+        }
+
+        // Create CONSTRUCTOR_CALL node (always, for all NewExpressions)
+        if (className) {
+          const constructorKey = `constructor:${nodeKey}`;
+          if (!ctx.processedCallSites.has(constructorKey)) {
+            ctx.processedCallSites.add(constructorKey);
+
+            const line = getLine(newNode);
+            const column = getColumn(newNode);
+            const constructorCallId = ConstructorCallNode.generateId(className, ctx.module.file, line, column);
+            const isBuiltin = ConstructorCallNode.isBuiltinConstructor(className);
+
+            ctx.constructorCalls.push({
+              id: constructorCallId,
+              type: 'CONSTRUCTOR_CALL',
+              className,
+              isBuiltin,
+              file: ctx.module.file,
+              line,
+              column
+            });
+
+            // REG-334: If this is Promise constructor with executor callback,
+            // register the context for resolve/reject detection
+            if (className === 'Promise' && newNode.arguments.length > 0) {
+              const executorArg = newNode.arguments[0];
+
+              // Only handle inline function expressions (not variable references)
+              if (t.isArrowFunctionExpression(executorArg) || t.isFunctionExpression(executorArg)) {
+                // Extract resolve/reject parameter names
+                let resolveName: string | undefined;
+                let rejectName: string | undefined;
+
+                if (executorArg.params.length > 0 && t.isIdentifier(executorArg.params[0])) {
+                  resolveName = executorArg.params[0].name;
+                }
+                if (executorArg.params.length > 1 && t.isIdentifier(executorArg.params[1])) {
+                  rejectName = executorArg.params[1].name;
+                }
+
+                if (resolveName) {
+                  // Key by function node position to allow nested Promise detection
+                  const funcKey = `${executorArg.start}:${executorArg.end}`;
+                  ctx.promiseExecutorContexts.set(funcKey, {
+                    constructorCallId,
+                    resolveName,
+                    rejectName,
+                    file: ctx.module.file,
+                    line,
+                    // REG-311: Store the ID of the function that creates the Promise
+                    creatorFunctionId: ctx.currentFunctionId || undefined
+                  });
+                }
+              }
+            }
+          }
+        }
+
+        // Handle simple constructor: new Foo()
+        if (newNode.callee.type === 'Identifier') {
+          if (ctx.processedCallSites.has(nodeKey)) {
+            return;
+          }
+          ctx.processedCallSites.add(nodeKey);
+
+          // Generate semantic ID (primary) or legacy ID (fallback)
+          const constructorName = newNode.callee.name;
+          const legacyId = `CALL#new:${constructorName}#${ctx.module.file}#${getLine(newNode)}:${getColumn(newNode)}:${ctx.callSiteCounterRef.value++}`;
+
+          let newCallId = legacyId;
+          if (ctx.scopeTracker) {
+            const discriminator = ctx.scopeTracker.getItemCounter(`CALL:new:${constructorName}`);
+            newCallId = computeSemanticId('CALL', `new:${constructorName}`, ctx.scopeTracker.getContext(), { discriminator });
+          }
+
+          ctx.callSites.push({
+            id: newCallId,
+            type: 'CALL',
+            name: constructorName,
+            file: ctx.module.file,
+            line: getLine(newNode),
+            parentScopeId: ctx.getCurrentScopeId(),
+            targetFunctionName: constructorName,
+            isNew: true
+          });
+        }
+        // Handle namespaced constructor: new ns.Constructor()
+        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') {
+            if (ctx.processedMethodCalls.has(nodeKey)) {
+              return;
+            }
+            ctx.processedMethodCalls.add(nodeKey);
+
+            const objectName = object.name;
+            const constructorName = property.name;
+            const fullName = `${objectName}.${constructorName}`;
+
+            // Generate semantic ID for method-style constructor call
+            const legacyId = `CALL#new:${fullName}#${ctx.module.file}#${getLine(newNode)}:${getColumn(newNode)}:${ctx.callSiteCounterRef.value++}`;
+
+            let newMethodCallId = legacyId;
+            if (ctx.scopeTracker) {
+              const discriminator = ctx.scopeTracker.getItemCounter(`CALL:new:${fullName}`);
+              newMethodCallId = computeSemanticId('CALL', `new:${fullName}`, ctx.scopeTracker.getContext(), { discriminator });
+            }
+
+            ctx.methodCalls.push({
+              id: newMethodCallId,
+              type: 'CALL',
+              name: fullName,
+              object: objectName,
+              method: constructorName,
+              file: ctx.module.file,
+              line: getLine(newNode),
+              column: getColumn(newNode),
+              parentScopeId: ctx.getCurrentScopeId(),
+              isNew: true
+            });
+          }
+        }
+      },
+    };
+  }
+}

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

@@ -0,0 +1,112 @@
+/**
+ * PropertyAccessHandler — handles MemberExpression, OptionalMemberExpression,
+ * MetaProperty, and UpdateExpression nodes.
+ *
+ * Mechanical extraction from analyzeFunctionBody() (REG-422).
+ * Original source: JSASTAnalyzer.ts lines ~4287-4877.
+ */
+import type { Visitor, NodePath } from '@babel/traverse';
+import type * as t from '@babel/types';
+import { getLine } from '../utils/location.js';
+import { PropertyAccessVisitor } from '../visitors/index.js';
+import type { PropertyAccessInfo, CounterRef } from '../types.js';
+import { FunctionBodyHandler } from './FunctionBodyHandler.js';
+
+export class PropertyAccessHandler extends FunctionBodyHandler {
+  getHandlers(): Visitor {
+    const ctx = this.ctx;
+    const analyzer = this.analyzer;
+
+    return {
+      UpdateExpression: (updatePath: NodePath<t.UpdateExpression>) => {
+        const updateNode = updatePath.node;
+
+        // REG-288/REG-312: Collect update expression info for graph building
+        analyzer.collectUpdateExpression(updateNode, ctx.module, ctx.updateExpressions, ctx.getCurrentScopeId(), ctx.scopeTracker);
+
+        // Legacy behavior: update scope.modifies for IDENTIFIER targets
+        if (updateNode.argument.type === 'Identifier') {
+          const varName = updateNode.argument.name;
+
+          // Find variable by name - could be from parent scope or declarations
+          const fromParentScope = Array.from(ctx.parentScopeVariables).find(v => v.name === varName);
+          const fromDeclarations = ctx.variableDeclarations.find(v => v.name === varName);
+          const variable = fromParentScope ?? fromDeclarations;
+
+          if (variable) {
+            const scope = ctx.scopes.find(s => s.id === ctx.parentScopeId);
+            if (scope) {
+              if (!scope.modifies) scope.modifies = [];
+              scope.modifies.push({
+                variableId: variable.id,
+                variableName: varName,
+                line: getLine(updateNode)
+              });
+            }
+          }
+        }
+      },
+
+      // Property access expressions (REG-395)
+      // Shared handler for both MemberExpression and OptionalMemberExpression
+      MemberExpression: (memberPath: NodePath<t.MemberExpression>) => {
+        // Initialize collections if needed
+        if (!ctx.collections.propertyAccesses) {
+          ctx.collections.propertyAccesses = [];
+        }
+        if (!ctx.collections.propertyAccessCounterRef) {
+          ctx.collections.propertyAccessCounterRef = { value: 0 };
+        }
+
+        PropertyAccessVisitor.extractPropertyAccesses(
+          memberPath,
+          memberPath.node,
+          ctx.module,
+          ctx.collections.propertyAccesses as PropertyAccessInfo[],
+          ctx.collections.propertyAccessCounterRef as CounterRef,
+          ctx.scopeTracker,
+          ctx.currentFunctionId || ctx.getCurrentScopeId()
+        );
+      },
+      // OptionalMemberExpression: obj?.prop (same logic as MemberExpression)
+      OptionalMemberExpression: (memberPath: NodePath) => {
+        // Initialize collections if needed
+        if (!ctx.collections.propertyAccesses) {
+          ctx.collections.propertyAccesses = [];
+        }
+        if (!ctx.collections.propertyAccessCounterRef) {
+          ctx.collections.propertyAccessCounterRef = { value: 0 };
+        }
+
+        PropertyAccessVisitor.extractPropertyAccesses(
+          memberPath,
+          memberPath.node as t.MemberExpression,
+          ctx.module,
+          ctx.collections.propertyAccesses as PropertyAccessInfo[],
+          ctx.collections.propertyAccessCounterRef as CounterRef,
+          ctx.scopeTracker,
+          ctx.currentFunctionId || ctx.getCurrentScopeId()
+        );
+      },
+      // MetaProperty: new.target (REG-301)
+      MetaProperty: (metaPath: NodePath<t.MetaProperty>) => {
+        // Initialize collections if needed
+        if (!ctx.collections.propertyAccesses) {
+          ctx.collections.propertyAccesses = [];
+        }
+        if (!ctx.collections.propertyAccessCounterRef) {
+          ctx.collections.propertyAccessCounterRef = { value: 0 };
+        }
+
+        PropertyAccessVisitor.extractMetaProperty(
+          metaPath.node,
+          ctx.module,
+          ctx.collections.propertyAccesses as PropertyAccessInfo[],
+          ctx.collections.propertyAccessCounterRef as CounterRef,
+          ctx.scopeTracker,
+          ctx.currentFunctionId || ctx.getCurrentScopeId()
+        );
+      },
+    };
+  }
+}

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

@@ -0,0 +1,166 @@
+/**
+ * ReturnYieldHandler — handles ReturnStatement and YieldExpression nodes.
+ *
+ * Mechanical extraction from analyzeFunctionBody() (REG-422).
+ * Original source: JSASTAnalyzer.ts lines ~3835-4061.
+ */
+import type { Visitor, NodePath } from '@babel/traverse';
+import * as t from '@babel/types';
+import { getLine, getColumn } from '../utils/location.js';
+import type { ReturnStatementInfo, YieldExpressionInfo } from '../types.js';
+import { FunctionBodyHandler } from './FunctionBodyHandler.js';
+
+export class ReturnYieldHandler extends FunctionBodyHandler {
+  getHandlers(): Visitor {
+    const ctx = this.ctx;
+    const analyzer = this.analyzer;
+
+    return {
+      // Handle return statements for RETURNS edges
+      ReturnStatement: (returnPath: NodePath<t.ReturnStatement>) => {
+        // Skip if we couldn't determine the function ID
+        if (!ctx.currentFunctionId) {
+          return;
+        }
+
+        // Skip if this return is inside a nested function (not the function we're analyzing)
+        // Check if there's a function ancestor BETWEEN us and funcNode
+        // Stop checking once we reach funcNode - parents above funcNode are outside scope
+        let parent: NodePath | null = returnPath.parentPath;
+        let isInsideConditional = false;
+        while (parent) {
+          // If we've reached funcNode, we're done checking - this return belongs to funcNode
+          if (parent.node === ctx.funcNode) {
+            break;
+          }
+          if (t.isFunction(parent.node)) {
+            // Found a function between returnPath and funcNode - this return is inside a nested function
+            return;
+          }
+          // Track if return is inside a conditional block (if/else, switch case, loop, try/catch)
+          if (t.isIfStatement(parent.node) ||
+              t.isSwitchCase(parent.node) ||
+              t.isLoop(parent.node) ||
+              t.isTryStatement(parent.node) ||
+              t.isCatchClause(parent.node)) {
+            isInsideConditional = true;
+          }
+          parent = parent.parentPath;
+        }
+
+        // Phase 6 (REG-267): Track return count and early return detection
+        ctx.controlFlowState.returnCount++;
+
+        // A return is "early" if it's inside a conditional structure
+        // (More returns after this one indicate the function doesn't always end here)
+        if (isInsideConditional) {
+          ctx.controlFlowState.hasEarlyReturn = true;
+        }
+
+        const returnNode = returnPath.node;
+        const returnLine = getLine(returnNode);
+        const returnColumn = getColumn(returnNode);
+
+        // Handle bare return; (no value)
+        if (!returnNode.argument) {
+          // Skip - no data flow value
+          return;
+        }
+
+        const arg = returnNode.argument;
+
+        // Extract expression-specific info using shared method
+        const exprInfo = analyzer.extractReturnExpressionInfo(
+          arg, ctx.module, ctx.literals, ctx.literalCounterRef, returnLine, returnColumn, 'return'
+        );
+
+        const returnInfo: ReturnStatementInfo = {
+          parentFunctionId: ctx.currentFunctionId,
+          file: ctx.module.file,
+          line: returnLine,
+          column: returnColumn,
+          returnValueType: 'NONE',
+          ...exprInfo,
+        };
+
+        ctx.returnStatements.push(returnInfo);
+      },
+
+      // Handle yield expressions for YIELDS/DELEGATES_TO edges (REG-270)
+      YieldExpression: (yieldPath: NodePath<t.YieldExpression>) => {
+        // Skip if we couldn't determine the function ID
+        if (!ctx.currentFunctionId) {
+          return;
+        }
+
+        // Skip if this yield is inside a nested function (not the function we're analyzing)
+        // Check if there's a function ancestor BETWEEN us and funcNode
+        let parent: NodePath | null = yieldPath.parentPath;
+        while (parent) {
+          // If we've reached funcNode, we're done checking - this yield belongs to funcNode
+          if (parent.node === ctx.funcNode) {
+            break;
+          }
+          if (t.isFunction(parent.node)) {
+            // Found a function between yieldPath and funcNode - this yield is inside a nested function
+            return;
+          }
+          parent = parent.parentPath;
+        }
+
+        const yieldNode = yieldPath.node;
+        const yieldLine = getLine(yieldNode);
+        const yieldColumn = getColumn(yieldNode);
+        const isDelegate = yieldNode.delegate ?? false;
+
+        // Handle bare yield; (no value) - only valid for non-delegate yield
+        if (!yieldNode.argument && !isDelegate) {
+          // Skip - no data flow value
+          return;
+        }
+
+        // For yield* without argument (syntax error in practice, but handle gracefully)
+        if (!yieldNode.argument) {
+          return;
+        }
+
+        const arg = yieldNode.argument;
+
+        // Extract expression-specific info using shared method
+        // Note: We reuse extractReturnExpressionInfo since yield values have identical semantics
+        const exprInfo = analyzer.extractReturnExpressionInfo(
+          arg, ctx.module, ctx.literals, ctx.literalCounterRef, yieldLine, yieldColumn, 'yield'
+        );
+
+        // Map ReturnStatementInfo fields to YieldExpressionInfo fields
+        const yieldInfo: YieldExpressionInfo = {
+          parentFunctionId: ctx.currentFunctionId,
+          file: ctx.module.file,
+          line: yieldLine,
+          column: yieldColumn,
+          isDelegate,
+          yieldValueType: exprInfo.returnValueType ?? 'NONE',
+          yieldValueName: exprInfo.returnValueName,
+          yieldValueId: exprInfo.returnValueId,
+          yieldValueLine: exprInfo.returnValueLine,
+          yieldValueColumn: exprInfo.returnValueColumn,
+          yieldValueCallName: exprInfo.returnValueCallName,
+          expressionType: exprInfo.expressionType,
+          operator: exprInfo.operator,
+          leftSourceName: exprInfo.leftSourceName,
+          rightSourceName: exprInfo.rightSourceName,
+          consequentSourceName: exprInfo.consequentSourceName,
+          alternateSourceName: exprInfo.alternateSourceName,
+          object: exprInfo.object,
+          property: exprInfo.property,
+          computed: exprInfo.computed,
+          objectSourceName: exprInfo.objectSourceName,
+          expressionSourceNames: exprInfo.expressionSourceNames,
+          unaryArgSourceName: exprInfo.unaryArgSourceName,
+        };
+
+        ctx.yieldExpressions.push(yieldInfo);
+      },
+    };
+  }
+}