fix: #1714 steps appear as if capturing happens

Author: CATISNOTSODIUM

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

@@ -93,18 +93,17 @@ test('function calling', () => {
 */
 test('general', () => {
   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);
+function h(f, x) {
+    function h(g, x) {
+        return x <= 1 ? 1 : 3 * g(f, x - 1);
+    }
+        return x <= 1 ? 1 : 2 * f(h, x - 1);
+    }
+    h(h, 5);
+
   `
   const program = parse(code, { ecmaVersion: 10 })!
   const steps = getSteps(convert(program), { stepLimit: 200 })
   const output = steps.map(stringifyWithExplanation)
-  console.log(output)
+  console.log(output.join('\n\n'))
 })

src/tracer/__tests__/tracer_debug.ts

@@ -1339,6 +1339,20 @@ test("Church numerals", async () => {
   `
   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')
+});
+
+test("steps appear as if capturing happens #1714", async () => {
+  const code = `
+  function h(f, x) {
+    function h(g, x) {
+        return x <= 1 ? 1 : 3 * g(f, x - 1);
+    }
+        return x <= 1 ? 1 : 2 * f(h, x - 1);
+    }
+    h(h, 5);
+  `
+  const steps = await codify(acornParser(code))
+  expect(steps.join('\n')).toMatchSnapshot()
+  expect(steps[steps.length - 1]).toEqual('36;\n[noMarker] Evaluation complete\n')
 });

src/tracer/__tests__/tracer_full.ts

@@ -4,6 +4,7 @@ import { StepperExpression, StepperPattern } from '..'
 import { convert } from '../../generator'
 import { getFreshName } from '../../utils'
 import { StepperBlockStatement } from '../Statement/BlockStatement'
+import { StepperBlockExpression } from './BlockExpression'
 
 export class StepperArrowFunctionExpression implements ArrowFunctionExpression, StepperBaseNode {
   type: 'ArrowFunctionExpression'
@@ -32,7 +33,6 @@ export class StepperArrowFunctionExpression implements ArrowFunctionExpression,
   ) {
     this.type = 'ArrowFunctionExpression'
     this.params = params
-    this.body = body
     this.expression = expression
     this.generator = generator
     this.async = async
@@ -41,6 +41,23 @@ export class StepperArrowFunctionExpression implements ArrowFunctionExpression,
     this.trailingComments = trailingComments
     this.loc = loc
     this.range = range
+
+    // check whether the declarations will not collide with this.name
+    // @ts-expect-error By nature of estree, block expression is a statement. 
+    if (body.type === "BlockStatement" && this.name !== undefined) {
+      const repeatedNames = (body as StepperBlockExpression).scanAllDeclarationNames()
+                              .filter(name => name === this.name);
+      const newNames = getFreshName([this.name], repeatedNames);
+      let currentBlockExpression: StepperBlockExpression = body;
+      for (var index in newNames) {
+        currentBlockExpression = currentBlockExpression
+          .rename(repeatedNames[index], newNames[index]) as StepperBlockExpression
+      }
+      // @ts-expect-error By nature of estree, block expression is a statement.
+      this.body = currentBlockExpression;
+    } else {
+      this.body = body;
+    }
   }
 
   static create(node: ArrowFunctionExpression) {

src/tracer/nodes/Expression/ArrowFunctionExpression.ts

@@ -2,7 +2,7 @@ import { StepperBaseNode } from '../../interface'
 import { StepperExpression, StepperPattern, undefinedNode } from '..'
 import { convert } from '../../generator'
 import { redex } from '../..'
-import { StepperVariableDeclaration, StepperVariableDeclarator } from '../Statement/VariableDeclaration'
+import { StepperVariableDeclaration } from '../Statement/VariableDeclaration'
 import { assignMuTerms, getFreshName } from '../../utils'
 import { StepperReturnStatement } from '../Statement/ReturnStatement'
 import { StepperStatement } from '../Statement'
@@ -168,9 +168,14 @@ export class StepperBlockExpression implements StepperBaseNode {
 
   scanAllDeclarationNames(): string[] {
     return this.body
-      .filter(ast => ast.type === 'VariableDeclaration')
-      .flatMap((ast: StepperVariableDeclaration) => ast.declarations)
-      .map((ast: StepperVariableDeclarator) => ast.id.name);
+      .filter(ast => ast.type === 'VariableDeclaration' || ast.type === 'FunctionDeclaration')
+      .flatMap((ast: StepperVariableDeclaration | StepperFunctionDeclaration) => {
+        if (ast.type === 'VariableDeclaration') {
+          return ast.declarations.map(ast => ast.id.name);
+        } else { // Function Declaration
+          return [(ast as StepperFunctionDeclaration).id.name];
+        }
+      })
   }
 
   freeNames(): string[] {

src/tracer/nodes/Expression/BlockExpression.ts

@@ -5,8 +5,7 @@ import { StepperStatement } from './Statement'
 import { StepperExpression, StepperPattern, undefinedNode } from '.'
 
 import {
-  StepperVariableDeclaration,
-  StepperVariableDeclarator
+  StepperVariableDeclaration
 } from './Statement/VariableDeclaration'
 import { redex } from '..'
 import { assignMuTerms } from '../utils'
@@ -156,9 +155,14 @@ export class StepperProgram implements Program, StepperBaseNode {
 
   scanAllDeclarationNames(): string[] {
     return this.body
-      .filter(ast => ast.type === 'VariableDeclaration')
-      .flatMap((ast: StepperVariableDeclaration) => ast.declarations)
-      .map((ast: StepperVariableDeclarator) => ast.id.name)
+      .filter(ast => ast.type === 'VariableDeclaration' || ast.type === 'FunctionDeclaration')
+      .flatMap((ast: StepperVariableDeclaration | StepperFunctionDeclaration) => {
+        if (ast.type === 'VariableDeclaration') {
+          return ast.declarations.map(ast => ast.id.name);
+        } else { // Function Declaration
+          return [(ast as StepperFunctionDeclaration).id.name];
+        }
+      })
   }
 
   freeNames(): string[] {

src/tracer/nodes/Program.ts

@@ -4,7 +4,7 @@ import { StepperExpression, StepperPattern, undefinedNode } from '..'
 import { StepperStatement } from '.'
 import { convert } from '../../generator'
 import { redex } from '../..'
-import { StepperVariableDeclaration, StepperVariableDeclarator } from './VariableDeclaration'
+import { StepperVariableDeclaration } from './VariableDeclaration'
 import { assignMuTerms, getFreshName } from '../../utils'
 import { StepperFunctionDeclaration } from './FunctionDeclaration'
 import { StepperReturnStatement } from './ReturnStatement'
@@ -200,9 +200,14 @@ export class StepperBlockStatement implements BlockStatement, StepperBaseNode {
 
   scanAllDeclarationNames(): string[] {
     return this.body
-      .filter(ast => ast.type === 'VariableDeclaration')
-      .flatMap((ast: StepperVariableDeclaration) => ast.declarations)
-      .map((ast: StepperVariableDeclarator) => ast.id.name)
+      .filter(ast => ast.type === 'VariableDeclaration' || ast.type === 'FunctionDeclaration')
+      .flatMap((ast: StepperVariableDeclaration | StepperFunctionDeclaration) => {
+        if (ast.type === 'VariableDeclaration') {
+          return ast.declarations.map(ast => ast.id.name);
+        } else { // Function Declaration
+          return [(ast as StepperFunctionDeclaration).id.name];
+        }
+      })
   }
 
   freeNames(): string[] {

src/tracer/nodes/Statement/BlockStatement.ts

@@ -7,6 +7,7 @@ import { convert } from '../../generator'
 import { redex } from '../..'
 import { StepperArrowFunctionExpression } from '../Expression/ArrowFunctionExpression'
 import { getFreshName } from '../../utils'
+import { StepperVariableDeclaration } from './VariableDeclaration'
 
 export class StepperFunctionDeclaration implements FunctionDeclaration, StepperBaseNode {
   type: 'FunctionDeclaration'
@@ -33,16 +34,23 @@ export class StepperFunctionDeclaration implements FunctionDeclaration, StepperB
   ) {
     this.type = 'FunctionDeclaration'
     this.id = id
-    this.body = body
     this.params = params
     this.generator = generator
     this.async = async
     this.leadingComments = leadingComments
     this.trailingComments = trailingComments
     this.loc = loc
     this.range = range
-  }
 
+    
+    const repeatedNames = body.scanAllDeclarationNames().filter(name => name === this.id.name);
+    const newNames = getFreshName([this.id.name], repeatedNames)
+    let currentBlockStatement = body
+    for (var index in newNames) {
+      currentBlockStatement = currentBlockStatement.rename(repeatedNames[index], newNames[index])
+    }
+    this.body = currentBlockStatement;
+  }
   static create(node: FunctionDeclaration) {
     return new StepperFunctionDeclaration(
       convert(node.id) as StepperIdentifier,
@@ -94,25 +102,37 @@ export class StepperFunctionDeclaration implements FunctionDeclaration, StepperB
   scanAllDeclarationNames(): string[] {
     const paramNames = this.params.map(param => param.name)
     const bodyDeclarations = this.body.body
-      .filter(stmt => stmt.type === 'VariableDeclaration')
-      .flatMap(decl => (decl as any).declarations.map((d: any) => d.id.name))
-
+      .filter(ast => ast.type === 'VariableDeclaration' || ast.type === 'FunctionDeclaration')
+      .flatMap((ast: StepperVariableDeclaration | StepperFunctionDeclaration) => {
+        if (ast.type === 'VariableDeclaration') {
+          return ast.declarations.map(ast => ast.id.name)
+        } else {
+          // Function Declaration
+          return [(ast as StepperFunctionDeclaration).id.name]
+        }
+      })
     return [...paramNames, ...bodyDeclarations]
   }
 
-  substitute(id: StepperPattern, value: StepperExpression, upperBoundName?: string[]): StepperBaseNode {
+  substitute(
+    id: StepperPattern,
+    value: StepperExpression,
+    upperBoundName?: string[]
+  ): StepperBaseNode {
     const valueFreeNames = value.freeNames()
     const scopeNames = this.scanAllDeclarationNames()
     const repeatedNames = valueFreeNames.filter(name => scopeNames.includes(name))
 
-    var currentFunction: StepperFunctionDeclaration = this;
-    let protectedNamesSet = new Set([this.allNames(), upperBoundName ?? []].flat());
-    repeatedNames.forEach(name => protectedNamesSet.delete(name));
-    const protectedNames = Array.from(protectedNamesSet);
-    const newNames = getFreshName(repeatedNames, protectedNames);
+    var currentFunction: StepperFunctionDeclaration = this
+    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) {
-      currentFunction = currentFunction
-        .rename(repeatedNames[index], newNames[index]) as StepperFunctionDeclaration
+      currentFunction = currentFunction.rename(
+        repeatedNames[index],
+        newNames[index]
+      ) as StepperFunctionDeclaration
     }
 
     if (currentFunction.scanAllDeclarationNames().includes(id.name)) {
@@ -141,12 +161,12 @@ export class StepperFunctionDeclaration implements FunctionDeclaration, StepperB
     const paramNames = this.params
       .filter(param => param.type === 'Identifier')
       .map(param => param.name)
-    return Array.from(new Set([paramNames, this.body.allNames()].flat()));
+    return Array.from(new Set([paramNames, this.body.allNames()].flat()))
   }
 
   rename(before: string, after: string): StepperFunctionDeclaration {
     return new StepperFunctionDeclaration(
-      this.id,
+      this.id.rename(before, after),
       this.body.rename(before, after) as unknown as StepperBlockStatement,
       this.params.map(param => param.rename(before, after))
     )