fix: alpha renaming with multiple clashes

Author: CATISNOTSODIUM

src/tracer/__tests__/__snapshots__/tracer_full.ts.snap

@@ -93,26 +93,18 @@ test('function calling', () => {
 */
 test('general', () => {
   const code = `
-       function repeat_pattern(n, p, r) {
-    function twice_p(r) {
-        return p(p(r));
-    }
-    return n === 0
-        ? r
-        : n % 2 !== 0
-          ? repeat_pattern(n - 1, p, p(r))
-          : repeat_pattern(n / 2, twice_p, r);
-}
-
-function plus_one(x) {
-    return x + 1;
-}
-
-repeat_pattern(5, plus_one, 0);
+const f = x => {
+    const x_1 = 1;
+  return x_1 => x_2 + g();  
+};
+  const g = () => x + x_1;
+  const x_2 = 0;
+  const x_1 = 2;
+  const x = 1;
+  f(1)(1);
   `
   const program = parse(code, { ecmaVersion: 10 })!
-  const steps = getSteps(convert(program), {stepLimit: 200})
+  const steps = getSteps(convert(program), { stepLimit: 200 })
   const output = steps.map(stringifyWithExplanation)
-  console.log(output.join('\n'))
+  console.log(output)
 })
-

src/tracer/__tests__/tracer_debug.ts

@@ -331,6 +331,23 @@ describe('Alpha renaming', () => {
     expect(steps[steps.length - 1]).toEqual('3;\n[noMarker] Evaluation complete\n')
   })
 
+  test(`multiple clash for lambda function with block expression`, async () => {
+    const code = `
+      const f = x => {
+        const x_1 = 1;
+        return x_1 => x_2 + g();  
+      };
+      const g = () => x + x_1;
+      const x_2 = 0;
+      const x_1 = 2;
+      const x = 1;
+      f(1)(1);
+      `
+    const steps = await codify(acornParser(code))
+    expect(steps.join('\n')).toMatchSnapshot()
+    expect(steps[steps.length - 1]).toEqual('3;\n[noMarker] Evaluation complete\n')
+  })
+
   test(`multiple clash 2 for function expression`, async () => {
     const code = `
       function f(x) {
@@ -1308,4 +1325,20 @@ describe(`Expressions: conditionals`, () => {
     expect(steps.join('\n')).toMatchSnapshot()
     expect(steps[steps.length - 1]).toEqual('5;\n[noMarker] Evaluation complete\n')
   })
-})
+})
+
+
+// Other tests
+test("Church numerals", async () => {
+  const code = `
+  const one = f => x => f(x);
+  const inc = a => f => x => f(a(f)(x));
+  const decode = a => a(x => x + 1)(0);
+  decode(inc(inc(one))) === 3;
+  
+  `
+  const steps = await codify(acornParser(code))
+  expect(steps.join('\n')).toMatchSnapshot()
+  expect(steps.join('\n')).toMatchSnapshot()
+  expect(steps[steps.length - 1]).toEqual('true;\n[noMarker] Evaluation complete\n')
+});

src/tracer/__tests__/tracer_full.ts

@@ -8,5 +8,6 @@ export interface StepperBaseNode {
   oneStep(): StepperBaseNode
   substitute(id: StepperPattern, value: StepperExpression): StepperBaseNode
   freeNames(): string[]
+  allNames(): string[]
   rename(before: string, after: string): StepperBaseNode
 }

src/tracer/interface.ts

@@ -81,6 +81,14 @@ export class StepperArrayExpression implements ArrayExpression, StepperBaseNode
     return Array.from(new Set(names))
   }
 
+  allNames(): string[] {
+    const names = this.elements
+      .filter(element => element !== null)
+      .map(element => element!.allNames())
+      .flat()
+    return Array.from(new Set(names))
+  }
+
   rename(before: string, after: string): StepperExpression {
     return new StepperArrayExpression(
       this.elements.map(element => (element ? element.rename(before, after) : null))

src/tracer/nodes/Expression/ArrayExpression.ts

@@ -89,7 +89,7 @@ export class StepperArrowFunctionExpression implements ArrowFunctionExpression,
 
   scanAllDeclarationNames(): string[] {
     const paramNames = this.params.map(param => param.name);
-    
+
     let bodyDeclarations: string[] = [];
     // @ts-ignore
     if (this.body.type === 'BlockStatement') {
@@ -103,24 +103,32 @@ export class StepperArrowFunctionExpression implements ArrowFunctionExpression,
     return [...paramNames, ...bodyDeclarations];
   }
 
-  substitute(id: StepperPattern, value: StepperExpression): StepperExpression {
+  // TODO: Fix name handling for lambda
+  substitute(id: StepperPattern, value: StepperExpression, upperBoundName?: string[]): StepperExpression {
     const valueFreeNames = value.freeNames()
     const scopeNames = this.scanAllDeclarationNames()
     const repeatedNames = valueFreeNames.filter(name => scopeNames.includes(name))
 
     var currentArrowFunction: StepperArrowFunctionExpression = this;
-    for (var index in repeatedNames) {
-      const name = repeatedNames[index]
-      currentArrowFunction = currentArrowFunction.rename(name, getFreshName(name)) as StepperArrowFunctionExpression
+    let protectedNamesSet = new Set([this.allNames(), upperBoundName ?? []].flat());
+    repeatedNames.forEach(name => protectedNamesSet.delete(name));
+    const protectedNames = Array.from(protectedNamesSet);
+    const newNames = getFreshName(repeatedNames, protectedNames);
+    for (var index in newNames) {
+      currentArrowFunction = currentArrowFunction
+        .rename(repeatedNames[index], newNames[index]) as StepperArrowFunctionExpression
     }
 
+
     if (currentArrowFunction.scanAllDeclarationNames().includes(id.name)) {
       return currentArrowFunction;
     }
 
     return new StepperArrowFunctionExpression(
         currentArrowFunction.params,
-        currentArrowFunction.body.substitute(id, value),
+        currentArrowFunction.body.substitute(id, 
+          value, 
+          currentArrowFunction.params.flatMap(p => p.allNames())),
         currentArrowFunction.name
     )
   }
@@ -132,6 +140,13 @@ export class StepperArrowFunctionExpression implements ArrowFunctionExpression,
     return this.body.freeNames().filter(name => !paramNames.includes(name))
   }
 
+  allNames(): string[] {
+    const paramNames = this.params
+      .filter(param => param.type === 'Identifier')
+      .map(param => param.name)
+    return Array.from(new Set([paramNames, this.body.allNames()].flat()))
+  }
+
   rename(before: string, after: string): StepperExpression {
     return new StepperArrowFunctionExpression(
       this.params.map(param => param.rename(before, after)),
@@ -143,3 +158,5 @@ export class StepperArrowFunctionExpression implements ArrowFunctionExpression,
     )
   }
 }
+
+

src/tracer/nodes/Expression/ArrowFunctionExpression.ts

@@ -134,6 +134,10 @@ export class StepperBinaryExpression implements BinaryExpression, StepperBaseNod
     return Array.from(new Set([this.left.freeNames(), this.right.freeNames()].flat()));
   }
 
+  allNames(): string[] {
+    return Array.from(new Set([this.left.allNames(), this.right.allNames()].flat()));
+  }
+
   rename(before: string, after: string): StepperExpression  {
     return new StepperBinaryExpression(this.operator, 
         this.left.rename(before, after), this.right.rename(before, after));

src/tracer/nodes/Expression/BinaryExpression.ts

@@ -149,8 +149,13 @@ export class StepperBlockExpression implements StepperBaseNode {
     const scopeNames = this.scanAllDeclarationNames();
     const repeatedNames = valueFreeNames.filter(name => scopeNames.includes(name));
     let currentBlockExpression: StepperBlockExpression = this;
-    for (const name of repeatedNames) {
-      currentBlockExpression = currentBlockExpression.rename(name, getFreshName(name)) as StepperBlockExpression;
+    let protectedNamesSet = new Set(this.allNames());
+    repeatedNames.forEach(name => protectedNamesSet.delete(name));
+    const protectedNames = Array.from(protectedNamesSet);
+    const newNames = getFreshName(repeatedNames, protectedNames);
+    for (var index in newNames) {
+      currentBlockExpression = currentBlockExpression
+        .rename(repeatedNames[index], newNames[index]) as StepperBlockExpression
     }
 
     if (currentBlockExpression.scanAllDeclarationNames().includes(id.name)) {
@@ -174,6 +179,10 @@ export class StepperBlockExpression implements StepperBaseNode {
     return Array.from(names);
   }
 
+  allNames(): string[] {
+    return Array.from(new Set(this.body.flatMap((ast) => ast.allNames())));
+  }
+
   rename(before: string, after: string): StepperBlockExpression {
     return new StepperBlockExpression(
       this.body.map(statement => statement.rename(before, after) as StepperStatement)

src/tracer/nodes/Expression/BlockExpression.ts

@@ -96,6 +96,14 @@ export class StepperConditionalExpression implements ConditionalExpression, Step
     ]))
   }
 
+  allNames(): string[] {
+    return Array.from(new Set([
+      ...this.test.allNames(),
+      ...this.consequent.allNames(),
+      ...this.alternate.allNames()
+    ]))
+  }
+
   rename(before: string, after: string): StepperExpression {
     return new StepperConditionalExpression(
       this.test.rename(before, after),

src/tracer/nodes/Expression/ConditionalExpression.ts

@@ -154,6 +154,13 @@ export class StepperFunctionApplication implements SimpleCallExpression, Stepper
     ]))
   }
 
+  allNames(): string[] {
+    return Array.from(new Set([
+      ...this.callee.allNames(),
+      ...this.arguments.flatMap(arg => arg.allNames())
+    ]))
+  }
+
   rename(before: string, after: string): StepperExpression {
     return new StepperFunctionApplication(
       this.callee.rename(before, after),