Fix stepper: no precheck for undefined variables (#1469)

* Fix stepper: no precheck for undefined variables (#1468)

* fix: enable preludes in precheck

* update snap file

* update test cases and snap files

* add one test case

Author: Ziwen510

src/stepper/__tests__/__snapshots__/stepper.ts.snap

@@ -4166,31 +4166,6 @@ f(undefined);
 "
 `;
 
-exports[`correctly avoids capture by other parameter names 1`] = `
-"function f(g, x) {
-  return g(x);
-}
-f(y => x + 1, 2);
-
-function f(g, x) {
-  return g(x);
-}
-f(y => x + 1, 2);
-
-f(y => x + 1, 2);
-
-f(y => x + 1, 2);
-
-(y => x + 1)(2);
-
-(y => x + 1)(2);
-
-x + 1;
-
-x + 1;
-"
-`;
-
 exports[`expmod 1`] = `
 "function is_even(n) {
   return n % 2 === 0;
@@ -7248,97 +7223,6 @@ g();
 "
 `;
 
-exports[`scoping test for block expressions, with renaming 1`] = `
-"function f(w) {
-  return g();
-}
-function h(f) {
-  function g() {
-    return w;
-  }
-  const w = 0;
-  return f(1);
-}
-h(f);
-
-function f(w) {
-  return g();
-}
-function h(f) {
-  function g() {
-    return w;
-  }
-  const w = 0;
-  return f(1);
-}
-h(f);
-
-function h(f) {
-  function g() {
-    return w;
-  }
-  const w = 0;
-  return f(1);
-}
-h(f);
-
-function h(f) {
-  function g() {
-    return w;
-  }
-  const w = 0;
-  return f(1);
-}
-h(f);
-
-h(f);
-
-h(f);
-
-{
-  function g_1() {
-    return w;
-  }
-  const w = 0;
-  return f(1);
-};
-
-{
-  function g_1() {
-    return w;
-  }
-  const w = 0;
-  return f(1);
-};
-
-{
-  const w = 0;
-  return f(1);
-};
-
-{
-  const w = 0;
-  return f(1);
-};
-
-{
-  return f(1);
-};
-
-{
-  return f(1);
-};
-
-f(1);
-
-f(1);
-
-g();
-
-g();
-"
-`;
-
 exports[`scoping test for blocks nested in lambda expressions 1`] = `
 "const f = x => {
   g();

src/stepper/__tests__/stepper.ts

@@ -186,28 +186,26 @@ test('Test unary and binary boolean operations', () => {
 
 test('Test ternary operator', () => {
   const code = `
-  1 + -1 === 0
-    ? false ? garbage : Infinity
-    : anotherGarbage;
+  1 + -1 === 0 ? false ? true : Infinity : undefined;
   `
   const program = parse(code, mockContext())!
   const steps = getEvaluationSteps(program, mockContext(), 1000)
   expect(steps.map(x => codify(x[0])).join('\n')).toMatchInlineSnapshot(`
-    "1 + -1 === 0 ? false ? garbage : Infinity : anotherGarbage;
+    "1 + -1 === 0 ? false ? true : Infinity : undefined;
 
-    1 + -1 === 0 ? false ? garbage : Infinity : anotherGarbage;
+    1 + -1 === 0 ? false ? true : Infinity : undefined;
 
-    0 === 0 ? false ? garbage : Infinity : anotherGarbage;
+    0 === 0 ? false ? true : Infinity : undefined;
 
-    0 === 0 ? false ? garbage : Infinity : anotherGarbage;
+    0 === 0 ? false ? true : Infinity : undefined;
 
-    true ? false ? garbage : Infinity : anotherGarbage;
+    true ? false ? true : Infinity : undefined;
 
-    true ? false ? garbage : Infinity : anotherGarbage;
+    true ? false ? true : Infinity : undefined;
 
-    false ? garbage : Infinity;
+    false ? true : Infinity;
 
-    false ? garbage : Infinity;
+    false ? true : Infinity;
 
     Infinity;
 
@@ -1013,26 +1011,6 @@ test('scoping test for block expressions, no renaming', () => {
   expect(getLastStepAsString(steps)).toEqual('1;')
 })
 
-test('scoping test for block expressions, with renaming', () => {
-  const code = `
-  function f(w) {
-    return g();
-  }
-  function h(f) {
-      function g() {
-          return w;
-      }
-      const w = 0;
-      return f(1);
-  }
-  h(f);
-  `
-  const program = parse(code, mockContext())!
-  const steps = getEvaluationSteps(program, mockContext(), 1000)
-  expect(steps.map(x => codify(x[0])).join('\n')).toMatchSnapshot()
-  expect(getLastStepAsString(steps)).toEqual('g();')
-})
-
 test('return in nested blocks', () => {
   const code = `
   function f(x) {{ return 1; }}
@@ -1365,19 +1343,6 @@ test(`renaming of outer parameter in lambda function`, () => {
   expect(getLastStepAsString(steps)).toEqual('1;')
 })
 
-test(`correctly avoids capture by other parameter names`, () => {
-  const code = `
-  function f(g, x) {
-      return g(x);
-  }
-  f(y => x + 1, 2);
-  `
-  const program = parse(code, mockContext())!
-  const steps = getEvaluationSteps(program, mockContext(), 1000)
-  expect(steps.map(x => codify(x[0])).join('\n')).toMatchSnapshot()
-  expect(getLastStepAsString(steps)).toEqual('x + 1;')
-})
-
 test(`removes debugger statements`, () => {
   const code = `
   function f(n) {

src/stepper/converter.ts

@@ -91,7 +91,7 @@ function evaluateFunctionObject(node: substituterNodes, context: Context) {
 }
 
 export function objectToString(value: any): string {
-  if ('toReplString' in value) {
+  if (value !== null && 'toReplString' in value) {
     return value.toReplString()
   }
   return '[Object]'

src/stepper/stepper.ts

@@ -25,6 +25,13 @@ import {
 } from '../utils/dummyAstCreator'
 import { evaluateBinaryExpression, evaluateUnaryExpression } from '../utils/operators'
 import * as rttc from '../utils/rttc'
+import {
+  getFunctionDeclarationNamesInProgram,
+  getIdentifiersInNativeStorage,
+  getIdentifiersInProgram,
+  getUniqueId
+} from '../utils/uniqueIds'
+import { ancestor } from '../utils/walkers'
 import { nodeToValue, objectToString, valueToExpression } from './converter'
 import * as builtin from './lib'
 import {
@@ -2501,7 +2508,7 @@ function jsTreeifyMain(
     },
 
     Literal: (target: es.Literal): es.Literal => {
-      if (typeof target.value === 'object') {
+      if (typeof target.value === 'object' && target.value !== null) {
         target.raw = objectToString(target.value)
       }
       return target
@@ -3202,6 +3209,131 @@ function evaluateImports(
   }
 }
 
+const globalIdNames = [
+  'native',
+  'callIfFuncAndRightArgs',
+  'boolOrErr',
+  'wrap',
+  'wrapSourceModule',
+  'unaryOp',
+  'binaryOp',
+  'throwIfTimeout',
+  'setProp',
+  'getProp',
+  'builtins'
+] as const
+type NativeIds = Record<typeof globalIdNames[number], es.Identifier>
+
+function getNativeIds(program: es.Program, usedIdentifiers: Set<string>): NativeIds {
+  const globalIds = {}
+  for (const identifier of globalIdNames) {
+    globalIds[identifier] = ast.identifier(getUniqueId(usedIdentifiers, identifier))
+  }
+  return globalIds as NativeIds
+}
+
+function checkForUndefinedVariables(program: es.Program, context: Context) {
+  const usedIdentifiers = new Set<string>([
+    ...getIdentifiersInProgram(program),
+    ...getIdentifiersInNativeStorage(context.nativeStorage)
+  ])
+  const globalIds = getNativeIds(program, usedIdentifiers)
+
+  const preludes = context.prelude
+    ? getFunctionDeclarationNamesInProgram(parse(context.prelude, context)!)
+    : new Set<String>()
+  const builtins = context.nativeStorage.builtins
+  const identifiersIntroducedByNode = new Map<es.Node, Set<string>>()
+  function processBlock(node: es.Program | es.BlockStatement) {
+    const identifiers = new Set<string>()
+    for (const statement of node.body) {
+      if (statement.type === 'VariableDeclaration') {
+        identifiers.add((statement.declarations[0].id as es.Identifier).name)
+      } else if (statement.type === 'FunctionDeclaration') {
+        if (statement.id === null) {
+          throw new Error(
+            'Encountered a FunctionDeclaration node without an identifier. This should have been caught when parsing.'
+          )
+        }
+        identifiers.add(statement.id.name)
+      } else if (statement.type === 'ImportDeclaration') {
+        for (const specifier of statement.specifiers) {
+          identifiers.add(specifier.local.name)
+        }
+      }
+    }
+    identifiersIntroducedByNode.set(node, identifiers)
+  }
+  function processFunction(
+    node: es.FunctionDeclaration | es.ArrowFunctionExpression,
+    _ancestors: es.Node[]
+  ) {
+    identifiersIntroducedByNode.set(
+      node,
+      new Set(
+        node.params.map(id =>
+          id.type === 'Identifier'
+            ? id.name
+            : ((id as es.RestElement).argument as es.Identifier).name
+        )
+      )
+    )
+  }
+  const identifiersToAncestors = new Map<es.Identifier, es.Node[]>()
+  ancestor(program, {
+    Program: processBlock,
+    BlockStatement: processBlock,
+    FunctionDeclaration: processFunction,
+    ArrowFunctionExpression: processFunction,
+    ForStatement(forStatement: es.ForStatement, ancestors: es.Node[]) {
+      const init = forStatement.init!
+      if (init.type === 'VariableDeclaration') {
+        identifiersIntroducedByNode.set(
+          forStatement,
+          new Set([(init.declarations[0].id as es.Identifier).name])
+        )
+      }
+    },
+    Identifier(identifier: es.Identifier, ancestors: es.Node[]) {
+      identifiersToAncestors.set(identifier, [...ancestors])
+    },
+    Pattern(node: es.Pattern, ancestors: es.Node[]) {
+      if (node.type === 'Identifier') {
+        identifiersToAncestors.set(node, [...ancestors])
+      } else if (node.type === 'MemberExpression') {
+        if (node.object.type === 'Identifier') {
+          identifiersToAncestors.set(node.object, [...ancestors])
+        }
+      }
+    }
+  })
+  const nativeInternalNames = new Set(Object.values(globalIds).map(({ name }) => name))
+
+  for (const [identifier, ancestors] of identifiersToAncestors) {
+    const name = identifier.name
+    const isCurrentlyDeclared = ancestors.some(a => identifiersIntroducedByNode.get(a)?.has(name))
+    if (isCurrentlyDeclared) {
+      continue
+    }
+    const isPreviouslyDeclared = context.nativeStorage.previousProgramsIdentifiers.has(name)
+    if (isPreviouslyDeclared) {
+      continue
+    }
+    const isBuiltin = builtins.has(name)
+    if (isBuiltin) {
+      continue
+    }
+    const isPrelude = preludes.has(name)
+    if (isPrelude) {
+      continue
+    }
+    const isNativeId = nativeInternalNames.has(name)
+    if (!isNativeId) {
+      throw new errors.UndefinedVariable(name, identifier)
+    }
+  }
+}
+
 // the context here is for builtins
 export function getEvaluationSteps(
   program: es.Program,
@@ -3210,6 +3342,7 @@ export function getEvaluationSteps(
 ): [es.Program, string[][], string][] {
   const steps: [es.Program, string[][], string][] = []
   try {
+    checkForUndefinedVariables(program, context)
     const limit = stepLimit === undefined ? 1000 : stepLimit % 2 === 0 ? stepLimit : stepLimit + 1
     evaluateImports(program, context, true, true)
     // starts with substituting predefined constants