@divmain/jdm-asm 0.2.0

package/tests/unit/compiler/optimizer-cache.test.ts

@@ -0,0 +1,327 @@
+import { describe, it, expect, vi } from 'vitest';
+import {
+  runOptimizations,
+  getExpressionCache,
+  clearExpressionCache,
+  constantFolding,
+  deadCodeElimination,
+} from '../../../src/compiler/optimizer';
+import { type JDMDecision, type JDMNode, NodeType } from '../../../src/compiler/parser';
+import * as unaryParser from '../../../src/compiler/unary-parser';
+
+describe('Optimizer Expression Caching', () => {
+  describe('Cache Initialization', () => {
+    it('should create cache on first access', () => {
+      const node: JDMNode = {
+        id: 'test-1',
+        type: NodeType.DECISION_TABLE,
+        name: 'Test',
+        position: { x: 0, y: 0 },
+      };
+
+      const cache = getExpressionCache(node);
+
+      expect(cache).toBeDefined();
+      expect(cache.size).toBe(0);
+      expect(node.parsedContent).toBeDefined();
+      expect(node.parsedContent._cachedExprs).toBe(cache);
+    });
+
+    it('should return existing cache on subsequent access', () => {
+      const node: JDMNode = {
+        id: 'test-2',
+        type: NodeType.DECISION_TABLE,
+        name: 'Test',
+        position: { x: 0, y: 0 },
+      };
+
+      const cache1 = getExpressionCache(node);
+      const cache2 = getExpressionCache(node);
+
+      expect(cache1).toBe(cache2);
+    });
+  });
+
+  describe('Cache Usage During Optimization', () => {
+    it('should cache parsed expressions in constant folding', () => {
+      const ast: JDMDecision = {
+        nodes: [
+          {
+            id: 'dt-1',
+            type: NodeType.DECISION_TABLE,
+            name: 'Test Table',
+            position: { x: 0, y: 0 },
+            content: {
+              inputs: [{ id: 'input1', field: 'x' }],
+              outputs: [{ id: 'output1', field: 'result' }],
+              rules: [
+                { input1: '> 5', output1: '10' },
+                { input1: '> 3', output1: '5' },
+              ],
+            },
+          },
+        ],
+        edges: [],
+      };
+
+      const optimized = constantFolding(ast);
+      const node = optimized.nodes[0];
+      const cache = getExpressionCache(node);
+
+      // The expressions should be cached
+      expect(cache.size).toBeGreaterThan(0);
+    });
+
+    it('should reuse cached expressions across multiple passes', () => {
+      const parseUnaryMock = vi.spyOn(unaryParser, 'parseUnaryExpression');
+      const parseStandardMock = vi.spyOn(unaryParser, 'parseStandardExpression');
+
+      const ast: JDMDecision = {
+        nodes: [
+          {
+            id: 'dt-1',
+            type: NodeType.DECISION_TABLE,
+            name: 'Test Table',
+            position: { x: 0, y: 0 },
+            content: {
+              inputs: [{ id: 'input1', field: 'x' }],
+              outputs: [{ id: 'output1', field: 'result' }],
+              rules: [
+                { input1: '> 5', output1: '10' },
+                { input1: '> 5', output1: '20' }, // Same expression as first rule
+              ],
+            },
+          },
+        ],
+        edges: [],
+      };
+
+      // Run constant folding first
+      const afterFolding = constantFolding(ast);
+      const foldingCalls = parseUnaryMock.mock.calls.length;
+
+      // Clear mock counts
+      parseUnaryMock.mockClear();
+
+      // Run dead code elimination on the already-cached node
+      deadCodeElimination(afterFolding);
+      const dceCalls = parseUnaryMock.mock.calls.length;
+
+      // DCE should use cached expressions, so should parse fewer (or zero) new expressions
+      expect(dceCalls).toBeLessThanOrEqual(foldingCalls);
+
+      parseUnaryMock.mockRestore();
+      parseStandardMock.mockRestore();
+    });
+
+    it('should cache expressions in switch nodes', () => {
+      const ast: JDMDecision = {
+        nodes: [
+          {
+            id: 'switch-1',
+            type: NodeType.SWITCH,
+            name: 'Test Switch',
+            position: { x: 0, y: 0 },
+            content: {
+              conditions: [
+                { id: '1', expression: 'x > 5' },
+                { id: '2', expression: 'x > 3' },
+              ],
+            },
+          },
+        ],
+        edges: [],
+      };
+
+      const optimized = constantFolding(ast);
+      const node = optimized.nodes[0];
+      const cache = getExpressionCache(node);
+
+      expect(cache.size).toBeGreaterThan(0);
+    });
+
+    it('should cache expressions in expression nodes', () => {
+      const ast: JDMDecision = {
+        nodes: [
+          {
+            id: 'expr-1',
+            type: NodeType.EXPRESSION,
+            name: 'Test Expression',
+            position: { x: 0, y: 0 },
+            content: {
+              expression: 'x + y', // Non-foldable expression to preserve cache
+            },
+          },
+        ],
+        edges: [],
+      };
+
+      const optimized = constantFolding(ast);
+      const node = optimized.nodes[0];
+      const cache = getExpressionCache(node);
+
+      // Expression can't be folded, so cache is preserved
+      expect(cache.size).toBeGreaterThan(0);
+    });
+  });
+
+  describe('Cache Invalidation', () => {
+    it('should clear cache when expressions are modified', () => {
+      const ast: JDMDecision = {
+        nodes: [
+          {
+            id: 'expr-1',
+            type: NodeType.EXPRESSION,
+            name: 'Test Expression',
+            position: { x: 0, y: 0 },
+            content: {
+              expression: '2 + 3', // This will be folded to "5"
+            },
+          },
+        ],
+        edges: [],
+      };
+
+      const optimized = constantFolding(ast);
+      const node = optimized.nodes[0];
+      const cache = getExpressionCache(node);
+
+      // After constant folding, the expression changed, so cache should be cleared
+      // The folded expression should be "5", which is different from original
+      expect(node.content.expression).toBe('5');
+
+      // Cache should be empty after modification
+      expect(cache.size).toBe(0);
+    });
+
+    it('should clear cache manually', () => {
+      const node: JDMNode = {
+        id: 'test-1',
+        type: NodeType.DECISION_TABLE,
+        name: 'Test',
+        position: { x: 0, y: 0 },
+      };
+
+      const cache = getExpressionCache(node);
+      cache.set('test', { type: 'NumberLiteral', value: 42 });
+
+      expect(cache.size).toBe(1);
+
+      clearExpressionCache(node);
+
+      expect(cache.size).toBe(0);
+    });
+  });
+
+  describe('Cache Correctness', () => {
+    it('should produce same results with and without cache', () => {
+      const ast: JDMDecision = {
+        nodes: [
+          {
+            id: 'dt-1',
+            type: NodeType.DECISION_TABLE,
+            name: 'Test Table',
+            position: { x: 0, y: 0 },
+            content: {
+              inputs: [{ id: 'input1', field: 'x' }],
+              outputs: [{ id: 'output1', field: 'result' }],
+              rules: [
+                { input1: '> 5', output1: '10' },
+                { input1: '> 3', output1: '5' },
+              ],
+            },
+          },
+        ],
+        edges: [],
+      };
+
+      // Deep clone to avoid sharing state
+      const ast1 = JSON.parse(JSON.stringify(ast));
+      const ast2 = JSON.parse(JSON.stringify(ast));
+
+      // Run optimizations on both
+      const optimized1 = runOptimizations(ast1);
+      const optimized2 = runOptimizations(ast2);
+
+      // Clear cache from both to compare only the content
+      if (optimized1.nodes[0].parsedContent) {
+        delete optimized1.nodes[0].parsedContent._cachedExprs;
+      }
+      if (optimized2.nodes[0].parsedContent) {
+        delete optimized2.nodes[0].parsedContent._cachedExprs;
+      }
+
+      // Results should be identical
+      expect(optimized1).toEqual(optimized2);
+    });
+  });
+
+  describe('Cache with Deep Copy', () => {
+    it('should preserve cache across JSON deep copy in optimization passes', () => {
+      const ast: JDMDecision = {
+        nodes: [
+          {
+            id: 'dt-1',
+            type: NodeType.DECISION_TABLE,
+            name: 'Test Table',
+            position: { x: 0, y: 0 },
+            content: {
+              inputs: [{ id: 'input1', field: 'x' }],
+              outputs: [{ id: 'output1', field: 'result' }],
+              rules: [{ input1: '> 5', output1: '10' }],
+            },
+          },
+        ],
+        edges: [],
+      };
+
+      // First pass builds cache
+      const afterFirstPass = constantFolding(ast);
+      const node1 = afterFirstPass.nodes[0];
+
+      // Note: JSON.parse(JSON.stringify()) will lose the Map cache
+      // This is expected behavior - each optimization pass starts fresh
+      // The cache is useful WITHIN a pass when the same expression appears multiple times
+      expect(getExpressionCache(node1)).toBeDefined();
+    });
+  });
+
+  describe('Cache Performance', () => {
+    it('should reduce parsing calls for duplicate expressions', () => {
+      const parseUnaryMock = vi.spyOn(unaryParser, 'parseUnaryExpression');
+
+      const ast: JDMDecision = {
+        nodes: [
+          {
+            id: 'dt-1',
+            type: NodeType.DECISION_TABLE,
+            name: 'Test Table',
+            position: { x: 0, y: 0 },
+            content: {
+              inputs: [{ id: 'input1', field: 'x' }],
+              outputs: [{ id: 'output1', field: 'result' }],
+              rules: [
+                { input1: '> 5', output1: '10' },
+                { input1: '> 5', output1: '20' }, // Duplicate
+                { input1: '> 5', output1: '30' }, // Duplicate
+                { input1: '> 5', output1: '40' }, // Duplicate
+                { input1: '> 3', output1: '5' },
+                { input1: '> 3', output1: '6' }, // Duplicate
+              ],
+            },
+          },
+        ],
+        edges: [],
+      };
+
+      constantFolding(ast);
+
+      const callCount = parseUnaryMock.mock.calls.length;
+
+      // Should only parse "> 5" once and "> 3" once, total 2 parses (not 6)
+      expect(callCount).toBe(2);
+
+      parseUnaryMock.mockRestore();
+    });
+  });
+});