@divmain/jdm-asm 0.2.0

package/src/compiler/optimizer.ts

@@ -0,0 +1,948 @@
+/**
+ * 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,
+    },
+  };
+}