Relocate svmc repl prompt

Author: leeyi45

README.md

@@ -81,7 +81,6 @@ Currently, valid CHAPTER/VARIANT combinations are:
 - `--chapter=2 --variant=interpreter`
 - `--chapter=2 --variant=typed`
 - `--chapter=3 --variant=default`
-- `--chapter=3 --variant=concurrent`
 - `--chapter=3 --variant=interpreter`
 - `--chapter=3 --variant=typed`
 - `--chapter=4 --variant=default`

docs/lib/concurrency.js

@@ -31,8 +31,6 @@ the members of our learning community.
 
 #### <a href="source_2_typed/">Source §2 Typed</a>
 
-#### <a href="source_3_concurrent/">Source §3 Concurrent</a>
-
 #### <a href="source_3_typed/">Source §3 Typed</a>
 
 #### <a href="source_4_typed/">Source §4 Typed</a>
@@ -58,8 +56,6 @@ the Source Academy.
 
 #### <a href="source_2_typed.pdf">Specification of Source §2 Typed</a>
 
-#### <a href="source_3_concurrent.pdf">Specification of Source §3 Concurrent</a>
-
 #### <a href="source_3_typed.pdf">Specification of Source §3 Typed</a>
 
 #### <a href="source_4_typed.pdf">Specification of Source §4 Typed</a>

docs/md/README_3_CONCURRENT.md

@@ -1,6 +1,6 @@
 PDFLATEX = latexmk -pdf
 
-SPECSNUMS = 1 1_wasm 1_type_inference 1_infinite_loop_detection 1_typed 2 2_typed 3_type_inference 3 3_concurrent 3_typed 4 4_explicitcontrol 4_typed styleguide 2_stepper studio_2 python_1
+SPECSNUMS = 1 1_wasm 1_type_inference 1_infinite_loop_detection 1_typed 2 2_typed 3_type_inference 3 3_typed 4 4_explicitcontrol 4_typed styleguide 2_stepper studio_2 python_1
 
 SPECS = $(SPECSNUMS:%=source_%)
 

docs/md/README_CONCURRENCY.md

@@ -71,20 +71,6 @@ const configs = {
       "pairmutator.js"
     ]
   },
-  "Source §3 Concurrent": {
-    "readme": "README_3_CONCURRENT.md",
-    "dst": "source_3_concurrent/",
-    "libs": [
-      "auxiliary.js",
-      "misc.js",
-      "math.js",
-      "list.js",
-      "stream.js",
-      "array.js",
-      "pairmutator.js",
-      "concurrency.js"
-    ]
-  },
   "Source §3 Typed": {
     "readme": "README_3_TYPED.md",
     "dst": "source_3_typed/",
@@ -190,13 +176,6 @@ const configs = {
       "pairmutator.js"
     ]
   },
-  "CONCURRENCY": {
-    "readme": "README_CONCURRENCY.md",
-    "dst": "CONCURRENCY/",
-    "libs": [
-      "concurrency.js"
-    ]
-  },
   "MCE": {
     "readme": "README_MCE.md",
     "dst": "MCE/",

docs/md/README_top.md

@@ -35,7 +35,6 @@ export const sourceLanguages: Language[] = [
   { chapter: Chapter.SOURCE_2, variant: Variant.TYPED },
   { chapter: Chapter.SOURCE_3, variant: Variant.DEFAULT },
   { chapter: Chapter.SOURCE_3, variant: Variant.TYPED },
-  { chapter: Chapter.SOURCE_3, variant: Variant.CONCURRENT },
   { chapter: Chapter.SOURCE_4, variant: Variant.DEFAULT },
   { chapter: Chapter.SOURCE_4, variant: Variant.TYPED },
   { chapter: Chapter.SOURCE_4, variant: Variant.EXPLICIT_CONTROL }

docs/specs/Makefile

@@ -11,7 +11,6 @@ import {
 import { GLOBAL, JSSLANG_PROPERTIES } from './constants'
 import { call_with_current_continuation } from './cse-machine/continuations'
 import Heap from './cse-machine/heap'
-import { AsyncScheduler } from './schedulers'
 import * as list from './stdlib/list'
 import { list_to_vector } from './stdlib/list'
 import { listPrelude } from './stdlib/list.prelude'
@@ -121,7 +120,6 @@ const createEmptyDebugger = () => ({
     it: (function* (): any {
       return
     })(),
-    scheduler: new AsyncScheduler()
   }
 })
 

docs/specs/source_3_concurrent.tex

@@ -4,7 +4,6 @@ import * as source_1_typed from './source_1_typed.json'
 import * as source_2 from './source_2.json'
 import * as source_2_typed from './source_2_typed.json'
 import * as source_3 from './source_3.json'
-import * as source_3_concurrent from './source_3_concurrent.json'
 import * as source_3_typed from './source_3_typed.json'
 import * as source_4 from './source_4.json'
 import * as source_4_typed from './source_4_typed.json'
@@ -45,7 +44,6 @@ export const SourceDocumentation = {
     '2': resolveImportInconsistency(source_2),
     '2_typed': resolveImportInconsistency(source_2_typed),
     '3': resolveImportInconsistency(source_3),
-    '3_concurrent': resolveImportInconsistency(source_3_concurrent),
     '3_typed': resolveImportInconsistency(source_3_typed),
     '4': resolveImportInconsistency(source_4),
     '4_typed': resolveImportInconsistency(source_4_typed),

docs/specs/source_concurrency.tex

@@ -253,12 +253,9 @@ export async function runFilesInContext(
 export function resume(result: Result): Finished | ResultError | Promise<Result> {
   if (result.status === 'finished' || result.status === 'error') {
     return result
-  } else if (result.status === 'suspended-cse-eval') {
-    const value = resumeEvaluate(result.context)
-    return CSEResultPromise(result.context, value)
-  } else {
-    return result.scheduler.run(result.it, result.context)
-  }
+  } 
+  const value = resumeEvaluate(result.context)
+  return CSEResultPromise(result.context, value)
 }
 
 export function interrupt(context: Context) {

scripts/docs.mjs

@@ -6,7 +6,7 @@ import { mockContext } from '../../../mocks/context'
 import { Chapter, type RecursivePartial } from '../../../types'
 import { memoizedGetModuleDocsAsync } from '../../loader/loaders'
 import preprocessFileImports from '..'
-import { sanitizeAST } from '../../../utils/ast/sanitizer'
+import { sanitizeAST } from '../../../utils/testing/sanitizer'
 import { parse } from '../../../parser/parser'
 import {
   accessExportFunctionName,

src/constants.ts

@@ -2,7 +2,7 @@ import { mockContext } from '../../../../mocks/context'
 import { parse } from '../../../../parser/parser'
 import { Chapter } from '../../../../types'
 import hoistAndMergeImports from '../../transformers/hoistAndMergeImports'
-import { sanitizeAST } from '../../../../utils/ast/sanitizer'
+import { sanitizeAST } from '../../../../utils/testing/sanitizer'
 
 describe('hoistAndMergeImports', () => {
   const assertASTsAreEqual = (actualCode: string, expectedCode: string) => {

src/createContext.ts

@@ -2,7 +2,7 @@ import { mockContext } from '../../../../mocks/context'
 import { parse } from '../../../../parser/parser'
 import { Chapter, type Context } from '../../../../types'
 import removeExports from '../../transformers/removeExports'
-import { sanitizeAST } from '../../../../utils/ast/sanitizer'
+import { sanitizeAST } from '../../../../utils/testing/sanitizer'
 
 type TestCase = [description: string, inputCode: string, expectedCode: string]
 

src/editors/ace/docTooltip/index.ts

@@ -3,7 +3,7 @@ import { parse } from '../../../../parser/parser'
 import { defaultExportLookupName } from '../../../../stdlib/localImport.prelude'
 import { Chapter } from '../../../../types'
 import { transformProgramToFunctionDeclaration } from '../../transformers/transformProgramToFunctionDeclaration'
-import { sanitizeAST } from '../../../../utils/ast/sanitizer'
+import { sanitizeAST } from '../../../../utils/testing/sanitizer'
 
 describe('transformImportedFile', () => {
   const currentFileName = '/dir/a.js'

src/index.ts

@@ -0,0 +1,20 @@
+import type { Command } from 'commander'
+import { getMainCommand } from '../main'
+
+jest.spyOn(process, 'exit').mockImplementation(code => {
+  throw new Error(`process.exit called with ${code}`)
+})
+
+jest.spyOn(process.stdout, 'write').mockImplementation(() => true)
+
+describe('Make sure each subcommand can be run', () => {
+  const mainCommand = getMainCommand()
+  test.each(mainCommand.commands.map(cmd => [cmd.name(), cmd] as [string, Command]))(
+    'Testing %s command',
+    (_, cmd) => {
+      return expect(cmd.parseAsync(['-h'], { from: 'user' })).rejects.toMatchInlineSnapshot(
+        '[Error: process.exit called with 0]'
+      )
+    }
+  )
+})

src/modules/preprocessor/__tests__/preprocessor.ts

@@ -0,0 +1,110 @@
+import { asMockedFunc } from '../../utils/testing/misc'
+import { compileToChoices, getSVMCCommand } from '../svmc'
+import * as vm from '../../vm/svml-compiler'
+import * as fs from 'fs/promises'
+import { INTERNAL_FUNCTIONS } from '../../stdlib/vm.prelude'
+import { expectWritten, getCommandRunner } from './utils'
+
+jest.mock('fs/promises', () => ({
+  writeFile: jest.fn(),
+  readFile: jest.fn()
+}))
+
+const mockedReadFile = asMockedFunc(fs.readFile)
+const mockedWriteFile = asMockedFunc(fs.writeFile)
+
+jest.spyOn(vm, 'compileToIns')
+
+beforeEach(() => {
+  jest.clearAllMocks()
+})
+
+const { expectError: rawExpectError, expectSuccess: rawExpectSuccess } =
+  getCommandRunner(getSVMCCommand)
+
+async function expectSuccess(code: string, ...args: string[]) {
+  mockedReadFile.mockResolvedValueOnce(code)
+
+  await rawExpectSuccess(...args)
+  expect(fs.readFile).toHaveBeenCalledTimes(1)
+  expect(fs.writeFile).toHaveBeenCalledTimes(1)
+}
+
+function expectError(code: string, ...args: string[]) {
+  mockedReadFile.mockResolvedValueOnce(code)
+  return rawExpectError(...args)
+}
+
+test('Running with defaults', async () => {
+  await expectSuccess('1+1;', 'test.js')
+
+  const [[fileName]] = mockedWriteFile.mock.calls
+  expect(fileName).toEqual('test.svm')
+})
+
+it("won't run if the program has parsing errors", async () => {
+  await expectError('1 + 1', '/test.js')
+  expect(vm.compileToIns).toHaveBeenCalledTimes(0)
+  expectWritten(process.stderr.write).toMatchInlineSnapshot(
+    `"Line 1: Missing semicolon at the end of statement"`
+  )
+})
+
+it("won't perform compilation if the output type is 'ast'", async () => {
+  await expectSuccess('1+1;', 'test.js', '-t', 'ast')
+  expect(vm.compileToIns).toHaveBeenCalledTimes(0)
+})
+
+describe('--internals option', () => {
+  test('with valid values', async () => {
+    await expectSuccess('1+1;', 'test.js', '--internals', '["func1", "func2"]')
+    expect(vm.compileToIns).toHaveBeenCalledTimes(1)
+    const [[, , internals]] = asMockedFunc(vm.compileToIns).mock.calls
+
+    expect(internals).toEqual(['func1', 'func2'])
+  })
+
+  test('with non-string values in array', async () => {
+    await expectError('1+1;', 'test.js', '--internals', '[1, 2]')
+    expectWritten(process.stderr.write).toMatchInlineSnapshot(`
+      "error: option '-i, --internals <names>' argument '[1, 2]' is invalid. Expected a JSON array of strings!
+      "
+    `)
+  })
+
+  test('with a non-array', async () => {
+    await expectError('1+1;', 'test.js', '--internals', '{ "a": 1, "b": 2}')
+    expectWritten(process.stderr.write).toMatchInlineSnapshot(`
+      "error: option '-i, --internals <names>' argument '{ \\"a\\": 1, \\"b\\": 2}' is invalid. Expected a JSON array of strings!
+      "
+    `)
+  })
+
+  it('is ignored if variant is concurrent', async () => {
+    await expectSuccess(
+      '1+1;',
+      'test.js',
+      '--internals',
+      '["func1", "func2"]',
+      '--variant',
+      'concurrent'
+    )
+
+    expect(vm.compileToIns).toHaveBeenCalledTimes(1)
+    const [[, , internals]] = asMockedFunc(vm.compileToIns).mock.calls
+    const expectedNames = INTERNAL_FUNCTIONS.map(([name]) => name)
+    expect(internals).toEqual(expectedNames)
+  })
+})
+
+describe('Test output options', () => {
+  compileToChoices.forEach(choice => {
+    test(choice, async () => {
+      await expectSuccess('1 + 1;', 'test.js', '-t', choice)
+      const [[fileName, contents]] = mockedWriteFile.mock.calls
+
+      expect((fileName as string).startsWith('test')).toEqual(true)
+      expect(contents).toMatchSnapshot()
+    })
+  })
+})

src/modules/preprocessor/__tests__/transformers/hoistAndMergeImports.ts

@@ -0,0 +1,66 @@
+import { asMockedFunc } from '../../utils/testing/misc'
+import { getTranspilerCommand } from '../transpiler'
+import * as fs from 'fs/promises'
+import { expectWritten, getCommandRunner } from './utils'
+
+jest.mock('fs/promises', () => ({
+  readFile: jest.fn(),
+  writeFile: jest.fn()
+}))
+
+beforeEach(() => {
+  jest.clearAllMocks()
+})
+
+const mockedWriteFile = asMockedFunc(fs.writeFile)
+const mockedReadFile = asMockedFunc(fs.readFile)
+const { expectError, expectSuccess } = getCommandRunner(getTranspilerCommand)
+
+test('Nothing should be written if the program has parser errors', async () => {
+  mockedReadFile.mockResolvedValueOnce('1+1')
+  await expectError('/test.js')
+  expect(fs.writeFile).toHaveBeenCalledTimes(0)
+
+  expectWritten(process.stderr.write).toMatchInlineSnapshot(
+    `"[/test.js] Line 1: Missing semicolon at the end of statement"`
+  )
+})
+
+test('Nothing should be written if the program has transpiler errors', async () => {
+  mockedReadFile.mockResolvedValueOnce('a;')
+  await expectError('/test.js')
+  expect(fs.writeFile).toHaveBeenCalledTimes(0)
+
+  expectWritten(process.stderr.write).toMatchInlineSnapshot(
+    `"[/test.js] Line 1: Name a not declared."`
+  )
+})
+
+test('Nothing should be written to disk if no output file was specified', async () => {
+  mockedReadFile.mockResolvedValueOnce('1+1;')
+  await expectSuccess('test.js')
+  expect(fs.writeFile).toHaveBeenCalledTimes(0)
+
+  // Code should have been written to stdout
+  expectWritten(process.stdout.write).toMatchSnapshot()
+})
+
+test('Writing to file', async () => {
+  mockedReadFile.mockResolvedValueOnce('1+1;')
+  await expectSuccess('test.js', '-o', 'out.js')
+  expect(fs.writeFile).toHaveBeenCalledTimes(1)
+
+  const [[fileName, contents]] = mockedWriteFile.mock.calls
+  expect(fileName).toEqual('out.js')
+  expect(contents).toMatchSnapshot()
+})
+
+test('pretranspile option', async () => {
+  mockedReadFile.mockResolvedValueOnce('1+1;')
+  await expectSuccess('test.js', '-o', 'out.js', '-p')
+  expect(fs.writeFile).toHaveBeenCalledTimes(1)
+
+  const [[fileName, contents]] = mockedWriteFile.mock.calls
+  expect(fileName).toEqual('out.js')
+  expect(contents).toEqual('1 + 1;\n')
+})

src/modules/preprocessor/__tests__/transformers/removeExports.ts

@@ -0,0 +1,38 @@
+import type { Command } from '@commander-js/extra-typings'
+import { asMockedFunc } from '../../utils/testing/misc'
+
+/**
+ * Set up the environment for testing the given command. Returns
+ * `expectSuccess` and `expectError` for use with making assertions
+ * about the behaviour of the command
+ */
+export function getCommandRunner<T extends Command<any, any>>(getter: () => T) {
+  jest.spyOn(process.stdout, 'write').mockImplementation(() => true)
+  jest.spyOn(process.stderr, 'write').mockImplementation(() => true)
+  jest.spyOn(process, 'exit').mockImplementation(code => {
+    throw new Error(`process.exit called with ${code}`)
+  })
+
+  async function runner(...args: string[]) {
+    await getter().parseAsync(args, { from: 'user' })
+  }
+
+  return {
+    expectError(...args: string[]) {
+      // Error conditions should always cause commands to call
+      // process.exit(1)
+      return expect(runner(...args)).rejects.toMatchInlineSnapshot(
+        `[Error: process.exit called with 1]`
+      )
+    },
+    expectSuccess(...args: string[]) {
+      return expect(runner(...args)).resolves.toBeUndefined()
+    }
+  }
+}
+
+export function expectWritten(f: (contents: string) => any) {
+  expect(f).toHaveBeenCalledTimes(1)
+  const [[contents]] = asMockedFunc(f).mock.calls
+  return expect(contents)
+}

src/modules/preprocessor/__tests__/transformers/transformProgramToFunctionDeclaration.ts

@@ -1,11 +1,4 @@
-#!/usr/bin/env node
+#!/bin/env/node
+import { getMainCommand } from './main'
 
-import { Command } from '@commander-js/extra-typings'
-
-import { getReplCommand } from './repl'
-import { transpilerCommand } from './transpiler'
-
-new Command()
-  .addCommand(transpilerCommand)
-  .addCommand(getReplCommand(), { isDefault: true })
-  .parseAsync()
+getMainCommand().parseAsync()

src/repl/__tests__/main.ts

@@ -0,0 +1,11 @@
+import { Command } from '@commander-js/extra-typings'
+
+import { getSVMCCommand } from './svmc'
+import { getReplCommand } from './repl'
+import { getTranspilerCommand } from './transpiler'
+
+export const getMainCommand = () =>
+  new Command()
+    .addCommand(getSVMCCommand())
+    .addCommand(getTranspilerCommand())
+    .addCommand(getReplCommand(), { isDefault: true })

src/repl/__tests__/svmc.ts

@@ -0,0 +1,106 @@
+import type pathlib from 'path'
+import type fslib from 'fs/promises'
+
+import { Command, InvalidArgumentError, Option } from '@commander-js/extra-typings'
+import { createEmptyContext } from '../createContext'
+import { parse } from '../parser/parser'
+import { Chapter, Variant } from '../types'
+import { stripIndent } from '../utils/formatters'
+import { parseError } from '..'
+import { assemble } from '../vm/svml-assembler'
+import { compileToIns } from '../vm/svml-compiler'
+import { stringifyProgram } from '../vm/util'
+import { chapterParser, getChapterOption } from './utils'
+
+export const compileToChoices = ['ast', 'binary', 'debug', 'json'] as const
+
+export const getSVMCCommand = () =>
+  new Command('svmc')
+    .argument('<inputFile>', 'File to read code from')
+    .addOption(getChapterOption(Chapter.SOURCE_3, chapterParser))
+    .addOption(
+      new Option(
+        '-t, --compileTo <compileOption>',
+        stripIndent`
+      json: Compile only, but don't assemble.
+      binary: Compile and assemble.
+      debug: Compile and pretty-print the compiler output. For debugging the compiler.
+      ast: Parse and pretty-print the AST. For debugging the parser.`
+      )
+        .choices(compileToChoices)
+        .default('binary' as (typeof compileToChoices)[number])
+    )
+    .option(
+      '-o, --out <outFile>',
+      stripIndent`
+      Sets the output filename.
+      Defaults to the input filename, minus any file extension, plus '.svm'.
+    `
+    )
+    .addOption(
+      new Option(
+        '-i, --internals <names>',
+        `Sets the list of VM-internal functions. The argument should be a JSON array of
+strings containing the names of the VM-internal functions.`
+      )
+        .argParser(value => {
+          const parsed = JSON.parse(value)
+          if (!Array.isArray(parsed)) {
+            throw new InvalidArgumentError('Expected a JSON array of strings!')
+          }
+
+          for (const each of parsed) {
+            if (typeof each !== 'string') {
+              throw new InvalidArgumentError('Expected a JSON array of strings!')
+            }
+          }
+          return parsed as string[]
+        })
+        .default([] as string[])
+    )
+    .action(async (inputFile, opts) => {
+      const fs: typeof fslib = require('fs/promises')
+      const vmInternalFunctions = opts.internals || []
+
+      const source = await fs.readFile(inputFile, 'utf-8')
+      const context = createEmptyContext(opts.chapter, Variant.DEFAULT, [], null)
+      const program = parse(source, context)
+      if (program === null) {
+        process.stderr.write(parseError(context.errors))
+        process.exit(1)
+      }
+
+      let output: string | Uint8Array
+      let ext: string
+
+      if (opts.compileTo === 'ast') {
+        output = JSON.stringify(program, undefined, 2)
+        ext = '.json'
+      } else {
+        const compiled = compileToIns(program, undefined, vmInternalFunctions)
+        switch (opts.compileTo) {
+          case 'debug': {
+            output = stringifyProgram(compiled).trimEnd()
+            ext = '.svm'
+            break
+          }
+          case 'json': {
+            output = JSON.stringify(compiled)
+            ext = '.json'
+            break
+          }
+          case 'binary': {
+            output = assemble(compiled)
+            ext = '.svm'
+            break
+          }
+        }
+      }
+
+      const { extname, basename }: typeof pathlib = require('path')
+      const extToRemove = extname(inputFile)
+
+      const outputFileName = opts.out ?? `${basename(inputFile, extToRemove)}${ext}`
+      await fs.writeFile(outputFileName, output)
+      console.log(`Output written to ${outputFileName}`)
+    })

src/repl/__tests__/transpiler.ts

@@ -16,63 +16,63 @@ import {
   validateChapterAndVariantCombo
 } from './utils'
 
-export const transpilerCommand = new Command('transpiler')
-  .addOption(getVariantOption(Variant.DEFAULT, [Variant.DEFAULT, Variant.NATIVE]))
-  .addOption(getChapterOption(Chapter.SOURCE_4, chapterParser))
-  .option(
-    '-p, --pretranspile',
-    "only pretranspile (e.g. GPU -> Source) and don't perform Source -> JS transpilation"
-  )
-  .option('-o, --out <outFile>', 'Specify a file to write to')
-  .argument('<filename>')
-  .action(async (fileName, opts) => {
-    if (!validateChapterAndVariantCombo(opts)) {
-      console.log('Invalid language combination!')
-      return
-    }
-
-    const fs: typeof fslib = require('fs/promises')
-    const context = createContext(opts.chapter, opts.variant)
-    const entrypointFilePath = resolve(fileName)
-
-    const linkerResult = await parseProgramsAndConstructImportGraph(
-      async p => {
-        try {
-          const text = await fs.readFile(p, 'utf-8')
-          return text
-        } catch (error) {
-          if (error.code === 'ENOENT') return undefined
-          throw error
-        }
-      },
-      entrypointFilePath,
-      context,
-      {},
-      true
+export const getTranspilerCommand = () =>
+  new Command('transpiler')
+    .addOption(getVariantOption(Variant.DEFAULT, [Variant.DEFAULT, Variant.NATIVE]))
+    .addOption(getChapterOption(Chapter.SOURCE_4, chapterParser))
+    .option(
+      '-p, --pretranspile',
+      "only pretranspile and don't perform Source -> JS transpilation"
     )
+    .option('-o, --out <outFile>', 'Specify a file to write to')
+    .argument('<filename>')
+    .action(async (fileName, opts) => {
+      if (!validateChapterAndVariantCombo(opts)) {
+        console.log('Invalid language combination!')
+        return
+      }
 
-    if (!linkerResult.ok) {
-      console.log(parseError(context.errors, linkerResult.verboseErrors))
-      return
-    }
+      const fs: typeof fslib = require('fs/promises')
+      const context = createContext(opts.chapter, opts.variant)
+      const entrypointFilePath = resolve(fileName)
 
-    const { programs, topoOrder } = linkerResult
-    const bundledProgram = defaultBundler(programs, entrypointFilePath, topoOrder, context)
+      const linkerResult = await parseProgramsAndConstructImportGraph(
+        async p => {
+          try {
+            const text = await fs.readFile(p, 'utf-8')
+            return text
+          } catch (error) {
+            if (error.code === 'ENOENT') return undefined
+            throw error
+          }
+        },
+        entrypointFilePath,
+        context,
+        {},
+        true
+      )
 
-    const transpiled = opts.pretranspile
-      ? generate(bundledProgram)
-      : transpile(bundledProgram, context).transpiled
+      if (!linkerResult.ok) {
+        process.stderr.write(parseError(context.errors, linkerResult.verboseErrors))
+        process.exit(1)
+      }
 
-    if (context.errors.length > 0) {
-      console.log(parseError(context.errors, linkerResult.verboseErrors))
-      return
-    }
+      const { programs, topoOrder } = linkerResult
+      const bundledProgram = defaultBundler(programs, entrypointFilePath, topoOrder, context)
 
-    if (opts.out) {
-      const resolvedOut = resolve(opts.out)
-      await fs.writeFile(resolvedOut, transpiled)
-      console.log(`Code written to ${resolvedOut}`)
-    } else {
-      console.log(transpiled)
-    }
-  })
+      try {
+        const transpiled = opts.pretranspile
+          ? generate(bundledProgram)
+          : transpile(bundledProgram, context).transpiled
+
+        if (opts.out) {
+          await fs.writeFile(opts.out, transpiled)
+          console.log(`Code written to ${opts.out}`)
+        } else {
+          process.stdout.write(transpiled)
+        }
+      } catch (error) {
+        process.stderr.write(parseError([error], linkerResult.verboseErrors))
+        process.exit(1)
+      }
+    })

src/repl/__tests__/utils.ts

@@ -3,19 +3,17 @@ import * as _ from 'lodash'
 import type { RawSourceMap } from 'source-map'
 
 import { type IOptions, type Result } from '..'
-import { JSSLANG_PROPERTIES, UNKNOWN_LOCATION } from '../constants'
+import { JSSLANG_PROPERTIES } from '../constants'
 import { CSEResultPromise, evaluate as CSEvaluate } from '../cse-machine/interpreter'
 import { ExceptionError } from '../errors/errors'
 import { RuntimeSourceError } from '../errors/runtimeSourceError'
 import { TimeoutError } from '../errors/timeoutErrors'
 import { isPotentialInfiniteLoop } from '../infiniteLoops/errors'
 import { testForInfiniteLoop } from '../infiniteLoops/runtime'
-import { evaluateProgram as evaluate } from '../interpreter/interpreter'
 import preprocessFileImports from '../modules/preprocessor'
 import { defaultAnalysisOptions } from '../modules/preprocessor/analyzer'
 import { defaultLinkerOptions } from '../modules/preprocessor/linker'
 import { parse } from '../parser/parser'
-import { AsyncScheduler, PreemptiveScheduler } from '../schedulers'
 import {
   callee,
   getEvaluationSteps,
@@ -25,12 +23,11 @@ import {
 } from '../stepper/stepper'
 import { sandboxedEval } from '../transpiler/evalContainer'
 import { transpile } from '../transpiler/transpiler'
-import { Chapter, type Context, type RecursivePartial, type Scheduler, Variant } from '../types'
+import { Chapter, type Context, type RecursivePartial, Variant } from '../types'
 import { validateAndAnnotate } from '../validator/validator'
-import { compileForConcurrent } from '../vm/svml-compiler'
-import { runWithProgram } from '../vm/svml-machine'
 import type { FileGetter } from '../modules/moduleTypes'
 import { mapResult } from '../alt-langs/mapper'
+import assert from '../utils/assert'
 import { toSourceError } from './errors'
 import { fullJSRunner } from './fullJSRunner'
 import { determineExecutionMethod, determineVariant, resolvedErrorPromise } from './utils'
@@ -60,29 +57,6 @@ let previousCode: {
 } | null = null
 let isPreviousCodeTimeoutError = false
 
-function runConcurrent(program: es.Program, context: Context, options: IOptions): Promise<Result> {
-  if (context.shouldIncreaseEvaluationTimeout) {
-    context.nativeStorage.maxExecTime *= JSSLANG_PROPERTIES.factorToIncreaseBy
-  } else {
-    context.nativeStorage.maxExecTime = options.originalMaxExecTime
-  }
-
-  try {
-    return Promise.resolve({
-      status: 'finished',
-      context,
-      value: runWithProgram(compileForConcurrent(program, context), context)
-    })
-  } catch (error) {
-    if (error instanceof RuntimeSourceError || error instanceof ExceptionError) {
-      context.errors.push(error) // use ExceptionErrors for non Source Errors
-      return resolvedErrorPromise
-    }
-    context.errors.push(new ExceptionError(error, UNKNOWN_LOCATION))
-    return resolvedErrorPromise
-  }
-}
-
 function runSubstitution(
   program: es.Program,
   context: Context,
@@ -110,17 +84,6 @@ function runSubstitution(
   })
 }
 
-function runInterpreter(program: es.Program, context: Context, options: IOptions): Promise<Result> {
-  let it = evaluate(program, context)
-  let scheduler: Scheduler
-  if (options.scheduler === 'async') {
-    scheduler = new AsyncScheduler()
-  } else {
-    scheduler = new PreemptiveScheduler(options.steps)
-  }
-  return scheduler.run(it, context)
-}
-
 async function runNative(
   program: es.Program,
   context: Context,
@@ -226,10 +189,6 @@ async function sourceRunner(
     return resolvedErrorPromise
   }
 
-  if (context.variant === Variant.CONCURRENT) {
-    return runConcurrent(program, context, theOptions)
-  }
-
   if (theOptions.useSubst) {
     return runSubstitution(program, context, theOptions)
   }
@@ -238,7 +197,7 @@ async function sourceRunner(
 
   // native, don't evaluate prelude
   if (context.executionMethod === 'native' && context.variant === Variant.NATIVE) {
-    return await fullJSRunner(program, context, theOptions.importOptions)
+    return fullJSRunner(program, context, theOptions.importOptions)
   }
 
   // All runners after this point evaluate the prelude.
@@ -264,11 +223,8 @@ async function sourceRunner(
     return runCSEMachine(program, context, theOptions)
   }
 
-  if (context.executionMethod === 'native') {
-    return runNative(program, context, theOptions)
-  }
-
-  return runInterpreter(program, context, theOptions)
+  assert(context.executionMethod !== 'auto', 'Execution method should have been properly determined!')
+  return runNative(program, context, theOptions)
 }
 
 /**

src/repl/index.ts

@@ -1,29 +1,9 @@
-import { Context, Result } from '..'
-import { Node, Scheduler, Value } from '../types'
-
-export const saveState = (
-  context: Context,
-  it: IterableIterator<Value>,
-  scheduler: Scheduler
-): void => {
-  context.debugger.state.it = it
-  context.debugger.state.scheduler = scheduler
-}
+import type { Context, Node } from '../types'
 
 export const setBreakpointAtLine = (lines: string[]): void => {
   breakpoints = lines
 }
 
-export const manualToggleDebugger = (context: Context): Result => {
-  context.runtime.break = true
-  return {
-    status: 'suspended',
-    scheduler: context.debugger.state.scheduler,
-    it: context.debugger.state.it,
-    context
-  }
-}
-
 let breakpoints: string[] = []
 let moved: boolean = true
 let prevStoppedLine: number = -1

src/repl/main.ts

@@ -2,7 +2,7 @@ import { mockContext } from '../../mocks/context'
 import { parse } from '../../parser/parser'
 import { Chapter } from '../../types'
 import * as ast from '../../utils/ast/astCreator'
-import { sanitizeAST } from '../../utils/ast/sanitizer'
+import { sanitizeAST } from '../../utils/testing/sanitizer'
 import { stripIndent } from '../../utils/formatters'
 import { transformImportDeclarations, transpile } from '../transpiler'
 

src/repl/svmc.ts

@@ -64,7 +64,7 @@ export interface Comment {
   loc: SourceLocation | undefined
 }
 
-export type ExecutionMethod = 'native' | 'interpreter' | 'auto' | 'cse-machine'
+export type ExecutionMethod = 'native' | 'auto' | 'cse-machine'
 
 export enum Chapter {
   SOURCE_1 = 1,
@@ -94,7 +94,6 @@ export enum Variant {
   TYPED = 'typed',
   NATIVE = 'native',
   WASM = 'wasm',
-  CONCURRENT = 'concurrent',
   EXPLICIT_CONTROL = 'explicit-control'
 }
 
@@ -168,7 +167,6 @@ export interface Context<T = any> {
     status: boolean
     state: {
       it: IterableIterator<T>
-      scheduler: Scheduler
     }
   }
 
@@ -274,23 +272,12 @@ export interface Finished {
   // field instead
 }
 
-export interface Suspended {
-  status: 'suspended'
-  it: IterableIterator<Value>
-  scheduler: Scheduler
-  context: Context
-}
-
 export interface SuspendedCseEval {
   status: 'suspended-cse-eval'
   context: Context
 }
 
-export type Result = Suspended | Finished | Error | SuspendedCseEval
-
-export interface Scheduler {
-  run(it: IterableIterator<Value>, context: Context): Promise<Result>
-}
+export type Result = Finished | Error | SuspendedCseEval
 
 /**
  * StatementSequence : A sequence of statements not surrounded by braces.
@@ -510,3 +497,5 @@ export type RecursivePartial<T> = T extends Array<any>
       [K in keyof T]: RecursivePartial<T[K]>
     }>
   : T
+
+export type NodeTypeToNode<T extends Node['type']> = Extract<Node, { type: T }>

src/repl/transpiler.ts

@@ -1,11 +1,11 @@
 import type { MockedFunction } from 'jest-mock'
 
-import createContext, { defineBuiltin } from '../createContext'
-import { parseError, Result, runInContext } from '../index'
-import { mockContext } from '../mocks/context'
-import { ImportOptions } from '../modules/moduleTypes'
-import { parse } from '../parser/parser'
-import { transpile } from '../transpiler/transpiler'
+import createContext, { defineBuiltin } from '../../createContext'
+import { parseError, Result, runInContext } from '../../'
+import { mockContext } from '../../mocks/context'
+import type { ImportOptions } from '../../modules/moduleTypes'
+import { parse } from '../../parser/parser'
+import { transpile } from '../../transpiler/transpiler'
 import {
   Chapter,
   Context,
@@ -14,8 +14,8 @@ import {
   Value,
   Variant,
   type Finished
-} from '../types'
-import { stringify } from './stringify'
+} from '../../types'
+import { stringify } from '../stringify'
 
 export interface CodeSnippetTestCase {
   name: string

src/runner/sourceRunner.ts

@@ -0,0 +1,27 @@
+import type { MockedFunction } from 'jest-mock'
+import type { Result } from '../..'
+import type { Finished, Value, Node, NodeTypeToNode } from '../../types'
+
+export function asMockedFunc<T extends (...args: any[]) => any>(func: T) {
+  return func as MockedFunction<T>
+}
+
+export function expectTrue(cond: boolean): asserts cond {
+  expect(cond).toEqual(true)
+}
+
+export function expectFinishedResult(result: Result): asserts result is Finished {
+  expect(result.status).toEqual('finished')
+}
+
+export function expectFinishedResultValue(result: Result, value: Value) {
+  expectFinishedResult(result)
+  expect(result.value).toEqual(value)
+}
+
+export function expectNodeType<T extends Node['type']>(
+  typeStr: T,
+  node: Node
+): asserts node is NodeTypeToNode<T> {
+  expect(node.type).toEqual(typeStr)
+}