@codeyam/codeyam-cli 0.1.0-bleeding-edge.8afd3ee

package/packages/ai/src/lib/astScopes/processExpression.js

@@ -0,0 +1,1485 @@
+import ts from 'typescript';
+import { StructuredPath } from "./paths.js";
+import { nodeToSource } from "./nodeToSource.js";
+import { methodRegistry } from "./methodSemantics.js";
+import { isArithmeticOperator, isAssignmentOperator, isBitwiseCompoundOperator, isComparisonOperator, isDefinedType, isNumericCompoundOperator, leftOrRightType, unwrapExpression, } from "./sharedPatterns.js";
+import { processBindingPattern } from "./processBindings.js";
+/**
+ * Marks variables used in truthiness checks as potentially undefined.
+ * When code checks `if (x)` or `x && ...`, it indicates x might be falsy (null/undefined).
+ * This function walks through the condition and adds | undefined to such variables.
+ */
+export function markConditionVariablesAsNullable(condition, context) {
+    const unwrapped = unwrapExpression(condition);
+    // For binary expressions with &&, mark both sides as nullable if they're truthiness checks
+    // Example: `diffView && <Component />` means diffView might be undefined
+    // Example: `a && b && <Component />` means both a and b might be undefined
+    if (ts.isBinaryExpression(unwrapped) &&
+        unwrapped.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken) {
+        // Recursively mark left side
+        markConditionVariablesAsNullable(unwrapped.left, context);
+        // Mark right side if it's also a truthiness check (not JSX or other consequences)
+        const rightUnwrapped = unwrapExpression(unwrapped.right);
+        // Check if right side is JSX or contains JSX
+        const isJsxConsequence = ts.isJsxElement(rightUnwrapped) ||
+            ts.isJsxSelfClosingElement(rightUnwrapped) ||
+            ts.isJsxFragment(rightUnwrapped);
+        if (!isJsxConsequence) {
+            // This handles chains like `a && b && ...` where both a and b are checks
+            markConditionVariablesAsNullable(unwrapped.right, context);
+        }
+        return;
+    }
+    // Don't mark variables in comparison operators as nullable
+    // Example: `if (x === 5)` doesn't mean x might be undefined
+    if (ts.isBinaryExpression(unwrapped) &&
+        isComparisonOperator(unwrapped.operatorToken.kind)) {
+        return;
+    }
+    // For simple identifiers or property accesses, mark as potentially undefined
+    const path = StructuredPath.fromNode(unwrapped, context.sourceFile);
+    if (path) {
+        const currentType = context.getTypeInfo(path) || 'unknown';
+        // Only add | undefined if it's not already there
+        if (!currentType.includes('undefined')) {
+            context.addType(path, `${currentType} | undefined`);
+        }
+    }
+}
+/**
+ * Extracts conditional usages from a condition expression for key attribute detection.
+ * This function identifies which attributes are used in conditionals and how they're used.
+ *
+ * @param condition The condition expression to analyze
+ * @param context The analysis context
+ * @param location Where this condition appears (if, ternary, logical-and, switch)
+ */
+export function extractConditionalUsage(condition, context, location) {
+    const unwrapped = unwrapExpression(condition);
+    // Handle binary expressions with && (logical AND chains)
+    // Example: `a && b && <Component />` - both a and b are conditional checks
+    if (ts.isBinaryExpression(unwrapped) &&
+        unwrapped.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken) {
+        // Recursively process left side
+        extractConditionalUsage(unwrapped.left, context, location);
+        // Process right side if it's not JSX (JSX is the consequence, not the condition)
+        const rightUnwrapped = unwrapExpression(unwrapped.right);
+        const isJsxConsequence = ts.isJsxElement(rightUnwrapped) ||
+            ts.isJsxSelfClosingElement(rightUnwrapped) ||
+            ts.isJsxFragment(rightUnwrapped);
+        if (!isJsxConsequence) {
+            extractConditionalUsage(unwrapped.right, context, location);
+        }
+        return;
+    }
+    // Handle binary expressions with || (logical OR)
+    if (ts.isBinaryExpression(unwrapped) &&
+        unwrapped.operatorToken.kind === ts.SyntaxKind.BarBarToken) {
+        // Both sides of || are conditional checks
+        extractConditionalUsage(unwrapped.left, context, location);
+        extractConditionalUsage(unwrapped.right, context, location);
+        return;
+    }
+    // Handle comparison operators (===, !==, <, >, <=, >=)
+    // Example: `if (status === 'active')` - status is compared against 'active'
+    if (ts.isBinaryExpression(unwrapped) &&
+        isComparisonOperator(unwrapped.operatorToken.kind)) {
+        // Try to extract the variable and the compared value
+        const leftPath = StructuredPath.fromNode(unwrapped.left, context.sourceFile);
+        const rightPath = StructuredPath.fromNode(unwrapped.right, context.sourceFile);
+        // Check if left is a variable and right is a literal
+        if (leftPath && isLiteralExpression(unwrapped.right)) {
+            const literalValue = getLiteralValue(unwrapped.right, context);
+            context.addConditionalUsage({
+                path: leftPath.toLeftHandSideString(),
+                conditionType: 'comparison',
+                comparedValues: literalValue !== undefined ? [literalValue] : undefined,
+                location,
+            });
+            return;
+        }
+        // Check if right is a variable and left is a literal
+        if (rightPath && isLiteralExpression(unwrapped.left)) {
+            const literalValue = getLiteralValue(unwrapped.left, context);
+            context.addConditionalUsage({
+                path: rightPath.toLeftHandSideString(),
+                conditionType: 'comparison',
+                comparedValues: literalValue !== undefined ? [literalValue] : undefined,
+                location,
+            });
+            return;
+        }
+        // Both sides are variables - record both as comparisons without specific values
+        if (leftPath) {
+            context.addConditionalUsage({
+                path: leftPath.toLeftHandSideString(),
+                conditionType: 'comparison',
+                location,
+            });
+        }
+        if (rightPath) {
+            context.addConditionalUsage({
+                path: rightPath.toLeftHandSideString(),
+                conditionType: 'comparison',
+                location,
+            });
+        }
+        return;
+    }
+    // Handle prefix unary NOT expression: !variable
+    // Example: `if (!isVisible)` - isVisible is a truthiness check
+    if (ts.isPrefixUnaryExpression(unwrapped) &&
+        unwrapped.operator === ts.SyntaxKind.ExclamationToken) {
+        extractConditionalUsage(unwrapped.operand, context, location);
+        return;
+    }
+    // Handle simple identifiers or property accesses (truthiness checks)
+    // Example: `if (x)` or `x && <JSX />` - x is checked for truthiness
+    const path = StructuredPath.fromNode(unwrapped, context.sourceFile);
+    if (path && !path.isLiteral()) {
+        context.addConditionalUsage({
+            path: path.toLeftHandSideString(),
+            conditionType: 'truthiness',
+            location,
+        });
+    }
+}
+/**
+ * Helper to check if an expression is a literal value
+ */
+function isLiteralExpression(expr) {
+    const unwrapped = unwrapExpression(expr);
+    return (ts.isStringLiteral(unwrapped) ||
+        ts.isNumericLiteral(unwrapped) ||
+        ts.isNoSubstitutionTemplateLiteral(unwrapped) ||
+        unwrapped.kind === ts.SyntaxKind.TrueKeyword ||
+        unwrapped.kind === ts.SyntaxKind.FalseKeyword ||
+        unwrapped.kind === ts.SyntaxKind.NullKeyword ||
+        unwrapped.kind === ts.SyntaxKind.UndefinedKeyword ||
+        unwrapped.kind === ts.SyntaxKind.ThisKeyword);
+}
+/**
+ * Helper to get the string representation of a literal value
+ */
+function getLiteralValue(expr, context) {
+    const unwrapped = unwrapExpression(expr);
+    if (ts.isStringLiteral(unwrapped) ||
+        ts.isNoSubstitutionTemplateLiteral(unwrapped)) {
+        return unwrapped.text;
+    }
+    if (ts.isNumericLiteral(unwrapped)) {
+        return unwrapped.text;
+    }
+    if (unwrapped.kind === ts.SyntaxKind.TrueKeyword) {
+        return 'true';
+    }
+    if (unwrapped.kind === ts.SyntaxKind.FalseKeyword) {
+        return 'false';
+    }
+    if (unwrapped.kind === ts.SyntaxKind.NullKeyword) {
+        return 'null';
+    }
+    if (unwrapped.kind === ts.SyntaxKind.UndefinedKeyword) {
+        return 'undefined';
+    }
+    if (unwrapped.kind === ts.SyntaxKind.ThisKeyword) {
+        return 'this';
+    }
+    return undefined;
+}
+/**
+ * Processes an expression node recursively, establishing equivalences and types
+ * in the analysis context as side effects.
+ *
+ * This is the core function for centralized expression analysis, which handles all
+ * expression types and registers appropriate relationships and types in the context.
+ *
+ * @param node The expression node to process.
+ * @param context The analysis context.
+ * @param targetPath The base path to which this expression's value should be related.
+ *        For example, for a variable declaration `const x = y`, the targetPath would be
+ *        StructuredPath.fromBase('x'). For a return statement `return expr`, the targetPath
+ *        would be StructuredPath.fromBase('returnValue').
+ *
+ *        When targetPath is provided, this function will establish all appropriate equivalences
+ *        and register types for targetPath. When omitted (typically for sub-expressions in
+ *        recursive calls), the function will operate without establishing external relationships.
+ *
+ * @returns true if the expression was processed successfully, false otherwise.
+ */
+export function processExpression({ node, context, targetPath, typeHint, }) {
+    let inferredNodeType = context.inferTypeFromNode(node);
+    if (inferredNodeType === 'unknown' && typeHint) {
+        inferredNodeType = typeHint;
+    }
+    const unwrappedNode = unwrapExpression(node);
+    // IMPORTANT: Mark nullable variables BEFORE checking child boundaries
+    // JSX expressions like {showLogsForEntity && projectSlug && (<Component />)} are child boundaries,
+    // but we still need to mark the variables as potentially undefined
+    if (ts.isBinaryExpression(unwrappedNode) &&
+        unwrappedNode.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken) {
+        markConditionVariablesAsNullable(unwrappedNode, context);
+        // Extract conditional usages for key attribute detection
+        extractConditionalUsage(unwrappedNode, context, 'logical-and');
+    }
+    // If the node falls within an excluded child scope, stop processing it.
+    if (context.isChildBoundary(node)) {
+        return true;
+    }
+    // Create a path for this node
+    let nodePath = null;
+    // if (unwrappedNode.kind === ts.SyntaxKind.Identifier) {
+    //   console.warn(
+    //     `Got IDENTIFIER and ts.isIdentifier = ${ts.isIdentifier(unwrappedNode)}`,
+    //     unwrappedNode.getText(context.sourceFile),
+    //   );
+    // }
+    // Handle simple cases directly
+    if (ts.isIdentifier(unwrappedNode)) {
+        nodePath = StructuredPath.fromBase(unwrappedNode.text);
+        // If targetPath is provided, establish equivalence and register type
+        if (targetPath) {
+            context.addEquivalence(targetPath, nodePath);
+            context.addType(targetPath, inferredNodeType);
+        }
+        context.addType(nodePath, inferredNodeType);
+        return true;
+    }
+    if (ts.isStringLiteral(unwrappedNode) ||
+        ts.isNoSubstitutionTemplateLiteral(unwrappedNode)) {
+        nodePath = StructuredPath.createLiteralPath(unwrappedNode.getText(context.sourceFile), 'string');
+        if (targetPath) {
+            context.addEquivalence(targetPath, nodePath);
+            context.addType(targetPath, 'string');
+        }
+        return true;
+    }
+    if (ts.isNumericLiteral(unwrappedNode)) {
+        nodePath = StructuredPath.createLiteralPath(unwrappedNode.text, 'number');
+        if (targetPath) {
+            context.addEquivalence(targetPath, nodePath);
+            context.addType(targetPath, 'number');
+        }
+        return true;
+    }
+    if (unwrappedNode.kind === ts.SyntaxKind.TrueKeyword ||
+        unwrappedNode.kind === ts.SyntaxKind.FalseKeyword) {
+        const value = unwrappedNode.kind === ts.SyntaxKind.TrueKeyword ? 'true' : 'false';
+        nodePath = StructuredPath.createLiteralPath(value, 'boolean');
+        if (targetPath) {
+            context.addEquivalence(targetPath, nodePath);
+            context.addType(targetPath, 'boolean');
+        }
+        return true;
+    }
+    if (unwrappedNode.kind === ts.SyntaxKind.NullKeyword) {
+        nodePath = StructuredPath.createLiteralPath('null', 'null');
+        if (targetPath) {
+            context.addEquivalence(targetPath, nodePath);
+            context.addType(targetPath, 'null');
+        }
+        return true;
+    }
+    if (unwrappedNode.kind === ts.SyntaxKind.UndefinedKeyword) {
+        nodePath = StructuredPath.createLiteralPath('undefined', 'undefined');
+        if (targetPath) {
+            context.addEquivalence(targetPath, nodePath);
+            context.addType(targetPath, 'undefined');
+        }
+        return true;
+    }
+    if (ts.isThisTypeNode(unwrappedNode) ||
+        unwrappedNode.kind === ts.SyntaxKind.ThisKeyword) {
+        nodePath = StructuredPath.createLiteralPath('this', 'object');
+        if (targetPath) {
+            context.addEquivalence(targetPath, nodePath);
+            context.addType(targetPath, 'object');
+        }
+        return true;
+    }
+    // Handle Property Access: obj.prop
+    if (ts.isPropertyAccessExpression(unwrappedNode)) {
+        // Process the object part recursively (without targetPath)
+        const objectProcessed = processExpression({
+            node: unwrappedNode.expression,
+            context,
+        });
+        if (!objectProcessed) {
+            // If we couldn't process the object part, we can't process the property access
+            // console.warn(
+            //   `processExpression: Unsupported object part: ${unwrappedNode.expression.getText(context.sourceFile)}`,
+            //   ts.isIdentifier(unwrappedNode.expression),
+            // );
+            context.markUnsupported(unwrappedNode.expression, `processExpression: Unsupported base expression for property access: ${ts.SyntaxKind[unwrappedNode.expression.kind]}`, false);
+            return false;
+        }
+        // Get a proper path for the object
+        const objectPath = StructuredPath.fromNode(unwrappedNode.expression, context.sourceFile);
+        if (!objectPath) {
+            context.markUnsupported(unwrappedNode.expression, `processExpression: Couldn't get path for property access base: ${ts.SyntaxKind[unwrappedNode.expression.kind]}`, false);
+            return false;
+        }
+        // Create the property access path
+        const propertyPath = objectPath.withProperty(unwrappedNode.name.text);
+        // Check if this is an environment variable access
+        const fullText = unwrappedNode.getText(context.sourceFile);
+        if (fullText.includes('.env.') // simple heuristic for env var access but not great
+        ) {
+            context.addEnvironmentVariable(fullText);
+        }
+        // Infer and register type for the property
+        context.addType(propertyPath, inferredNodeType);
+        // If targetPath is provided, establish equivalence and propagate type
+        if (targetPath) {
+            context.addEquivalence(targetPath, propertyPath);
+            context.addType(targetPath, inferredNodeType);
+        }
+        return true;
+    }
+    // Handle Binary Expressions: a + b, x === y, etc.
+    if (ts.isBinaryExpression(unwrappedNode)) {
+        // Check if it's an assignment first, as BinaryExpression includes assignments
+        if (isAssignmentOperator(unwrappedNode.operatorToken.kind)) {
+            // Check for destructuring assignment first
+            if ((ts.isObjectBindingPattern(unwrappedNode.left) ||
+                ts.isArrayBindingPattern(unwrappedNode.left)) &&
+                unwrappedNode.operatorToken.kind === ts.SyntaxKind.EqualsToken) {
+                // For destructuring assignment, we first need to process the right side
+                const rightSideProcessed = processExpression({
+                    node: unwrappedNode.right,
+                    context,
+                });
+                if (!rightSideProcessed) {
+                    context.markUnsupported(unwrappedNode.right, `processExpression: Unsupported right side of destructuring assignment: ${ts.SyntaxKind[unwrappedNode.right.kind]}`, false);
+                    return false;
+                }
+                // Get the right side path
+                const rightSidePath = StructuredPath.fromNode(unwrappedNode.right, context.sourceFile);
+                if (!rightSidePath) {
+                    context.markUnsupported(unwrappedNode.right, `processExpression: Couldn't get path for right side of destructuring assignment`, false);
+                    return false;
+                }
+                // Process the binding pattern with the right side as source
+                const success = processBindingPattern(unwrappedNode.left, rightSidePath, context);
+                // If targetPath was provided, establish equivalence to the right side
+                // This is useful when the destructuring assignment is itself part of a larger expression
+                if (targetPath) {
+                    context.addEquivalence(targetPath, rightSidePath);
+                    context.inferAndAddType(targetPath, unwrappedNode.right);
+                }
+                return success;
+            }
+            // Regular non-destructuring assignment
+            else {
+                // Process the left side to ensure it's analyzed and to get its path
+                const leftSideProcessed = processExpression({
+                    node: unwrappedNode.left,
+                    context,
+                });
+                if (!leftSideProcessed) {
+                    context.markUnsupported(unwrappedNode.left, `processExpression: Unsupported left side of assignment: ${ts.SyntaxKind[unwrappedNode.left.kind]}`, false);
+                    return false; // Cannot process assignment without successful LHS processing
+                }
+                // Get the structured path for the left side
+                const leftSidePath = StructuredPath.fromNode(unwrappedNode.left, context.sourceFile);
+                if (!leftSidePath) {
+                    context.markUnsupported(unwrappedNode.left, `processExpression: Couldn't get path for left side of assignment: ${ts.SyntaxKind[unwrappedNode.left.kind]}`, false);
+                    return false;
+                }
+                // Handle simple assignment (=)
+                if (unwrappedNode.operatorToken.kind === ts.SyntaxKind.EqualsToken) {
+                    // Process the right side
+                    const rightSideProcessed = processExpression({
+                        node: unwrappedNode.right,
+                        context,
+                        targetPath: leftSidePath, // Pass leftSidePath as targetPath
+                    });
+                    if (!rightSideProcessed) {
+                        context.addType(leftSidePath, 'unknown');
+                        context.markUnsupported(unwrappedNode.right, `processExpression: Unsupported right side of assignment: ${ts.SyntaxKind[unwrappedNode.right.kind]}`, false);
+                        return false;
+                    }
+                    if (ts.isObjectLiteralExpression(unwrappedNode.right)) {
+                        // Just add object type - property equivalences were set up during processing
+                        context.addType(leftSidePath, 'object');
+                    }
+                    // If targetPath was provided to us, establish equivalence
+                    if (targetPath) {
+                        context.addEquivalence(targetPath, leftSidePath);
+                        context.inferAndAddType(targetPath, unwrappedNode.right);
+                    }
+                    return true;
+                }
+                // Handle compound assignments (+=, -=, etc.)
+                else {
+                    // For compound assignments, we process the right side without targetPath
+                    const rightSideProcessed = processExpression({
+                        node: unwrappedNode.right,
+                        context,
+                    });
+                    if (!rightSideProcessed) {
+                        context.markUnsupported(unwrappedNode.right, `processExpression: Unsupported right side of compound assignment: ${ts.SyntaxKind[unwrappedNode.right.kind]}`, false);
+                        return false;
+                    }
+                    // Determine the result type based on operation
+                    const operatorKind = unwrappedNode.operatorToken.kind;
+                    let leftType = context.getTypeInfo(leftSidePath);
+                    if (leftType === 'unknown') {
+                        leftType = context.inferTypeFromNode(unwrappedNode.left);
+                    }
+                    const rightType = context.inferTypeFromNode(unwrappedNode.right);
+                    let resultType = 'unknown';
+                    if (operatorKind === ts.SyntaxKind.PlusEqualsToken) {
+                        // plus operator is special - it can be string or number
+                        resultType =
+                            leftType === 'string' || rightType === 'string'
+                                ? 'string'
+                                : 'number';
+                    }
+                    else if (isNumericCompoundOperator(operatorKind)) {
+                        resultType = 'number';
+                    }
+                    else if (isBitwiseCompoundOperator(operatorKind)) {
+                        resultType = 'number';
+                    }
+                    else if (operatorKind === ts.SyntaxKind.AmpersandAmpersandEqualsToken) {
+                        resultType = 'boolean';
+                    }
+                    else if (operatorKind === ts.SyntaxKind.BarBarEqualsToken ||
+                        operatorKind === ts.SyntaxKind.QuestionQuestionEqualsToken) {
+                        resultType = leftOrRightType(leftType, rightType) ?? 'unknown';
+                    }
+                    else {
+                        context.markUnsupported(unwrappedNode, `processExpression: Unsupported compound assignment operator: ${ts.SyntaxKind[operatorKind]}`, false);
+                    }
+                    // Update the type of the left side
+                    context.addType(leftSidePath, resultType);
+                    context.addEquivalence(leftSidePath, StructuredPath.fromNode(unwrappedNode.right, context.sourceFile));
+                    // If targetPath was provided, establish equivalence
+                    if (targetPath) {
+                        context.addEquivalence(targetPath, leftSidePath);
+                        context.addType(targetPath, resultType);
+                    }
+                    return true;
+                }
+            }
+        }
+        // Non-assignment binary expressions (logical, arithmetic, comparison, etc.)
+        else {
+            // Process both sides for their side effects (without targetPath)
+            processExpression({ node: unwrappedNode.left, context });
+            processExpression({ node: unwrappedNode.right, context });
+            // Determine the type of the result
+            const operatorKind = unwrappedNode.operatorToken.kind;
+            let resultPath = null;
+            let resultType = 'unknown';
+            // Type Inference Logic
+            if (isComparisonOperator(operatorKind)) {
+                resultType = 'boolean';
+                // Type narrowing: if comparing a call expression with unknown return type
+                // to a value of known type, narrow the return type
+                const leftType = context.inferTypeFromNode(unwrappedNode.left);
+                const rightType = context.inferTypeFromNode(unwrappedNode.right);
+                // Check if left side is a call expression with unknown return type
+                if (ts.isCallExpression(unwrappedNode.left) &&
+                    leftType === 'unknown' &&
+                    rightType !== 'unknown') {
+                    const leftPath = StructuredPath.fromNode(unwrappedNode.left, context.sourceFile);
+                    if (leftPath) {
+                        const returnValuePath = leftPath.withProperty('functionCallReturnValue');
+                        context.addType(returnValuePath, `${rightType} | unknown`);
+                    }
+                }
+                // Check if right side is a call expression with unknown return type
+                else if (ts.isCallExpression(unwrappedNode.right) &&
+                    rightType === 'unknown' &&
+                    leftType !== 'unknown') {
+                    const rightPath = StructuredPath.fromNode(unwrappedNode.right, context.sourceFile);
+                    if (rightPath) {
+                        const returnValuePath = rightPath.withProperty('functionCallReturnValue');
+                        context.addType(returnValuePath, `${leftType} | unknown`);
+                    }
+                }
+            }
+            else if (isArithmeticOperator(operatorKind)) {
+                // For plus operator, check if either operand is a string
+                if (operatorKind === ts.SyntaxKind.PlusToken) {
+                    const leftType = context.inferTypeFromNode(unwrappedNode.left);
+                    const rightType = context.inferTypeFromNode(unwrappedNode.right);
+                    if (leftType === 'string' || rightType === 'string') {
+                        resultType = 'string';
+                    }
+                    else {
+                        resultType = 'number';
+                    }
+                }
+                else {
+                    // All other arithmetic operators result in numbers
+                    resultType = 'number';
+                }
+            }
+            else if (operatorKind === ts.SyntaxKind.AmpersandAmpersandToken) {
+                // Logical AND typically results in a boolean
+                resultType = 'boolean';
+                // Mark the left operand as potentially undefined since it's being checked for truthiness
+                markConditionVariablesAsNullable(unwrappedNode.left, context);
+            }
+            else if (operatorKind === ts.SyntaxKind.BarBarToken || // Logical OR
+                operatorKind === ts.SyntaxKind.QuestionQuestionToken // Nullish Coalescing
+            ) {
+                // For || and ??, the result type depends on the operands
+                const leftType = context.inferTypeFromNode(unwrappedNode.left);
+                const rightType = context.inferTypeFromNode(unwrappedNode.right);
+                // For ||, if either side is boolean, result is boolean
+                if (operatorKind === ts.SyntaxKind.BarBarToken &&
+                    (leftType === 'boolean' || rightType === 'boolean')) {
+                    resultType = 'boolean';
+                }
+                // Otherwise, for both || and ??, we use the first defined type
+                else if (isDefinedType(leftType)) {
+                    resultType = leftType;
+                }
+                else {
+                    resultType = rightType || 'unknown';
+                }
+                if (operatorKind === ts.SyntaxKind.QuestionQuestionToken) {
+                    // specifically for ?? we create an equivalence to the left side
+                    if (targetPath) {
+                        resultPath = StructuredPath.fromNode(unwrappedNode.left, context.sourceFile);
+                    }
+                    else {
+                        // if the expression is the target capture that the two sides are equivalent (e.g. (x ?? y).map())
+                        targetPath = StructuredPath.fromNode(unwrappedNode, context.sourceFile);
+                        resultPath = StructuredPath.fromNode(unwrappedNode.left, context.sourceFile);
+                    }
+                }
+            }
+            else if (operatorKind === ts.SyntaxKind.InstanceOfKeyword) {
+                resultType = 'boolean';
+            }
+            else {
+                // Fallback for other operators
+                resultType = inferredNodeType;
+                context.markUnsupported(unwrappedNode, `processExpression: Unsupported binary operator: ${ts.SyntaxKind[operatorKind]}`, false);
+            }
+            // Get a canonical representation for the entire binary expression
+            resultPath ?? (resultPath = nodeToSource(unwrappedNode, context.sourceFile));
+            // Register the type for the expression
+            context.addType(resultPath, resultType);
+            // If targetPath is provided, establish equivalence and register type
+            if (targetPath) {
+                context.addEquivalence(targetPath, resultPath);
+                context.addType(targetPath, resultType);
+            }
+            return true;
+        }
+    }
+    // Handle Call Expressions: func(), obj.method(), func()() etc.
+    if (ts.isCallExpression(unwrappedNode)) {
+        // 1. Process the expression being called (e.g., 'func', 'obj.method')
+        const calledExprProcessed = processExpression({
+            node: unwrappedNode.expression,
+            context,
+        });
+        if (!calledExprProcessed) {
+            context.markUnsupported(unwrappedNode.expression, `processExpression: Unsupported expression being called: ${ts.SyntaxKind[unwrappedNode.expression.kind]}`, false);
+            return false;
+        }
+        // Get a proper path for the called expression
+        const calledExprPath = StructuredPath.fromNode(unwrappedNode.expression, context.sourceFile);
+        if (!calledExprPath) {
+            context.markUnsupported(unwrappedNode.expression, `processExpression: Couldn't get path for called expression: ${ts.SyntaxKind[unwrappedNode.expression.kind]}`, false);
+            return false;
+        }
+        // Construct empty arguments list just to get the call path
+        // We'll process each argument with its parameter path as targetPath
+        const callPath = StructuredPath.fromNode(unwrappedNode, context.sourceFile);
+        // 2. Process all arguments recursively WITH targetPath for proper equivalence
+        for (let i = 0; i < unwrappedNode.arguments.length; i++) {
+            const arg = unwrappedNode.arguments[i];
+            const childBoundary = context.isChildBoundary(arg);
+            if (childBoundary) {
+                context.addChildBoundaryEquivalence(callPath.withParameter(i), arg);
+            }
+            // Process each argument with its parameter path as targetPath
+            // This automatically establishes all equivalences and types
+            processExpression({
+                node: arg,
+                context,
+                targetPath: callPath.withParameter(i), // Use parameter path as targetPath
+            });
+            // Special case for Object.keys, etc.
+            if (calledExprPath.base === 'Object' && i === 0) {
+                const argPath = StructuredPath.fromNode(arg, context.sourceFile);
+                if (argPath) {
+                    context.addType(argPath, 'object');
+                }
+            }
+        }
+        // 5. Handle Method Semantics and determine return type
+        let returnType = 'unknown';
+        let handledBySemantics = false;
+        // Check if it's a method call (PropertyAccess)
+        if (ts.isPropertyAccessExpression(unwrappedNode.expression)) {
+            const methodName = unwrappedNode.expression.name.text;
+            const semanticsList = methodRegistry.getByMethodName(methodName);
+            if (semanticsList && semanticsList.length > 0) {
+                const semantics = semanticsList[0];
+                // Get the source expression path (e.g., the object for obj.method())
+                const sourceExpr = unwrappedNode.expression.expression;
+                const sourcePath = StructuredPath.fromNode(sourceExpr, context.sourceFile);
+                if (sourcePath) {
+                    // Apply method semantics
+                    semantics.addEquivalences(callPath, sourcePath, context);
+                    returnType = semantics.getReturnType();
+                    handledBySemantics = true;
+                }
+            }
+        }
+        // Check if it's a method call via element access (obj['method']())
+        else if (ts.isElementAccessExpression(unwrappedNode.expression) &&
+            ts.isStringLiteral(unwrappedNode.expression.argumentExpression)) {
+            const methodName = unwrappedNode.expression.argumentExpression.text;
+            const semanticsList = methodRegistry.getByMethodName(methodName);
+            if (semanticsList && semanticsList.length > 0) {
+                const semantics = semanticsList[0];
+                // Get the source expression path
+                const sourceExpr = unwrappedNode.expression.expression;
+                const sourcePath = StructuredPath.fromNode(sourceExpr, context.sourceFile);
+                if (sourcePath) {
+                    // Apply method semantics
+                    semantics.addEquivalences(callPath, sourcePath, context);
+                    returnType = semantics.getReturnType();
+                    handledBySemantics = true;
+                }
+            }
+        }
+        // 7. Determine and Add Return Type
+        if (returnType === 'unknown') {
+            // If semantics didn't provide a type, try inferring
+            returnType = context.inferTypeFromNode(node);
+        }
+        // Register types
+        context.addType(callPath, 'function');
+        context.addType(calledExprPath, 'function');
+        // Only register the function call return value if:
+        // - It's not void, AND
+        // - Either the result is being used (targetPath exists) OR the return type is known (not 'unknown')
+        if (returnType !== 'void' && (targetPath || returnType !== 'unknown')) {
+            const returnValuePath = callPath.withProperty('functionCallReturnValue');
+            context.addType(returnValuePath, returnType);
+        }
+        // 8. If targetPath is provided, establish equivalence and register type
+        if (targetPath) {
+            context.addEquivalence(targetPath, callPath);
+            context.addType(targetPath, returnType);
+        }
+        return true;
+    }
+    // Handle Object Literals: { a: 1, b: x, ...spread }
+    if (ts.isObjectLiteralExpression(unwrappedNode)) {
+        // Create a path for the object literal itself
+        const literalSourcePath = StructuredPath.createLiteralPath(unwrappedNode.getText(context.sourceFile), 'object');
+        // If targetPath is provided, establish property relationships
+        // This is the main use case we're optimizing for
+        if (targetPath) {
+            // Process each property and establish relationships to the targetPath
+            for (const property of unwrappedNode.properties) {
+                if (ts.isPropertyAssignment(property)) {
+                    // Get property name
+                    let propName;
+                    if (ts.isIdentifier(property.name)) {
+                        propName = property.name.text;
+                    }
+                    else if (ts.isStringLiteral(property.name)) {
+                        propName = property.name.text;
+                    }
+                    else if (ts.isNumericLiteral(property.name)) {
+                        propName = property.name.text;
+                    }
+                    else if (ts.isComputedPropertyName(property.name)) {
+                        // Handle computed property names: { [x]: y }
+                        processExpression({ node: property.name.expression, context });
+                        const path = StructuredPath.fromNode(property.name.expression, context.sourceFile);
+                        propName = `*${path}*`;
+                    }
+                    else {
+                        // For other property name types, use text representation
+                        propName = property.name.getText(context.sourceFile);
+                        context.markSemanticLimitation(property.name, 'Complex property name might not be accurately represented.');
+                    }
+                    // Create a path for this property within the base
+                    const propPath = targetPath.withProperty(propName);
+                    // Process the property value with propPath as targetPath
+                    // This allows nested object literals to work correctly
+                    processExpression({
+                        node: property.initializer,
+                        context,
+                        targetPath: propPath,
+                    });
+                }
+                else if (ts.isShorthandPropertyAssignment(property)) {
+                    // Handle shorthand form: { x } is equivalent to { x: x }
+                    const propName = property.name.text;
+                    const propPath = targetPath.withProperty(propName);
+                    // Create a path for the identifier value
+                    const valuePath = StructuredPath.fromBase(propName);
+                    // Establish the equivalence and type
+                    context.addEquivalence(propPath, valuePath);
+                    const valueType = context.inferTypeFromNode(property.name);
+                    context.addType(propPath, valueType);
+                    context.addType(valuePath, valueType);
+                }
+                else if (ts.isSpreadAssignment(property)) {
+                    // Handle spread: { ...obj }
+                    // Process the spread expression first (without targetPath for now)
+                    processExpression({ node: property.expression, context });
+                    // Create a path for this spread source
+                    let spreadSourcePath = null;
+                    // Handle simple identifier spread: { ...obj }
+                    if (ts.isIdentifier(property.expression)) {
+                        spreadSourcePath = StructuredPath.fromBase(property.expression.text);
+                        // Establish equivalence between the target and the spread source
+                        context.addEquivalence(targetPath, spreadSourcePath);
+                        // and we kow obj is an object
+                        context.addType(spreadSourcePath, 'object');
+                    }
+                    // Handle property access spread: { ...obj.prop }
+                    else if (ts.isPropertyAccessExpression(property.expression)) {
+                        spreadSourcePath = StructuredPath.fromNode(property.expression, context.sourceFile);
+                        if (spreadSourcePath) {
+                            context.addEquivalence(targetPath, spreadSourcePath);
+                        }
+                    }
+                    // Handle other expression types
+                    else {
+                        // For complex expressions, use their source representation
+                        spreadSourcePath = nodeToSource(property.expression, context.sourceFile);
+                        if (spreadSourcePath) {
+                            context.addEquivalence(targetPath, spreadSourcePath);
+                        }
+                        // Mark semantic limitation only for complex spread expressions
+                        context.markSemanticLimitation(property, 'Complex spread assignment - individual properties not fully mapped.');
+                    }
+                }
+                else if (ts.isMethodDeclaration(property) ||
+                    ts.isGetAccessorDeclaration(property) ||
+                    ts.isSetAccessorDeclaration(property)) {
+                    // For methods and accessors, just mark the property as a function
+                    if (ts.isIdentifier(property.name)) {
+                        const propName = property.name.text;
+                        const propPath = targetPath.withProperty(propName);
+                        context.addType(propPath, 'function');
+                    }
+                    context.markUnsupported(property, `processExpression: Method/Accessor in object literal not fully processed: ${ts.SyntaxKind[property.kind]}`, false);
+                }
+            }
+            // Mark the targetPath as an object type
+            context.addType(targetPath, 'object');
+            return true;
+        }
+        else {
+            // No targetPath provided - just process each property for side effects
+            for (const property of unwrappedNode.properties) {
+                if (ts.isPropertyAssignment(property)) {
+                    processExpression({ node: property.initializer, context });
+                }
+                else if (ts.isShorthandPropertyAssignment(property)) {
+                    // For shorthand, establish type for the identifier
+                    const identPath = StructuredPath.fromBase(property.name.text);
+                    const idType = context.inferTypeFromNode(property.name);
+                    context.addType(identPath, idType);
+                }
+                else if (ts.isSpreadAssignment(property)) {
+                    // Still process the spread expression to ensure its contents are analyzed
+                    processExpression({ node: property.expression, context });
+                    // Even without a targetPath, we can still determine the type for the spread source
+                    if (ts.isIdentifier(property.expression)) {
+                        const spreadSource = StructuredPath.fromBase(property.expression.text);
+                        context.addType(spreadSource, 'object');
+                    }
+                    else if (ts.isPropertyAccessExpression(property.expression)) {
+                        const spreadSource = StructuredPath.fromNode(property.expression, context.sourceFile);
+                        if (spreadSource) {
+                            context.addType(spreadSource, 'object');
+                        }
+                    }
+                }
+                else if (ts.isMethodDeclaration(property) ||
+                    ts.isGetAccessorDeclaration(property) ||
+                    ts.isSetAccessorDeclaration(property)) {
+                    context.markUnsupported(property, `processExpression: Method/Accessor in object literal not fully processed: ${ts.SyntaxKind[property.kind]}`, false);
+                }
+            }
+            // If we have no targetPath but we're still analyzing an object literal,
+            // create a type registration for the literal itself
+            context.addType(literalSourcePath, 'object');
+            return true;
+        }
+    }
+    // Handle Array Literals: [1, x, func()]
+    if (ts.isArrayLiteralExpression(unwrappedNode)) {
+        // Create a path for the array literal
+        const arrayLiteralPath = StructuredPath.createLiteralPath(unwrappedNode.getText(context.sourceFile), 'array');
+        // Process each element recursively
+        for (let i = 0; i < unwrappedNode.elements.length; i++) {
+            const element = unwrappedNode.elements[i];
+            // If targetPath is provided, create element paths
+            if (targetPath) {
+                // Create path for this element (e.g., targetPath[0], targetPath[1])
+                const elementPath = targetPath.withElement(i);
+                // Process the element with elementPath as targetPath
+                processExpression({ node: element, context, targetPath: elementPath });
+            }
+            else {
+                // No targetPath, just process for side effects
+                processExpression({ node: element, context });
+            }
+        }
+        // Register type information
+        if (targetPath) {
+            context.addType(targetPath, 'array');
+        }
+        else {
+            context.addType(arrayLiteralPath, 'array');
+        }
+        return true;
+    }
+    // Handle Element Access: arr[0], obj[key], obj['prop']
+    if (ts.isElementAccessExpression(unwrappedNode)) {
+        // Process the object expression
+        const objectProcessed = processExpression({
+            node: unwrappedNode.expression,
+            context,
+        });
+        if (!objectProcessed) {
+            context.markUnsupported(unwrappedNode.expression, `processExpression: Unsupported base expression for element access: ${ts.SyntaxKind[unwrappedNode.expression.kind]}`, false);
+            return false;
+        }
+        // Get a path for the object
+        const objectPath = StructuredPath.fromNode(unwrappedNode.expression, context.sourceFile);
+        if (!objectPath) {
+            context.markUnsupported(unwrappedNode.expression, `processExpression: Couldn't get path for element access base: ${ts.SyntaxKind[unwrappedNode.expression.kind]}`, false);
+            return false;
+        }
+        // Process the argument expression
+        processExpression({ node: unwrappedNode.argumentExpression, context });
+        // Create the element access path based on argument type
+        let elementPath;
+        if (ts.isNumericLiteral(unwrappedNode.argumentExpression)) {
+            // Array index: arr[0]
+            elementPath = objectPath.withElement(parseInt(unwrappedNode.argumentExpression.text, 10));
+        }
+        else if (ts.isStringLiteral(unwrappedNode.argumentExpression)) {
+            // String key: obj['prop']
+            elementPath = objectPath.withProperty(unwrappedNode.argumentExpression.text);
+        }
+        else {
+            // Dynamic access: obj[key]
+            // Use a representation of the argument or fallback to wildcard
+            const argText = unwrappedNode.argumentExpression.getText(context.sourceFile);
+            elementPath = objectPath.withElement(argText || '*');
+        }
+        // Infer and register type
+        context.addType(elementPath, inferredNodeType);
+        // If targetPath is provided, establish equivalence and register type
+        if (targetPath) {
+            context.addEquivalence(targetPath, elementPath);
+            context.addType(targetPath, inferredNodeType);
+        }
+        return true;
+    }
+    // Handle Conditional Expression (Ternary): cond ? trueVal : falseVal
+    if (ts.isConditionalExpression(unwrappedNode)) {
+        // Mark variables in the condition as potentially undefined
+        markConditionVariablesAsNullable(unwrappedNode.condition, context);
+        // Extract conditional usages for key attribute detection
+        extractConditionalUsage(unwrappedNode.condition, context, 'ternary');
+        // Process all parts recursively
+        processExpression({
+            node: unwrappedNode.condition,
+            context,
+            typeHint: 'boolean | unknown',
+        }); //TODO: could we capture that this is evidence of a boolean type?
+        processExpression({ node: unwrappedNode.whenTrue, context });
+        processExpression({ node: unwrappedNode.whenFalse, context });
+        // Create a path for the whole expression
+        const expressionSourcePath = nodeToSource(unwrappedNode, context.sourceFile);
+        // Infer type based on branches
+        const trueType = context.inferTypeFromNode(unwrappedNode.whenTrue);
+        const falseType = context.inferTypeFromNode(unwrappedNode.whenFalse);
+        // Determine the result type
+        let resultType = leftOrRightType(falseType, trueType);
+        if (!resultType) {
+            // If we can't determine a specific type, use unknown without marking as semantic limitation
+            // This prevents conditional expressions from marking the analysis as incomplete
+            resultType = 'unknown';
+        }
+        // Register type for the expression
+        context.addType(expressionSourcePath, resultType);
+        // If targetPath is provided, establish equivalence and register type
+        if (targetPath) {
+            context.addEquivalence(targetPath, expressionSourcePath);
+            context.addType(targetPath, resultType);
+        }
+        return true;
+    }
+    // Handle New Expression: new Date(), new MyClass()
+    if (ts.isNewExpression(unwrappedNode)) {
+        // Process the constructor expression
+        const constructorProcessed = processExpression({
+            node: unwrappedNode.expression,
+            context,
+        });
+        if (!constructorProcessed) {
+            context.markUnsupported(unwrappedNode.expression, `processExpression: Unsupported constructor expression: ${ts.SyntaxKind[unwrappedNode.expression.kind]}`, false);
+            return false;
+        }
+        // Get a path for the constructor
+        const constructorPath = StructuredPath.fromNode(unwrappedNode.expression, context.sourceFile);
+        if (!constructorPath) {
+            return false;
+        }
+        // Process any arguments
+        if (unwrappedNode.arguments) {
+            for (const arg of unwrappedNode.arguments) {
+                processExpression({ node: arg, context });
+            }
+        }
+        // Create argument paths for the function call
+        const validArgPaths = unwrappedNode.arguments
+            ? unwrappedNode.arguments.map((arg) => StructuredPath.fromNode(arg, context.sourceFile) ??
+                nodeToSource(arg, context.sourceFile) ??
+                StructuredPath.literal('unknown'))
+            : [];
+        // Construct a path for the new expression
+        const newCallPath = constructorPath.withFunctionCall(validArgPaths);
+        // Infer result type
+        let resultType = 'object';
+        if (ts.isIdentifier(unwrappedNode.expression)) {
+            const constructorName = unwrappedNode.expression.text;
+            if (['String', 'Number', 'Boolean', 'Array', 'Date'].includes(constructorName)) {
+                resultType = constructorName.toLowerCase();
+            }
+        }
+        else {
+            resultType = inferredNodeType;
+        }
+        // Register types
+        context.addType(newCallPath, resultType);
+        context.addType(constructorPath, 'function');
+        // If targetPath is provided, establish equivalence and register type
+        if (targetPath) {
+            context.addEquivalence(targetPath, newCallPath);
+            context.addType(targetPath, resultType);
+        }
+        return true;
+    }
+    // Handle Arrow Functions: (p) => p.prop, (a, b) => { ... }
+    if (ts.isArrowFunction(unwrappedNode)) {
+        // Create a path for the function
+        const functionPath = StructuredPath.empty();
+        // Process parameters
+        unwrappedNode.parameters.forEach((param, index) => {
+            const signaturePath = functionPath.withParameter(index);
+            if (ts.isIdentifier(param.name)) {
+                const paramNamePath = StructuredPath.fromBase(param.name.text);
+                // Establish equivalence between parameter name and signature path
+                context.addEquivalence(paramNamePath, signaturePath);
+                // Register types
+                const paramType = context.inferTypeFromNode(param) || 'unknown';
+                context.addType(paramNamePath, paramType);
+                context.addType(signaturePath, paramType);
+            }
+            else if (ts.isObjectBindingPattern(param.name) ||
+                ts.isArrayBindingPattern(param.name)) {
+                const success = processBindingPattern(param.name, signaturePath, context);
+                if (!success) {
+                    context.markUnsupported(param, `processExpression: Failed to process binding pattern: ${ts.SyntaxKind[param.kind]}`, false);
+                }
+            }
+            else {
+                context.markUnsupported(param, `processExpression: Unsupported parameter kind in ArrowFunction: ${ts.SyntaxKind[param.kind]}`, false);
+            }
+        });
+        // Process function body
+        const body = unwrappedNode.body;
+        if (ts.isBlock(body)) {
+            // For block bodies, process the statements inside
+            context.processNode(body);
+        }
+        else {
+            // For expression bodies, process as implicit return
+            const returnPath = functionPath.withProperty('returnValue');
+            processExpression({ node: body, context, targetPath: returnPath });
+        }
+        // If targetPath is provided, establish equivalence
+        if (targetPath) {
+            context.addEquivalence(targetPath, functionPath);
+            context.addType(targetPath, 'function');
+        }
+        return true;
+    }
+    // Handle Tagged Template Expressions: sql`SELECT * FROM ${table}`
+    if (ts.isTaggedTemplateExpression(unwrappedNode)) {
+        // Process the tag expression (e.g., 'sql', 'css', 'gql')
+        const tagProcessed = processExpression({
+            node: unwrappedNode.tag,
+            context,
+        });
+        if (!tagProcessed) {
+            context.markUnsupported(unwrappedNode.tag, `processExpression: Unsupported tag expression in tagged template: ${ts.SyntaxKind[unwrappedNode.tag.kind]}`, false);
+            return false;
+        }
+        // Get a path for the tag
+        const tagPath = StructuredPath.fromNode(unwrappedNode.tag, context.sourceFile);
+        if (tagPath) {
+            // Mark the tag as a function
+            context.addType(tagPath, 'function');
+        }
+        // Process the template part (reusing existing template processing logic)
+        const template = unwrappedNode.template;
+        let allSpansProcessed = true;
+        if (ts.isTemplateExpression(template)) {
+            // Process all template spans (interpolations)
+            for (const span of template.templateSpans) {
+                if (context.isChildBoundary(span.expression)) {
+                    continue;
+                }
+                const spanProcessed = processExpression({
+                    node: span.expression,
+                    context,
+                    targetPath: StructuredPath.empty(),
+                });
+                allSpansProcessed = allSpansProcessed && spanProcessed;
+            }
+        }
+        // If it's NoSubstitutionTemplateLiteral, nothing more to process
+        // Create a path for the entire tagged template expression
+        const taggedTemplatePath = StructuredPath.fromNode(unwrappedNode, context.sourceFile);
+        // The return type of a tagged template is unknown (depends on the tag function)
+        context.addType(taggedTemplatePath, 'unknown');
+        // If targetPath is provided, establish equivalence
+        if (targetPath) {
+            context.addEquivalence(targetPath, taggedTemplatePath);
+            context.addType(targetPath, 'unknown');
+        }
+        // If we didn't fully handle all spans, mark as semantic limitation
+        if (!allSpansProcessed && ts.isTemplateExpression(template)) {
+            context.markSemanticLimitation(unwrappedNode, 'Tagged template contains complex expressions that may not be fully analyzed');
+        }
+        return true;
+    }
+    // Handle Template Literals: `Hello ${name}` or `Simple`
+    if (ts.isTemplateExpression(unwrappedNode) ||
+        ts.isNoSubstitutionTemplateLiteral(unwrappedNode)) {
+        // Create a path for the template literal
+        const templatePath = StructuredPath.createLiteralPath(unwrappedNode.getText(context.sourceFile), 'string');
+        // Track if we can fully handle all expressions in the template
+        let allSpansProcessed = true;
+        // Process template spans if any by recursing back into processExpression
+        if (ts.isTemplateExpression(unwrappedNode)) {
+            for (const span of unwrappedNode.templateSpans) {
+                if (context.isChildBoundary(span.expression)) {
+                    continue;
+                }
+                // Process each span with StructuredPath.empty() as targetPath
+                // This ensures types and equivalences are established without imposing
+                // a prefix that wouldn't make sense in a template context
+                const spanProcessed = processExpression({
+                    node: span.expression,
+                    context,
+                    targetPath: StructuredPath.empty(), // Use empty path to trigger equivalence and type registration
+                });
+                allSpansProcessed = allSpansProcessed && spanProcessed;
+            }
+        }
+        // Template expressions are always strings
+        context.addType(templatePath, 'string');
+        // Register the type with targetPath if provided
+        if (targetPath) {
+            context.addEquivalence(targetPath, templatePath);
+            context.addType(targetPath, 'string');
+        }
+        // If we didn't fully handle all spans, still return true but with limitations noted
+        if (!allSpansProcessed && ts.isTemplateExpression(unwrappedNode)) {
+            context.markSemanticLimitation(unwrappedNode, 'Template literal contains complex expressions that may not be fully analyzed');
+        }
+        return true;
+    }
+    // Handle TypeOf Expression: typeof x
+    if (ts.isTypeOfExpression(unwrappedNode)) {
+        // Process the inner expression
+        processExpression({ node: unwrappedNode.expression, context });
+        // Create a path for the typeof expression
+        const typeofPath = StructuredPath.createLiteralPath(unwrappedNode.getText(context.sourceFile), 'string');
+        // Register the type (always string)
+        if (targetPath) {
+            context.addEquivalence(targetPath, typeofPath);
+            context.addType(targetPath, 'string');
+        }
+        return true;
+    }
+    // Handle Prefix Unary Expressions: ++x, --y, !z, -a
+    if (ts.isPrefixUnaryExpression(unwrappedNode)) {
+        // Process the operand
+        const operandProcessed = processExpression({
+            node: unwrappedNode.operand,
+            context,
+        });
+        if (!operandProcessed) {
+            context.markUnsupported(unwrappedNode.operand, `processExpression: Could not process operand of PrefixUnaryExpression: ${ts.SyntaxKind[unwrappedNode.operand.kind]}`, false);
+            return false;
+        }
+        // Get a path for the operand
+        const operandPath = StructuredPath.fromNode(unwrappedNode.operand, context.sourceFile);
+        if (!operandPath) {
+            return false;
+        }
+        // Determine the result type based on operator
+        const operatorKind = unwrappedNode.operator;
+        let resultType = 'unknown';
+        if (operatorKind === ts.SyntaxKind.PlusPlusToken ||
+            operatorKind === ts.SyntaxKind.MinusMinusToken) {
+            resultType = 'number';
+        }
+        else if (operatorKind === ts.SyntaxKind.ExclamationToken) {
+            resultType = 'boolean | unknown';
+        }
+        else if (operatorKind === ts.SyntaxKind.MinusToken ||
+            operatorKind === ts.SyntaxKind.PlusToken ||
+            operatorKind === ts.SyntaxKind.TildeToken) {
+            resultType = 'number';
+        }
+        else {
+            context.markUnsupported(unwrappedNode, `processExpression: Unsupported prefix unary operator: ${ts.SyntaxKind[operatorKind]}`, false);
+        }
+        // Register the operand's type (which is also the result)
+        context.addType(operandPath, resultType);
+        // If targetPath is provided, establish equivalence and register type
+        if (targetPath) {
+            context.addEquivalence(targetPath, operandPath);
+            context.addType(targetPath, resultType);
+        }
+        return true;
+    }
+    // Handle Postfix Unary Expressions: x++, y--, etc.
+    if (ts.isPostfixUnaryExpression(unwrappedNode)) {
+        // Process the operand
+        const operandProcessed = processExpression({
+            node: unwrappedNode.operand,
+            context,
+        });
+        if (!operandProcessed) {
+            context.markUnsupported(unwrappedNode.operand, `processExpression: Could not process operand of PostfixUnaryExpression: ${ts.SyntaxKind[unwrappedNode.operand.kind]}`, false);
+            return false;
+        }
+        // Get a path for the operand
+        const operandPath = StructuredPath.fromNode(unwrappedNode.operand, context.sourceFile);
+        if (!operandPath) {
+            return false;
+        }
+        // Determine the result type based on operator
+        const operatorKind = unwrappedNode.operator;
+        let resultType = 'unknown';
+        // Currently postfix expressions only support ++ and -- operators
+        if (operatorKind === ts.SyntaxKind.PlusPlusToken ||
+            operatorKind === ts.SyntaxKind.MinusMinusToken) {
+            resultType = 'number';
+            // Register the operand as a number
+            context.addType(operandPath, resultType);
+            // If it's a property access like user.age, add type for parent object
+            if (ts.isPropertyAccessExpression(unwrappedNode.operand)) {
+                const objectPath = StructuredPath.fromNode(unwrappedNode.operand.expression, context.sourceFile);
+                if (objectPath) {
+                    context.addType(objectPath, 'object');
+                }
+            }
+        }
+        else {
+            // Should never reach here (postfix only has ++ and --) but handle just in case
+            context.markUnsupported(unwrappedNode, `processExpression: Unsupported postfix unary operator: ${ts.SyntaxKind[operatorKind]}`, false);
+            return false;
+        }
+        // If targetPath is provided, establish equivalence and register type
+        if (targetPath) {
+            context.addEquivalence(targetPath, operandPath);
+            context.addType(targetPath, resultType);
+        }
+        return true;
+    }
+    // Handle JSX Elements (both normal and self-closing)
+    if (ts.isJsxElement(unwrappedNode) ||
+        ts.isJsxSelfClosingElement(unwrappedNode)) {
+        let openingElement;
+        if (ts.isJsxElement(unwrappedNode)) {
+            openingElement = unwrappedNode.openingElement;
+        }
+        else {
+            openingElement = unwrappedNode;
+        }
+        // Extract the component/tag name
+        const tagName = getJsxTagName(openingElement.tagName, context);
+        if (!tagName) {
+            context.markUnsupported(unwrappedNode, 'Unable to determine JSX element name', false);
+            return false;
+        }
+        // Create a path for the component as a function call
+        const componentPath = StructuredPath.fromFunction(tagName);
+        // Process each attribute
+        let allAttributesHandled = true;
+        for (const attr of openingElement.attributes.properties) {
+            if (ts.isJsxAttribute(attr)) {
+                // Process JSX attribute with component path as context
+                const attrHandled = processJsxAttribute(attr, context, componentPath, targetPath);
+                allAttributesHandled = allAttributesHandled && attrHandled;
+            }
+            else if (ts.isJsxSpreadAttribute(attr)) {
+                // Process JSX spread attribute (e.g., <Comp {...props} />)
+                if (attr.expression) {
+                    // Process the spread expression
+                    const parameterPath = componentPath.withParameter(0);
+                    const spreadProcessed = processExpression({
+                        node: attr.expression,
+                        context,
+                        targetPath: parameterPath,
+                    });
+                    if (!spreadProcessed) {
+                        context.markUnsupported(attr.expression, `processExpression: Unsupported spread expression: ${ts.SyntaxKind[attr.expression.kind]}`, false);
+                    }
+                    allAttributesHandled = allAttributesHandled && spreadProcessed;
+                }
+            }
+        }
+        // Process children for JSX elements (not self-closing)
+        if (ts.isJsxElement(unwrappedNode)) {
+            for (const child of unwrappedNode.children) {
+                // Process expressions in JSX children: <div>{expr}</div>
+                if (ts.isJsxExpression(child) && child.expression) {
+                    // Process the expression with StructuredPath.empty() as targetPath
+                    // to trigger type registration without imposing prefix
+                    processExpression({
+                        node: child.expression,
+                        context,
+                        targetPath: StructuredPath.empty(),
+                    });
+                }
+                // Process nested JSX elements recursively
+                else if (ts.isJsxElement(child) || ts.isJsxSelfClosingElement(child)) {
+                    processExpression({ node: child, context });
+                }
+            }
+        }
+        // Register component as 'function' type (not 'JSX')
+        context.addType(componentPath, 'function');
+        // If targetPath is provided (e.g., in variable assignment), establish equivalence to hardcoded "JSX"
+        if (targetPath) {
+            context.addEquivalence(targetPath, StructuredPath.literal('JSX'));
+            // Don't register a type for targetPath
+        }
+        return allAttributesHandled;
+    }
+    // Handle JSX Fragments (<>...</>)
+    if (ts.isJsxFragment(unwrappedNode)) {
+        // Process children
+        for (const child of unwrappedNode.children) {
+            // Process expressions in JSX children: <>{expr}</>
+            if (ts.isJsxExpression(child) && child.expression) {
+                // Process the expression to extract structure
+                processExpression({
+                    node: child.expression,
+                    context,
+                    targetPath: StructuredPath.empty(),
+                });
+            }
+            // Process nested JSX elements recursively
+            else if (ts.isJsxElement(child) || ts.isJsxSelfClosingElement(child)) {
+                processExpression({ node: child, context });
+            }
+            // Process nested fragments recursively
+            else if (ts.isJsxFragment(child)) {
+                processExpression({ node: child, context });
+            }
+            // Process JsxText (for completeness)
+            else if (ts.isJsxText(child)) {
+                // JsxText nodes are just string literals, no additional processing needed
+                // But we record them for completeness
+            }
+        }
+        // If targetPath is provided, establish equivalence to hardcoded "JSX"
+        if (targetPath) {
+            context.addEquivalence(targetPath, StructuredPath.literal('JSX'));
+            // Don't register a type for targetPath
+        }
+        return true;
+    }
+    if (ts.isJsxOpeningElement(unwrappedNode) ||
+        ts.isJsxOpeningFragment(unwrappedNode)) {
+        if (unwrappedNode.parent) {
+            return processExpression({
+                node: unwrappedNode.parent,
+                context,
+                targetPath,
+            });
+        }
+        // Fallback: shouldn't normally happen, but handle gracefully
+        return true;
+    }
+    if (ts.isJsxClosingElement(unwrappedNode) ||
+        ts.isJsxClosingFragment(unwrappedNode)) {
+        // Closing elements/fragments don't carry additional information
+        return true;
+    }
+    // Handle standalone JsxExpression (e.g., {expr} in JSX context)
+    if (ts.isJsxExpression(unwrappedNode)) {
+        if (unwrappedNode.expression) {
+            // Process the inner expression
+            return processExpression({
+                node: unwrappedNode.expression,
+                context,
+                targetPath,
+            });
+        }
+        // If there's no expression, we can just return true
+        return true;
+    }
+    // Handle JsxText (text content inside JSX elements)
+    if (ts.isJsxText(unwrappedNode)) {
+        // JsxText is just string content in JSX, typically doesn't need
+        // complex analysis, but we mark it as handled
+        // If the text is non-whitespace and targetPath is provided,
+        // we could establish a string literal equivalence
+        const text = unwrappedNode.getText(context.sourceFile).trim();
+        if (text && targetPath) {
+            const literalPath = StructuredPath.createLiteralPath(`"${text}"`, 'string');
+            context.addEquivalence(targetPath, literalPath);
+            context.addType(targetPath, 'string');
+        }
+        return true;
+    }
+    // Handle Spread Element: ...obj, ...arr
+    if (ts.isSpreadElement(unwrappedNode)) {
+        // Process the expression being spread
+        const spreadExprProcessed = processExpression({
+            node: unwrappedNode.expression,
+            context,
+        });
+        if (!spreadExprProcessed) {
+            context.markUnsupported(unwrappedNode.expression, `processExpression: Unsupported expression in spread element: ${ts.SyntaxKind[unwrappedNode.expression.kind]}`, false);
+            return false;
+        }
+        // Get a path for the spread expression
+        const spreadExprPath = StructuredPath.fromNode(unwrappedNode.expression, context.sourceFile);
+        if (!spreadExprPath) {
+            context.markUnsupported(unwrappedNode.expression, `processExpression: Couldn't get path for spread element expression`, false);
+            return false;
+        }
+        // Create a path for the spread element itself
+        const spreadPath = StructuredPath.fromBase(`...${unwrappedNode.expression.getText(context.sourceFile)}`);
+        // If targetPath is provided, establish equivalence
+        if (targetPath) {
+            context.addEquivalence(targetPath, spreadPath);
+            // We don't know the exact type of the spread result as it depends on context
+            // (object spread vs array spread), so we use the same type as the expression
+            const spreadType = context.getTypeInfo(spreadExprPath) || 'unknown';
+            context.addType(targetPath, spreadType);
+        }
+        return true;
+    }
+    if (ts.isDeleteExpression(unwrappedNode)) {
+        // first just process whatever is being deleted
+        const result = processExpression({
+            node: unwrappedNode.expression,
+            context,
+        });
+        if (!result) {
+            context.markUnsupported(unwrappedNode.expression, `processExpression: Unsupported expression in delete: ${ts.SyntaxKind[unwrappedNode.expression.kind]}`, false);
+            return false;
+        }
+        nodePath = StructuredPath.fromNode(unwrappedNode, context.sourceFile);
+        // 'delete' is boolean typed
+        context.addType(nodePath, 'boolean');
+        if (targetPath) {
+            context.addEquivalence(targetPath, nodePath);
+            context.addType(targetPath, 'boolean');
+        }
+        return result;
+    }
+    if (ts.isRegularExpressionLiteral(unwrappedNode)) {
+        // Regular expressions are treated as string literals
+        const regexPath = StructuredPath.createLiteralPath(unwrappedNode.getText(context.sourceFile), 'string');
+        context.addType(regexPath, 'string');
+        // If targetPath is provided, establish equivalence
+        if (targetPath) {
+            context.addEquivalence(targetPath, regexPath);
+            context.addType(targetPath, 'string');
+        }
+        return true;
+    }
+    console.warn(`processExpression: Unsupported expression kind: ${ts.SyntaxKind[unwrappedNode.kind]}`, {
+        nodeText: node.getText(context.sourceFile),
+        statementName: context.statementInfo.name,
+        statementText: context.statementInfo.text,
+    });
+    // For now, mark other types as unsupported and return false
+    context.markUnsupported(unwrappedNode, `processExpression: Unsupported expression kind: ${ts.SyntaxKind[unwrappedNode.kind]}`, false);
+    return false;
+}
+/**
+ * Helper function to process a JSX attribute
+ */
+function processJsxAttribute(attr, context, componentPath, targetPath) {
+    // JSX attribute names can be either simple identifiers or namespace names
+    const attrName = ts.isIdentifier(attr.name)
+        ? attr.name.text
+        : attr.name.name.text;
+    // Skip attributes with no initializer (boolean props)
+    if (!attr.initializer) {
+        return true;
+    }
+    // Create path for this attribute: Component.signature[0].attributeName
+    const attributePath = componentPath.withParameter(0).withProperty(attrName);
+    // For string literals: <Component attr="value" />
+    if (ts.isStringLiteral(attr.initializer)) {
+        const literalPath = StructuredPath.createLiteralPath(`"${attr.initializer.text}"`, 'string');
+        context.addEquivalence(attributePath, literalPath);
+        context.addType(attributePath, 'string');
+        return true;
+    }
+    // For expressions: <Component attr={value} />
+    if (ts.isJsxExpression(attr.initializer) && attr.initializer.expression) {
+        const expression = attr.initializer.expression;
+        if (context.isChildBoundary(expression)) {
+            return true;
+        }
+        // Process the expression with attributePath as targetPath
+        // This will establish all equivalences and types automatically
+        return processExpression({
+            node: expression,
+            context,
+            targetPath: attributePath,
+        });
+    }
+    // Mark as unsupported if we couldn't handle the attribute
+    context.markUnsupported(attr, `Unsupported JSX attribute initializer: ${attr.initializer?.kind ? ts.SyntaxKind[attr.initializer.kind] : 'undefined'}`, false);
+    return false;
+}
+/**
+ * Helper function to get a string representation of a JSX tag name
+ */
+function getJsxTagName(tagNameNode, context) {
+    if (ts.isIdentifier(tagNameNode)) {
+        return tagNameNode.text;
+    }
+    else if (ts.isPropertyAccessExpression(tagNameNode)) {
+        const objName = getJsxTagName(tagNameNode.expression, context);
+        return objName ? `${objName}.${tagNameNode.name.text}` : '';
+    }
+    else if (tagNameNode.namespace) {
+        // Handle namespaced names like <ns:elem />
+        const jsxNamespacedName = tagNameNode;
+        return `${jsxNamespacedName.namespace.text}:${jsxNamespacedName.name.text}`;
+    }
+    return '';
+}
+//# sourceMappingURL=processExpression.js.map