@divmain/jdm-asm 0.2.1 → 0.2.3

package/src/compiler/nodes/expression-compiler.ts

@@ -1,526 +0,0 @@
-// ============================================================================
-// Expression AST Compiler
-// ============================================================================
-//
-// This module provides the core expression compilation functionality for
-// transforming expression ASTs into AssemblyScript code. It uses the
-// ContextResolver strategy pattern to handle different compilation contexts.
-
-import type {
-  ExpressionAST,
-  BinaryOp,
-  UnaryOp,
-  NumberLiteral,
-  StringLiteral,
-  BooleanLiteral,
-  Identifier,
-  TernaryOp,
-  MemberAccess,
-  IndexAccess,
-  FunctionCall,
-  Interval,
-  TemplateLiteral,
-  ArrayLiteral,
-  ObjectLiteral,
-} from '../ast-types';
-import type { CompilationContext } from '../types';
-import type { ContextResolver } from './context-resolvers';
-import { StandardContextResolver } from './context-resolvers';
-
-// ============================================================================
-// Unified Expression Compiler
-// ============================================================================
-
-/**
- * Compile an expression AST using the provided context resolver strategy.
- *
- * This is the single unified implementation that handles all expression compilation.
- * The resolver parameter determines how identifiers, $, and # are resolved.
- *
- * @param ast - The AST node to compile
- * @param context - The compilation context
- * @param resolver - The context resolution strategy
- * @returns AssemblyScript code string that produces a Value
- */
-export function compileExpressionUnified(
-  ast: ExpressionAST,
-  context: CompilationContext,
-  resolver: ContextResolver,
-): string {
-  switch (ast.type) {
-    case 'NumberLiteral':
-      return `Value.Float(${(ast as NumberLiteral).value})`;
-
-    case 'StringLiteral':
-      return `Value.String("${escapeString((ast as StringLiteral).value)}")`;
-
-    case 'BooleanLiteral':
-      return `Value.Bool(${(ast as BooleanLiteral).value})`;
-
-    case 'NullLiteral':
-      return `Value.Null()`;
-
-    case 'Identifier':
-      return resolver.resolveIdentifier((ast as Identifier).name);
-
-    case 'DollarRef':
-      return resolver.resolveDollarRef();
-
-    case 'HashRef':
-      return resolver.resolveHashRef();
-
-    case 'BinaryOp': {
-      const bop = ast as BinaryOp;
-      const left = compileExpressionUnified(bop.left, context, resolver);
-      const right = compileExpressionUnified(bop.right, context, resolver);
-      return compileBinaryOpWithValues(bop.op, left, right);
-    }
-
-    case 'UnaryOp': {
-      const uop = ast as UnaryOp;
-      const operand = compileExpressionUnified(uop.operand, context, resolver);
-      switch (uop.op) {
-        case 'not':
-          return `Value.Bool(!(${operand}).asBool())`;
-        case '-':
-          return `negateValue(${operand})`;
-        default:
-          throw new Error(`Unknown unary operator: ${uop.op}`);
-      }
-    }
-
-    case 'TernaryOp': {
-      const top = ast as TernaryOp;
-      const cond = compileExpressionUnified(top.condition, context, resolver);
-      const cons = compileExpressionUnified(top.consequent, context, resolver);
-      const alt = compileExpressionUnified(top.alternate, context, resolver);
-      return `(${cond}.asBool() ? ${cons} : ${alt})`;
-    }
-
-    case 'MemberAccess': {
-      const ma = ast as MemberAccess;
-      // Handle $.property.subproperty - look up in appropriate context
-      const dollarPath = buildDollarPath(ma);
-      if (dollarPath) {
-        return resolver.resolveDollarPath(dollarPath);
-      }
-      // Check if this is a $nodes reference
-      if (checkIsNodesReference(ma)) {
-        const nodesPath = buildNodesPath(ma);
-        return resolver.resolveNodesPath(nodesPath);
-      }
-      // For other member access, use getProperty helper
-      const obj = compileExpressionUnified(ma.object, context, resolver);
-      return `getProperty(${obj}, "${ma.property}")`;
-    }
-
-    case 'IndexAccess': {
-      const ia = ast as IndexAccess;
-      const arr = compileExpressionUnified(ia.object, context, resolver);
-      const idx = compileExpressionUnified(ia.index, context, resolver);
-      return `getIndex(${arr}, ${idx})`;
-    }
-
-    case 'FunctionCall': {
-      const fc = ast as FunctionCall;
-      if (fc.callee.type === 'Identifier') {
-        const name = (fc.callee as Identifier).name;
-
-        // Higher-order functions need special handling
-        if (name === 'filter') {
-          return compileHigherOrderCall(fc, context, resolver, 'filter');
-        }
-        if (name === 'map') {
-          return compileHigherOrderCall(fc, context, resolver, 'map');
-        }
-        if (name === 'reduce') {
-          return compileHigherOrderCall(fc, context, resolver, 'reduce');
-        }
-        if (name === 'all') {
-          return compileHigherOrderCall(fc, context, resolver, 'all');
-        }
-        if (name === 'some') {
-          return compileHigherOrderCall(fc, context, resolver, 'some');
-        }
-
-        // Regular function call
-        const args = fc.args.map((arg) => compileExpressionUnified(arg, context, resolver));
-        const numArgs = args.length;
-
-        // AssemblyScript requires typed array constructors
-        if (numArgs === 1) {
-          return `evaluateFunction("${name}", makeArgs1(${args[0]}))`;
-        } else if (numArgs === 2) {
-          return `evaluateFunction("${name}", makeArgs2(${args[0]}, ${args[1]}))`;
-        } else if (numArgs === 3) {
-          return `evaluateFunction("${name}", makeArgs3(${args[0]}, ${args[1]}, ${args[2]}))`;
-        } else {
-          return `evaluateFunction("${name}", [${args.join(', ')}])`;
-        }
-      }
-      throw new Error('Only direct function calls are supported');
-    }
-
-    case 'Interval': {
-      const intv = ast as Interval;
-      const start = compileExpressionUnified(intv.start, context, resolver);
-      const end = compileExpressionUnified(intv.end, context, resolver);
-      return `createInterval(${start}, ${end}, ${intv.startInclusive}, ${intv.endInclusive})`;
-    }
-
-    case 'ArrayLiteral': {
-      const al = ast as ArrayLiteral;
-      if (al.elements.length === 0) {
-        return 'Value.Array(new Array<Value>(0))';
-      }
-      const elements = al.elements.map((e) => compileExpressionUnified(e, context, resolver));
-      return `Value.Array([${elements.join(', ')}])`;
-    }
-
-    case 'ObjectLiteral': {
-      const ol = ast as ObjectLiteral;
-      if (ol.properties.length === 0) {
-        return 'Value.Object(new Map<string, Value>())';
-      }
-      // Generate a helper function for object construction
-      const childResolver = resolver.createChildResolver();
-      const helperId = context.getUniqueId('object');
-      const props = ol.properties.map((p) => {
-        const value = compileExpressionUnified(p.value, context, childResolver);
-        return `  objResult.set("${p.key}", ${value});`;
-      });
-
-      const helperCode = `
-function objectHelper_${helperId}(ctx: Context${resolver.getHelperParams()}): Value {
-  const objResult = new Map<string, Value>();
-${props.join('\n')}
-  return Value.Object(objResult);
-}`;
-      context.helperFunctions.set(`objectHelper_${helperId}`, helperCode);
-      return `objectHelper_${helperId}(ctx${resolver.getHelperArgs()})`;
-    }
-
-    case 'TemplateLiteral': {
-      const tl = ast as TemplateLiteral;
-      const parts = tl.parts.map((part) => {
-        if ('text' in part) {
-          return `"${escapeString(part.text)}"`;
-        } else {
-          return `(${compileExpressionUnified(part.expr, context, resolver)}).asString()`;
-        }
-      });
-      if (parts.length === 0) {
-        return 'Value.String("")';
-      }
-      if (parts.length === 1) {
-        return `Value.String(${parts[0]})`;
-      }
-      return `Value.String(${parts.join(' + ')})`;
-    }
-
-    default:
-      throw new Error(`Unsupported expression type: ${(ast as any).type}`);
-  }
-}
-
-// ============================================================================
-// Higher-Order Function Compilation
-// ============================================================================
-
-/**
- * Compile a higher-order function call (filter, map, reduce, all, some).
- *
- * These functions iterate over arrays and need helper functions that set # for each element.
- * The resolver's child resolver is used inside the helper to maintain proper scoping.
- */
-function compileHigherOrderCall(
-  ast: FunctionCall,
-  context: CompilationContext,
-  resolver: ContextResolver,
-  fnName: 'filter' | 'map' | 'reduce' | 'all' | 'some',
-): string {
-  const expectedArgs = fnName === 'reduce' ? 3 : 2;
-  if (ast.args.length !== expectedArgs) {
-    throw new Error(
-      `${fnName}() requires exactly ${expectedArgs} arguments, got ${ast.args.length}`,
-    );
-  }
-
-  const arrayExpr = ast.args[0];
-  const lambdaExpr = ast.args[1];
-
-  // Compile array expression with current resolver
-  const arrayCode = compileExpressionUnified(arrayExpr, context, resolver);
-
-  // Use child resolver for lambda (maintains access to outer scope)
-  const childResolver = resolver.createChildResolver();
-  const lambdaCode = compileExpressionUnified(lambdaExpr, context, childResolver);
-
-  const helperId = context.getUniqueId(fnName);
-  const extraParams = resolver.getHelperParams();
-  const extraArgs = resolver.getHelperArgs();
-
-  let helperCode: string;
-
-  switch (fnName) {
-    case 'filter':
-      helperCode = `
-function filterHelper_${helperId}(ctx: Context, arr: Value${extraParams}): Value {
-  if (!arr.isArray()) {
-    return Value.Array(new Array<Value>(0));
-  }
-
-  const inputArr = arr.asArray();
-  const filterResult = new Array<Value>(0);
-
-  for (let i = 0; i < inputArr.length; i++) {
-    const element = inputArr[i];
-    ctx.set("#", element);
-    if (${lambdaCode}.asBool()) {
-      filterResult.push(element);
-    }
-  }
-
-  return Value.Array(filterResult);
-}`;
-      break;
-
-    case 'map':
-      helperCode = `
-function mapHelper_${helperId}(ctx: Context, arr: Value${extraParams}): Value {
-  if (!arr.isArray()) {
-    return Value.Array(new Array<Value>(0));
-  }
-
-  const inputArr = arr.asArray();
-  const mapResult = new Array<Value>(0);
-
-  for (let i = 0; i < inputArr.length; i++) {
-    const element = inputArr[i];
-    ctx.set("#", element);
-    mapResult.push(${lambdaCode});
-  }
-
-  return Value.Array(mapResult);
-}`;
-      break;
-
-    case 'reduce': {
-      const initialExpr = ast.args[2];
-      const initialCode = compileExpressionUnified(initialExpr, context, resolver);
-      helperCode = `
-function reduceHelper_${helperId}(ctx: Context, arr: Value, initAcc: Value${extraParams}): Value {
-  if (!arr.isArray()) {
-    return initAcc;
-  }
-
-  const inputArr = arr.asArray();
-  let reduceAcc = initAcc;
-
-  for (let i = 0; i < inputArr.length; i++) {
-    const element = inputArr[i];
-    ctx.set("#", element);
-    ctx.set("acc", reduceAcc);
-    reduceAcc = ${lambdaCode};
-  }
-
-  return reduceAcc;
-}`;
-      context.helperFunctions.set(`reduceHelper_${helperId}`, helperCode);
-      return `reduceHelper_${helperId}(ctx, ${arrayCode}, ${initialCode}${extraArgs})`;
-    }
-
-    case 'all':
-      helperCode = `
-function allHelper_${helperId}(ctx: Context, arr: Value${extraParams}): Value {
-  if (!arr.isArray()) {
-    return Value.Bool(false);
-  }
-
-  const inputArr = arr.asArray();
-
-  for (let i = 0; i < inputArr.length; i++) {
-    const element = inputArr[i];
-    ctx.set("#", element);
-    if (!${lambdaCode}.asBool()) {
-      return Value.Bool(false);
-    }
-  }
-
-  return Value.Bool(true);
-}`;
-      break;
-
-    case 'some':
-      helperCode = `
-function someHelper_${helperId}(ctx: Context, arr: Value${extraParams}): Value {
-  if (!arr.isArray()) {
-    return Value.Bool(false);
-  }
-
-  const inputArr = arr.asArray();
-
-  for (let i = 0; i < inputArr.length; i++) {
-    const element = inputArr[i];
-    ctx.set("#", element);
-    if (${lambdaCode}.asBool()) {
-      return Value.Bool(true);
-    }
-  }
-
-  return Value.Bool(false);
-}`;
-      break;
-  }
-
-  context.helperFunctions.set(`${fnName}Helper_${helperId}`, helperCode);
-  return `${fnName}Helper_${helperId}(ctx, ${arrayCode}${extraArgs})`;
-}
-
-// ============================================================================
-// Binary Operator Compilation
-// ============================================================================
-
-/**
- * Helper to compile binary operations with pre-compiled left and right values.
- * This is the single source of truth for all binary operator code generation.
- *
- * @param op - The operator string (e.g., "+", "-", "==", "and", etc.)
- * @param left - Pre-compiled code string for the left operand
- * @param right - Pre-compiled code string for the right operand
- * @returns AssemblyScript code string for the binary operation
- */
-export function compileBinaryOpWithValues(op: string, left: string, right: string): string {
-  switch (op) {
-    // Arithmetic
-    case '+':
-      return `addValues(${left}, ${right})`;
-    case '-':
-      return `subtractValues(${left}, ${right})`;
-    case '*':
-      return `multiplyValues(${left}, ${right})`;
-    case '/':
-      return `divideValues(${left}, ${right})`;
-    case '%':
-      return `moduloValues(${left}, ${right})`;
-    case '^':
-      return `powerValues(${left}, ${right})`;
-
-    // Comparison
-    case '==':
-      return `Value.Bool(valuesEqual(${left}, ${right}))`;
-    case '!=':
-      return `Value.Bool(!valuesEqual(${left}, ${right}))`;
-    case '<':
-      return `Value.Bool(compareValues(${left}, ${right}) < 0)`;
-    case '>':
-      return `Value.Bool(compareValues(${left}, ${right}) > 0)`;
-    case '<=':
-      return `Value.Bool(compareValues(${left}, ${right}) <= 0)`;
-    case '>=':
-      return `Value.Bool(compareValues(${left}, ${right}) >= 0)`;
-
-    // Logical
-    case 'and':
-      return `((${left}).asBool() ? (${right}) : (${left}))`;
-    case 'or':
-      return `((${left}).asBool() ? (${left}) : (${right}))`;
-
-    // Null coalescing
-    case '??':
-      return `(${left}.isNull() ? ${right} : ${left})`;
-
-    // Membership
-    case 'in':
-      return `valueIn(${left}, ${right})`;
-    case 'not in':
-      return `Value.Bool(!valueIn(${left}, ${right}).asBool())`;
-
-    default:
-      throw new Error(`Unknown binary operator: ${op}`);
-  }
-}
-
-// ============================================================================
-// Utility Functions
-// ============================================================================
-
-/**
- * Escape a string for use in AssemblyScript string literals.
- */
-export function escapeString(s: string): string {
-  return s
-    .replace(/\\/g, '\\\\')
-    .replace(/"/g, '\\"')
-    .replace(/\n/g, '\\n')
-    .replace(/\r/g, '\\r')
-    .replace(/\t/g, '\\t');
-}
-
-/**
- * Build the full dotted path for a $-rooted member access chain.
- * Returns null if the path is not rooted at $.
- *
- * Example: $.eligibility.specialOffers -> "eligibility.specialOffers"
- */
-export function buildDollarPath(ast: MemberAccess): string | null {
-  if (ast.object.type === 'DollarRef') {
-    return ast.property;
-  }
-  if (ast.object.type === 'MemberAccess') {
-    const parentPath = buildDollarPath(ast.object as MemberAccess);
-    if (parentPath !== null) {
-      return `${parentPath}.${ast.property}`;
-    }
-  }
-  return null;
-}
-
-/**
- * Check if a member access chain is rooted at the '$nodes' identifier.
- */
-export function checkIsNodesReference(ast: MemberAccess): boolean {
-  if (ast.object.type === 'Identifier') {
-    return (ast.object as Identifier).name === '$nodes';
-  } else if (ast.object.type === 'MemberAccess') {
-    return checkIsNodesReference(ast.object as MemberAccess);
-  }
-  return false;
-}
-
-/**
- * Build the full dotted path for a $nodes-rooted member access chain.
- */
-export function buildNodesPath(ast: MemberAccess): string {
-  if (ast.object.type === 'Identifier') {
-    return `${(ast.object as Identifier).name}.${ast.property}`;
-  } else if (ast.object.type === 'MemberAccess') {
-    return `${buildNodesPath(ast.object as MemberAccess)}.${ast.property}`;
-  }
-  throw new Error('Invalid object type for $nodes reference');
-}
-
-// ============================================================================
-// Convenience Functions
-// ============================================================================
-
-// Singleton instance for standard context compilation
-const standardResolver = new StandardContextResolver();
-
-/**
- * Compile an AST node to AssemblyScript code using standard context resolution.
- *
- * This is a convenience function that uses StandardContextResolver, where:
- * - $ references resolve to ctx.get("$")
- * - Identifiers resolve to ctx.get("name")
- *
- * For specialized compilation contexts (expression nodes with local $, scoped contexts),
- * use compileExpressionUnified directly with the appropriate resolver.
- *
- * @param ast - The AST node to compile
- * @param context - The compilation context
- * @returns AssemblyScript code string that produces a Value
- */
-export function compileExpression(ast: ExpressionAST, context: CompilationContext): string {
-  return compileExpressionUnified(ast, context, standardResolver);
-}