@divmain/jdm-asm 0.2.1 → 0.2.3

package/src/compiler/optimizer.ts

@@ -1,948 +0,0 @@
-/**
- * Optimization Pipeline for JDM to WebAssembly Compilation
- *
- * This module defines the interface for optimization passes and the runner
- * that applies them sequentially to transform the compiled AST into an
- * optimized form before code generation.
- */
-
-import { type JDMDecision, type JDMNode, NodeType } from './parser';
-import {
-  type ExpressionAST,
-  type NumberLiteral,
-  type StringLiteral,
-  type BooleanLiteral,
-  isNumberLiteral,
-  isStringLiteral,
-  isBooleanLiteral,
-  isNullLiteral,
-  isBinaryOp,
-  isUnaryOp,
-  isTernaryOp,
-} from './ast-types';
-import { parseStandardExpression, parseUnaryExpression } from './unary-parser';
-
-/**
- * Cache for parsed expression ASTs.
- * Maps expression strings to their parsed AST nodes to avoid redundant parsing.
- */
-type ExpressionCache = Map<string, ExpressionAST>;
-
-/**
- * Compiled AST - the intermediate representation after parsing.
- *
- * JDMDecision structure is simple enough for in-place transformation, avoiding the
- * complexity and memory overhead of building a separate intermediate representation.
- */
-export type CompiledAST = JDMDecision;
-
-/**
- * Interface for an optimization pass.
- *
- * Each optimization pass receives the compiled AST and returns a
- * potentially modified/optimized AST.
- */
-export interface OptimizationPass {
-  /** Human-readable name of the optimization pass */
-  name: string;
-
-  /**
-   * Run the optimization pass on the given AST.
-   *
-   * @param ast - The compiled AST to optimize
-   * @returns The optimized AST
-   */
-  run(ast: CompiledAST): CompiledAST;
-}
-
-/**
- * Ordered list of optimization passes.
- *
- * Passes have dependencies - one pass may create opportunities for the next. For example,
- * constant folding might convert "if (2 > 3)" to "if (false)", then dead code elimination
- * removes the unreachable branch. Running DCE before folding would miss this optimization.
- */
-export const optimizer: OptimizationPass[] = [
-  { name: 'Constant Folding', run: constantFolding },
-  { name: 'Dead Code Elimination', run: deadCodeElimination },
-  { name: 'Expression Inlining', run: expressionInlining },
-  { name: 'Table Indexing', run: tableIndexing },
-];
-
-/**
- * Run all optimization passes sequentially on the given AST.
- *
- * @param ast - The compiled AST to optimize
- * @returns The fully optimized AST
- */
-export function runOptimizations(ast: CompiledAST): CompiledAST {
-  let optimized = ast;
-
-  for (const pass of optimizer) {
-    optimized = pass.run(optimized);
-  }
-
-  return optimized;
-}
-
-// ============================================================================
-// Expression Cache Utilities
-// ============================================================================
-
-/**
- * Get the expression cache for a node, creating it if it doesn't exist.
- */
-function getExpressionCache(node: JDMNode): ExpressionCache {
-  if (!node.parsedContent) {
-    node.parsedContent = {};
-  }
-  if (!node.parsedContent._cachedExprs) {
-    node.parsedContent._cachedExprs = new Map<string, ExpressionAST>();
-  }
-  return node.parsedContent._cachedExprs as ExpressionCache;
-}
-
-/**
- * Parse an expression with caching.
- * Checks the cache first, and only parses if not found.
- */
-function cachedParseUnary(node: JDMNode, expr: string): ExpressionAST {
-  const cache = getExpressionCache(node);
-  const cached = cache.get(expr);
-  if (cached) {
-    return cached;
-  }
-  const parsed = parseUnaryExpression(expr);
-  cache.set(expr, parsed);
-  return parsed;
-}
-
-/**
- * Parse a standard expression with caching.
- * Checks the cache first, and only parses if not found.
- */
-function cachedParseStandard(node: JDMNode, expr: string): ExpressionAST {
-  const cache = getExpressionCache(node);
-  const cached = cache.get(expr);
-  if (cached) {
-    return cached;
-  }
-  const parsed = parseStandardExpression(expr);
-  cache.set(expr, parsed);
-  return parsed;
-}
-
-/**
- * Clear the expression cache for a node.
- * Should be called when the node's expressions are modified.
- */
-function clearExpressionCache(node: JDMNode): void {
-  if (node.parsedContent && node.parsedContent._cachedExprs) {
-    node.parsedContent._cachedExprs.clear();
-  }
-}
-
-// Export individual optimization passes for testing
-export { constantFolding, deadCodeElimination, expressionInlining, tableIndexing };
-
-// Export cache utilities for testing
-export { getExpressionCache, clearExpressionCache };
-
-// ============================================================================
-// Constant Folding
-// ============================================================================
-
-/**
- * Fold constant expressions at compile time.
- *
- * This pass traverses expression ASTs and evaluates them at compile time
- * when possible. Examples:
- *   - Replace (2 + 3) with 5
- *   - Replace true and false with false
- *   - Replace "hello" + " world" with "hello world"
- *
- * @param ast - The compiled AST to optimize
- * @returns The AST with folded constants
- */
-function constantFolding(ast: CompiledAST): CompiledAST {
-  // Create a deep copy to avoid mutating the original
-  const optimized = JSON.parse(JSON.stringify(ast)) as JDMDecision;
-
-  // Apply constant folding to each node's expression content
-  optimized.nodes = optimized.nodes.map((node: JDMNode) => foldNodeExpressions(node));
-
-  return optimized;
-}
-
-/**
- * Apply constant folding to expressions within a node.
- */
-function foldNodeExpressions(node: JDMNode): JDMNode {
-  if (!node.content) {
-    return node;
-  }
-
-  const content = node.content;
-
-  // Handle decision table nodes
-  if (node.type === NodeType.DECISION_TABLE) {
-    return foldDecisionTableExpressions(node, content);
-  }
-
-  // Handle switch nodes
-  if (node.type === NodeType.SWITCH) {
-    return foldSwitchExpressions(node, content);
-  }
-
-  // Handle expression nodes
-  if (node.type === NodeType.EXPRESSION) {
-    return foldExpressionNode(node, content);
-  }
-
-  return node;
-}
-
-/**
- * Fold expressions in a decision table node.
- */
-function foldDecisionTableExpressions(node: JDMNode, content: Record<string, unknown>): JDMNode {
-  const { rules, inputs } = content as { rules: any[]; inputs: any[] };
-  let modified = false;
-
-  // Update each rule's input conditions with folded expressions
-  const foldedRules = rules.map((rule: Record<string, unknown>) => {
-    const foldedRule = { ...rule };
-
-    for (const input of inputs) {
-      const expr = rule[input.id] as string | undefined;
-      if (!expr || expr === '' || expr === '-') {
-        continue;
-      }
-
-      // Parse the expression in unary mode (using cache)
-      try {
-        const ast = cachedParseUnary(node, expr);
-        const folded = foldExpression(ast);
-
-        // If folding succeeded, update the expression string
-        if (folded !== null && isLiteral(folded)) {
-          const newExpr = literalToExprString(folded);
-          if (newExpr !== expr) {
-            foldedRule[input.id] = newExpr;
-            modified = true;
-          }
-        }
-      } catch {
-        // If expression can't be parsed or folded, keep original
-      }
-    }
-
-    return foldedRule;
-  });
-
-  // Clear cache if expressions were modified
-  if (modified) {
-    clearExpressionCache(node);
-  }
-
-  return {
-    ...node,
-    content: {
-      ...content,
-      rules: foldedRules,
-    },
-  };
-}
-
-/**
- * Fold expressions in a switch node.
- */
-function foldSwitchExpressions(node: JDMNode, content: any): JDMNode {
-  const { conditions } = content;
-  let modified = false;
-
-  const foldedConditions = conditions.map((condition: any) => {
-    const expr = condition.expression;
-    if (!expr || expr === '') {
-      return condition;
-    }
-
-    try {
-      const ast = cachedParseStandard(node, expr);
-      const folded = foldExpression(ast);
-
-      if (folded !== null && isLiteral(folded)) {
-        const newExpr = literalToExprString(folded);
-        if (newExpr !== expr) {
-          modified = true;
-          return {
-            ...condition,
-            expression: newExpr,
-          };
-        }
-      }
-    } catch {
-      // If expression can't be parsed or folded, keep original
-    }
-
-    return condition;
-  });
-
-  // Clear cache if expressions were modified
-  if (modified) {
-    clearExpressionCache(node);
-  }
-
-  return {
-    ...node,
-    content: {
-      ...content,
-      conditions: foldedConditions,
-    },
-  };
-}
-
-/**
- * Fold expressions in an expression node.
- */
-function foldExpressionNode(node: JDMNode, content: any): JDMNode {
-  const expr = content.expression;
-  if (!expr) {
-    return node;
-  }
-
-  try {
-    const ast = cachedParseStandard(node, expr);
-    const folded = foldExpression(ast);
-
-    if (folded !== null && isLiteral(folded)) {
-      const newExpr = literalToExprString(folded);
-      if (newExpr !== expr) {
-        // Clear cache since we're modifying the expression
-        clearExpressionCache(node);
-        return {
-          ...node,
-          content: {
-            ...content,
-            expression: newExpr,
-          },
-        };
-      }
-    }
-  } catch {
-    // If expression can't be parsed or folded, keep original
-  }
-
-  return node;
-}
-
-/**
- * Recursively fold an expression AST.
- * Returns the folded AST node, or null if folding is not possible.
- */
-function foldExpression(expr: ExpressionAST): ExpressionAST | null {
-  if (isLiteralExpr(expr)) {
-    return expr;
-  }
-
-  if (isBinaryOp(expr)) {
-    const leftFolded = foldExpression(expr.left);
-    const rightFolded = foldExpression(expr.right);
-
-    // If both sides are literals, try to evaluate at compilation time
-    if (leftFolded && rightFolded && isLiteral(leftFolded) && isLiteral(rightFolded)) {
-      const result = evaluateConstantBinaryOp(expr.op, leftFolded, rightFolded);
-      if (result !== null) {
-        return result;
-      }
-    }
-
-    return {
-      ...expr,
-      left: leftFolded || expr.left,
-      right: rightFolded || expr.right,
-    };
-  }
-
-  if (isUnaryOp(expr)) {
-    const operandFolded = foldExpression(expr.operand);
-
-    if (operandFolded && isLiteral(operandFolded)) {
-      const result = evaluateConstantUnaryOp(expr.op, operandFolded);
-      if (result !== null) {
-        return result;
-      }
-    }
-
-    return {
-      ...expr,
-      operand: operandFolded || expr.operand,
-    };
-  }
-
-  if (isTernaryOp(expr)) {
-    const conditionFolded = foldExpression(expr.condition);
-    const consequentFolded = foldExpression(expr.consequent);
-    const alternateFolded = foldExpression(expr.alternate);
-
-    if (conditionFolded && isLiteral(conditionFolded) && isBooleanLiteral(conditionFolded)) {
-      return conditionFolded.value
-        ? consequentFolded || expr.consequent
-        : alternateFolded || expr.alternate;
-    }
-
-    return {
-      ...expr,
-      condition: conditionFolded || expr.condition,
-      consequent: consequentFolded || expr.consequent,
-      alternate: alternateFolded || expr.alternate,
-    };
-  }
-
-  // Can't fold other expression types (identifiers, function calls, etc.)
-  return null;
-}
-
-/**
- * Check if an expression is a literal value.
- */
-function isLiteralExpr(expr: ExpressionAST): boolean {
-  return (
-    isNumberLiteral(expr) || isStringLiteral(expr) || isBooleanLiteral(expr) || isNullLiteral(expr)
-  );
-}
-
-/**
- * Check if a node is a literal.
- */
-function isLiteral(
-  node: ExpressionAST | null,
-): node is NumberLiteral | StringLiteral | BooleanLiteral {
-  return node !== null && isLiteralExpr(node);
-}
-
-/**
- * Evaluate a binary operation with constant operands.
- */
-function evaluateConstantBinaryOp(
-  op: string,
-  left: NumberLiteral | StringLiteral | BooleanLiteral,
-  right: NumberLiteral | StringLiteral | BooleanLiteral,
-): ExpressionAST | null {
-  // Numeric operations
-  if (isNumberLiteral(left) && isNumberLiteral(right)) {
-    switch (op) {
-      case '+':
-        return { type: 'NumberLiteral', value: left.value + right.value };
-      case '-':
-        return { type: 'NumberLiteral', value: left.value - right.value };
-      case '*':
-        return { type: 'NumberLiteral', value: left.value * right.value };
-      case '/':
-        return { type: 'NumberLiteral', value: left.value / right.value };
-      case '%':
-        return { type: 'NumberLiteral', value: left.value % right.value };
-      case '^':
-        return { type: 'NumberLiteral', value: Math.pow(left.value, right.value) };
-      case '<':
-        return { type: 'BooleanLiteral', value: left.value < right.value };
-      case '>':
-        return { type: 'BooleanLiteral', value: left.value > right.value };
-      case '<=':
-        return { type: 'BooleanLiteral', value: left.value <= right.value };
-      case '>=':
-        return { type: 'BooleanLiteral', value: left.value >= right.value };
-      case '==':
-        return { type: 'BooleanLiteral', value: left.value === right.value };
-      case '!=':
-        return { type: 'BooleanLiteral', value: left.value !== right.value };
-    }
-  }
-
-  // String operations
-  if (isStringLiteral(left) && isStringLiteral(right)) {
-    switch (op) {
-      case '+':
-        return { type: 'StringLiteral', value: left.value + right.value };
-      case '==':
-        return { type: 'BooleanLiteral', value: left.value === right.value };
-      case '!=':
-        return { type: 'BooleanLiteral', value: left.value !== right.value };
-    }
-  }
-
-  // Boolean operations
-  if (isBooleanLiteral(left) && isBooleanLiteral(right)) {
-    switch (op) {
-      case 'and':
-        return { type: 'BooleanLiteral', value: left.value && right.value };
-      case 'or':
-        return { type: 'BooleanLiteral', value: left.value || right.value };
-      case '==':
-        return { type: 'BooleanLiteral', value: left.value === right.value };
-      case '!=':
-        return { type: 'BooleanLiteral', value: left.value !== right.value };
-    }
-  }
-
-  return null;
-}
-
-/**
- * Evaluate a unary operation with a constant operand.
- */
-function evaluateConstantUnaryOp(
-  op: string,
-  operand: NumberLiteral | StringLiteral | BooleanLiteral,
-): ExpressionAST | null {
-  if (op === 'not' && isBooleanLiteral(operand)) {
-    return { type: 'BooleanLiteral', value: !operand.value };
-  }
-
-  if (op === '-' && isNumberLiteral(operand)) {
-    return { type: 'NumberLiteral', value: -operand.value };
-  }
-
-  return null;
-}
-
-/**
- * Convert a literal AST node to its string representation.
- */
-function literalToExprString(node: NumberLiteral | StringLiteral | BooleanLiteral): string {
-  switch (node.type) {
-    case 'NumberLiteral':
-      return String(node.value);
-    case 'StringLiteral':
-      return `"${node.value}"`;
-    case 'BooleanLiteral':
-      return String(node.value);
-  }
-}
-
-// ============================================================================
-// Dead Code Elimination
-// ============================================================================
-
-/**
- * Remove unreachable code.
- *
- * This pass identifies and removes branches that can never be reached.
- * Examples:
- *   - Remove if branches with constant false conditions
- *   - Remove decision table rows with always-false conditions
- *   - Remove decision table rows that can never match after previous rows
- *
- * @param ast - The compiled AST to optimize
- * @returns The AST with dead code removed
- */
-function deadCodeElimination(ast: CompiledAST): CompiledAST {
-  const optimized = JSON.parse(JSON.stringify(ast)) as JDMDecision;
-
-  optimized.nodes = optimized.nodes.map((node: JDMNode) => eliminateDeadCodeInNode(node));
-
-  return optimized;
-}
-
-/**
- * Apply dead code elimination to a node.
- */
-function eliminateDeadCodeInNode(node: JDMNode): JDMNode {
-  if (!node.content) {
-    return node;
-  }
-
-  const content = node.content;
-
-  if (node.type === NodeType.DECISION_TABLE) {
-    return eliminateDeadCodeInDecisionTable(node, content);
-  }
-
-  if (node.type === NodeType.SWITCH) {
-    return eliminateDeadCodeInSwitch(node, content);
-  }
-
-  return node;
-}
-
-/**
- * Check if a unary expression is always false.
- * In unary mode, "false" is equivalent to "$ == false".
- */
-function isUnaryAlwaysFalse(expr: ExpressionAST): boolean {
-  if (isBinaryOp(expr) && expr.op === '==') {
-    const leftIsDollar = expr.left.type === 'DollarRef';
-    const rightIsFalse = isBooleanLiteral(expr.right) && !expr.right.value;
-    return leftIsDollar && rightIsFalse;
-  }
-
-  if (isBinaryOp(expr) && expr.op === '!=') {
-    const leftIsDollar = expr.left.type === 'DollarRef';
-    const rightIsTrue = isBooleanLiteral(expr.right) && expr.right.value;
-    return leftIsDollar && rightIsTrue;
-  }
-
-  return false;
-}
-
-/**
- * Eliminate dead code in decision table nodes.
- */
-function eliminateDeadCodeInSwitch(node: JDMNode, content: any): JDMNode {
-  const { conditions } = content;
-
-  // Filter out conditions that are always false
-  const liveConditions = conditions.filter((condition: any) => {
-    const expr = condition.expression;
-    if (!expr || expr === '') {
-      return true;
-    }
-
-    try {
-      const parsed = cachedParseStandard(node, expr);
-
-      if (isBooleanLiteral(parsed) && !parsed.value) {
-        return false;
-      }
-    } catch {}
-
-    return true;
-  });
-
-  return {
-    ...node,
-    content: {
-      ...content,
-      conditions: liveConditions,
-    },
-  };
-}
-
-/**
- * Eliminate dead code in decision table nodes.
- */
-function eliminateDeadCodeInDecisionTable(node: JDMNode, content: any): JDMNode {
-  const { rules, inputs } = content;
-
-  // Filter out rules that have a non-trivial always-false condition
-  const liveRules = rules.filter((rule: any) => {
-    for (const input of inputs) {
-      const expr = rule[input.id];
-      if (!expr || expr === '' || expr === '-') {
-        continue;
-      }
-
-      try {
-        const parsed = cachedParseUnary(node, expr);
-
-        // Check if this is a boolean literal (not common in unary mode, but possible)
-        if (isBooleanLiteral(parsed) && !parsed.value) {
-          return false;
-        }
-
-        // Check if this is a unary expression that's always false
-        // e.g., "false" in a decision table cell is interpreted as "$ == false"
-        if (isUnaryAlwaysFalse(parsed)) {
-          return false;
-        }
-      } catch {
-        // If we can't parse it, assume the rule is live
-      }
-    }
-
-    return true;
-  });
-
-  return {
-    ...node,
-    content: {
-      ...content,
-      rules: liveRules,
-    },
-  };
-}
-
-// ============================================================================
-// Expression Inlining
-// ============================================================================
-
-/**
- * Inline small expressions.
- *
- * This pass replaces function calls with evaluated results for pure functions.
- * Examples:
- *   - Inline small arithmetic operations in decision table cells
- *   - Pre-evaluate expressions that don't depend on runtime values
- *
- * @param ast - The compiled AST to optimize
- * @returns The AST with inlined expressions
- */
-function expressionInlining(ast: CompiledAST): CompiledAST {
-  // Create a deep copy to avoid mutating the original
-  const optimized = JSON.parse(JSON.stringify(ast)) as JDMDecision;
-
-  // Only functions without side effects can be safely evaluated at compile time. Arithmetic
-  // (sum, max, min, abs, floor, ceil, round) and string functions (upper, lower, len) are
-  // pure and deterministic, so their results with constant inputs are predictable.
-  optimized.nodes = optimized.nodes.map((node: JDMNode) => inlineExpressionsInNode(node));
-
-  return optimized;
-}
-
-/**
- * Apply expression inlining to a node.
- */
-function inlineExpressionsInNode(node: JDMNode): JDMNode {
-  if (!node.content) {
-    return node;
-  }
-
-  const content = node.content;
-
-  // Handle decision table nodes
-  if (node.type === NodeType.DECISION_TABLE && content && content.rules && content.inputs) {
-    return inlineDecisionTableExpressions(node, content);
-  }
-
-  return node;
-}
-
-/**
- * Inline expressions in decision table nodes.
- */
-function inlineDecisionTableExpressions(node: JDMNode, content: any): JDMNode {
-  const { rules, inputs } = content;
-
-  const inlinedRules = rules.map((rule: any) => {
-    const inlinedRule = { ...rule };
-
-    for (const input of inputs) {
-      const expr = rule[input.id];
-      if (!expr || expr === '' || expr === '-') {
-        continue;
-      }
-
-      const inlined = tryInlineExpression(expr);
-      if (inlined !== expr) {
-        inlinedRule[input.id] = inlined;
-      }
-    }
-
-    return inlinedRule;
-  });
-
-  return {
-    ...node,
-    content: {
-      ...content,
-      rules: inlinedRules,
-    },
-  };
-}
-
-/**
- * Try to inline an expression by evaluating simple pure function calls.
- * Returns the inlined expression string, or the original if inlining is not possible.
- */
-function tryInlineExpression(expr: string): string {
-  const trimmed = expr.trim();
-
-  // Inline simple arithmetic operations wrapped in function notation
-  // Examples: sum(2, 3) → 5, min(10, 5) → 5, abs(-5) → 5, upper("hello") → "HELLO"
-
-  // Match sum(a, b, ...) pattern where all arguments are numeric literals
-  const sumMatch = trimmed.match(/^sum\((.+)\)$/i);
-  if (sumMatch) {
-    const args = sumMatch[1].split(',').map((s: string) => s.trim());
-    if (args.every((arg: string) => /^-?\d+\.?\d*$/.test(arg))) {
-      const sum = args.reduce((acc: number, arg: string) => acc + parseFloat(arg), 0);
-      return String(sum);
-    }
-  }
-
-  // Match max(a, b) pattern where both arguments are numeric literals
-  const maxMatch = trimmed.match(/^max\((.+),(.+)\)$/i);
-  if (maxMatch) {
-    const [_, arg1, arg2] = maxMatch;
-    const num1 = parseFloat(arg1.trim());
-    const num2 = parseFloat(arg2.trim());
-    if (!isNaN(num1) && !isNaN(num2)) {
-      return String(Math.max(num1, num2));
-    }
-  }
-
-  // Match min(a, b) pattern where both arguments are numeric literals
-  const minMatch = trimmed.match(/^min\((.+),(.+)\)$/i);
-  if (minMatch) {
-    const [_, arg1, arg2] = minMatch;
-    const num1 = parseFloat(arg1.trim());
-    const num2 = parseFloat(arg2.trim());
-    if (!isNaN(num1) && !isNaN(num2)) {
-      return String(Math.min(num1, num2));
-    }
-  }
-
-  // Match abs(a) pattern where argument is a numeric literal
-  const absMatch = trimmed.match(/^abs\((.+)\)$/i);
-  if (absMatch) {
-    const val = parseFloat(absMatch[1].trim());
-    if (!isNaN(val)) {
-      return String(Math.abs(val));
-    }
-  }
-
-  // Match floor(a) pattern where argument is a numeric literal
-  const floorMatch = trimmed.match(/^floor\((.+)\)$/i);
-  if (floorMatch) {
-    const val = parseFloat(floorMatch[1].trim());
-    if (!isNaN(val)) {
-      return String(Math.floor(val));
-    }
-  }
-
-  // Match ceil(a) pattern where argument is a numeric literal
-  const ceilMatch = trimmed.match(/^ceil\((.+)\)$/i);
-  if (ceilMatch) {
-    const val = parseFloat(ceilMatch[1].trim());
-    if (!isNaN(val)) {
-      return String(Math.ceil(val));
-    }
-  }
-
-  // Match round(a) pattern where argument is a numeric literal
-  const roundMatch = trimmed.match(/^round\((.+)\)$/i);
-  if (roundMatch) {
-    const val = parseFloat(roundMatch[1].trim());
-    if (!isNaN(val)) {
-      return String(Math.round(val));
-    }
-  }
-
-  // Match upper("string") pattern for constant string literals
-  const upperMatch = trimmed.match(/^upper\("(.+)"\)$/i);
-  if (upperMatch) {
-    return `"${upperMatch[1].toUpperCase()}"`;
-  }
-
-  // Match lower("string") pattern for constant string literals
-  const lowerMatch = trimmed.match(/^lower\("(.+)"\)$/i);
-  if (lowerMatch) {
-    return `"${lowerMatch[1].toLowerCase()}"`;
-  }
-
-  // Match len("string") pattern for constant string literals
-  const lenMatch = trimmed.match(/^len\("(.*)"\)$/i);
-  if (lenMatch) {
-    return String(lenMatch[1].length);
-  }
-
-  // Match len(123) pattern for numeric literals (counting digits excluding sign)
-  const lenNumMatch = trimmed.match(/^len\(-?\d+\.?\d*\)$/i);
-  if (lenNumMatch) {
-    const numStr = trimmed.match(/^len\((.+)\)$/i)![1].trim();
-    // Count digits ignoring sign and decimal point
-    const digitCount = numStr.replace(/^-/, '').replace('.', '').length;
-    return String(digitCount);
-  }
-
-  return expr;
-}
-
-// ============================================================================
-// Table Indexing
-// ============================================================================
-
-/**
- * Build index structures for efficient table lookup.
- *
- * This pass transforms linear search structures into more efficient alternatives.
- * Examples:
- *   - Convert decision table rows with equality checks to index-based lookup
- *   - Mark tables that are good candidates for switch statement generation
- *
- * Table indexing converts O(n) linear search to O(1) hash lookup when all rules check
- * equality on a single column with unique values - this is common in lookup tables
- * (e.g., pricing tiers by customer type) and can improve evaluation time by 10-100x
- * for large tables.
- *
- * @param ast - The compiled AST to optimize
- * @returns The AST with optimized table lookups
- */
-function tableIndexing(ast: CompiledAST): CompiledAST {
-  const optimized = JSON.parse(JSON.stringify(ast)) as JDMDecision;
-
-  optimized.nodes = optimized.nodes.map((node: JDMNode) => indexTableInNode(node));
-
-  return optimized;
-}
-
-/**
- * Apply table indexing to a node.
- */
-function indexTableInNode(node: JDMNode): JDMNode {
-  if (!node.content) {
-    return node;
-  }
-
-  const content = node.content;
-
-  if (node.type === NodeType.DECISION_TABLE) {
-    return indexDecisionTable(node, content);
-  }
-
-  return node;
-}
-
-/**
- * Index decision table for efficient lookup.
- *
- * This pass analyzes the decision table to identify patterns that can be
- * optimized, such as equality checks on a single column that could be
- * converted to a switch statement or hash map.
- */
-function indexDecisionTable(node: JDMNode, content: any): JDMNode {
-  const { rules, inputs } = content;
-
-  // Analyze each input column to find indexing opportunities
-  const indexedInputs = inputs.map((input: any) => {
-    const inputValues = rules.map((rule: any) => {
-      const expr = rule[input.id];
-      if (!expr || expr === '' || expr === '-') {
-        return null;
-      }
-      return expr.trim();
-    });
-
-    // Check if this column is a good candidate for indexing:
-    // - All values are string or number literals
-    // - No intervals or complex expressions
-    // - No duplicate values
-    const allLiterals = inputValues.every((val: string | null) => {
-      if (!val) {
-        return true;
-      }
-      return /^(["'])(?:(?=(\\?))\2.)*?\1$|^-?\d+\.?\d*$/.test(val);
-    });
-
-    const uniqueValues = new Set(inputValues.filter((v: string | null) => v !== null));
-    const hasDuplicates =
-      uniqueValues.size < inputValues.filter((v: string | null) => v !== null).length;
-
-    return {
-      ...input,
-      // Hash-based lookup becomes beneficial with ~10+ unique values, but overhead matters
-      // for small tables. 50 is a practical limit where indexing provides clear wins without
-      // excessive memory for the lookup structure.
-      _indexable: allLiterals && !hasDuplicates && uniqueValues.size > 0 && uniqueValues.size < 50,
-      _uniqueValues: Array.from(uniqueValues),
-    };
-  });
-
-  return {
-    ...node,
-    content: {
-      ...content,
-      inputs: indexedInputs,
-    },
-  };
-}