Merge pull request #3 from btc-vision/closures

Refactor closure capture analysis and remove collectCapturedNames

Author: BlobMaster41

src/compiler.ts

@@ -51,3 +51,182 @@ function testSharedEnvironment(): i32 {
  return getter();
 }
 assert(testSharedEnvironment() == 50);
+
+// ============================================================================
+// Tests for closure capture from various control flow constructs
+// ============================================================================
+
+// Test 7: Capture from while loop
+function testCaptureInWhile(): i32 {
+ let sum = 0;
+ let i = 0;
+ while (i < 3) {
+ let adder = (): void => { sum = sum + i; };
+ adder();
+ i++;
+ }
+ return sum; // 0 + 1 + 2 = 3
+}
+assert(testCaptureInWhile() == 3);
+
+// Test 8: Capture from do-while loop
+function testCaptureInDoWhile(): i32 {
+ let product = 1;
+ let i = 1;
+ do {
+ let multiplier = (): void => { product = product * i; };
+ multiplier();
+ i++;
+ } while (i <= 4);
+ return product; // 1 * 1 * 2 * 3 * 4 = 24
+}
+assert(testCaptureInDoWhile() == 24);
+
+// Test 9: Capture from for loop
+function testCaptureInFor(): i32 {
+ let result = 0;
+ for (let i = 1; i <= 5; i++) {
+ let addI = (): void => { result = result + i; };
+ addI();
+ }
+ return result; // 1 + 2 + 3 + 4 + 5 = 15
+}
+assert(testCaptureInFor() == 15);
+
+// Test 10: Capture from switch statement
+function testCaptureInSwitch(x: i32): i32 {
+ let captured = 0;
+ switch (x) {
+ case 1: {
+ let setCaptured = (): void => { captured = 10; };
+ setCaptured();
+ break;
+ }
+ case 2: {
+ let setCaptured = (): void => { captured = 20; };
+ setCaptured();
+ break;
+ }
+ default: {
+ let setCaptured = (): void => { captured = 99; };
+ setCaptured();
+ break;
+ }
+ }
+ return captured;
+}
+assert(testCaptureInSwitch(1) == 10);
+assert(testCaptureInSwitch(2) == 20);
+assert(testCaptureInSwitch(3) == 99);
+
+// Test 11: Capture from array literal
+function testCaptureInArrayLiteral(): i32 {
+ let x = 5;
+ let y = 10;
+ let fns = [
+ (): i32 => x,
+ (): i32 => y,
+ (): i32 => x + y
+ ];
+ return fns[0]() + fns[1]() + fns[2](); // 5 + 10 + 15 = 30
+}
+assert(testCaptureInArrayLiteral() == 30);
+
+// Test 12: Closure returning closure (nested capture)
+function testNestedClosureCapture(): i32 {
+ let outer = 100;
+ let makeAdder = (): (y: i32) => i32 => {
+ return (y: i32): i32 => outer + y;
+ };
+ let adder = makeAdder();
+ return adder(23); // 100 + 23 = 123
+}
+assert(testNestedClosureCapture() == 123);
+
+// Test 13: Multiple closures in array capturing same variable
+function testMultipleClosuresInArray(): i32 {
+ let shared = 0;
+ let incrementers: Array<() => void> = [];
+
+ for (let i = 0; i < 3; i++) {
+ incrementers.push((): void => { shared = shared + 1; });
+ }
+
+ for (let i = 0; i < incrementers.length; i++) {
+ incrementers[i]();
+ }
+
+ return shared; // Should be 3
+}
+assert(testMultipleClosuresInArray() == 3);
+
+// Test 14: Closure with ternary expression using captured variable
+function testCaptureInTernary(): i32 {
+ let flag = true;
+ let a = 10;
+ let b = 20;
+ let chooser = (): i32 => flag ? a : b;
+
+ assert(chooser() == 10);
+ flag = false;
+ return chooser(); // Should be 20 now
+}
+assert(testCaptureInTernary() == 20);
+
+// Test 15: Closure capturing from condition expression
+function testCaptureFromCondition(): i32 {
+ let threshold = 50;
+ let value = 75;
+ let isAboveThreshold = (): bool => value > threshold;
+
+ assert(isAboveThreshold() == true);
+ value = 25;
+ return isAboveThreshold() ? 1 : 0; // Should be 0
+}
+assert(testCaptureFromCondition() == 0);
+
+// Test 16: Deeply nested loops with closure
+function testDeepLoopCapture(): i32 {
+ let total = 0;
+ for (let i = 0; i < 2; i++) {
+ for (let j = 0; j < 2; j++) {
+ let addBoth = (): void => { total = total + i + j; };
+ addBoth();
+ }
+ }
+ // i=0,j=0: +0, i=0,j=1: +1, i=1,j=0: +1, i=1,j=1: +2 = 4
+ return total;
+}
+assert(testDeepLoopCapture() == 4);
+
+// Test 17: Closure capturing counter pattern
+function makeCounter(): () => i32 {
+ let count = 0;
+ return (): i32 => {
+ count = count + 1;
+ return count;
+ };
+}
+let counter1 = makeCounter();
+let counter2 = makeCounter();
+assert(counter1() == 1);
+assert(counter1() == 2);
+assert(counter2() == 1); // Independent counter
+assert(counter1() == 3);
+assert(counter2() == 2);
+
+// Test 18: Closure with parameter default value capturing outer variable
+function testDefaultParamCapture(): i32 {
+ let defaultVal = 42;
+ let fn = (x: i32 = defaultVal): i32 => x;
+ return fn();
+}
+assert(testDefaultParamCapture() == 42);
+
+// Test 19: Closure with parameter default value using another param
+function testDefaultParamWithOtherParam(): i32 {
+ let multiplier = 3;
+ let fn = (a: i32, b: i32 = a * multiplier): i32 => b;
+ return fn(10); // b defaults to 10 * 3 = 30
+}
+assert(testDefaultParamWithOtherParam() == 30);