Match use of ‘async’ in Ark 0.1.14, and restore ‘use js’ test

Now we have dynamic import() working, and hence ‘use js’, test it.

Subsequent commits will switch to ‘use js’ from our current manual bindings.

TODO.md

@@ -2,6 +2,7 @@
 
 ## Version 0.2
 
+* Use `use js` to move most of the globals into the prelude.
 * Sets: use `{ Exp, }` notation, with mandatory first comma.
 * Map interface to file system and internet.
 

src/basics.test.ts

@@ -61,7 +61,7 @@ testGroup('Conditionals', [
   ['if 3 + 4 == 8 {1} else if 3 + 4 == 7 {2} else {3}', 2],
 ])
 
-test('loop and break', (t) => {
+test('loop and break', async (t) => {
   const error = t.throws(() => new ArkState().run(compile('break')), {instanceOf: UrsaCompilerError})
   assert(error !== undefined)
   t.is(error.message, `\
@@ -70,19 +70,19 @@ Line 1, col 1:
       ^~~~~
 
 break used outside a loop`)
-  t.is(toJs(new ArkState().run(compile('loop { break 3 }'))), 3)
+  t.is(toJs(await new ArkState().run(compile('loop { break 3 }'))), 3)
 })
 
-test('return', (t) => {
-  const error = t.throws(() => new ArkState().run(compile('return')), {instanceOf: UrsaCompilerError})
+test('return', async (t) => {
+  const error = await t.throwsAsync(async () => new ArkState().run(compile('return')), {instanceOf: UrsaCompilerError})
   assert(error !== undefined)
   t.is(error.message, `\
 Line 1, col 1:
 > 1 | return
       ^~~~~~
 
 return used outside a function`)
-  t.is(toJs(new ArkState().run(compile('fn () { return 3 }()'))), 3)
+  t.is(toJs(await new ArkState().run(compile('fn () { return 3 }()'))), 3)
 })
 
 testGroup('let', [

src/cli.ts

@@ -95,7 +95,7 @@ async function repl() {
           env = env.push(compiled.boundVars)
           ark.stack.push(Array(compiled.boundVars.length).fill(new ArkValRef(ArkUndefined)))
         }
-        val = toJs(runWithTraceback(ark, compiled))
+        val = toJs(await runWithTraceback(ark, compiled))
         console.dir(val, {depth: null})
       }
     } catch (error) {
@@ -148,7 +148,7 @@ async function main() {
       fs.readFileSync(path.join(thisDir, 'prelude.ursa'), {encoding: 'utf-8'}),
     )
     const ark = new ArkState()
-    const preludeObj = prelude.value.eval(ark) as ArkObject
+    const preludeObj = await prelude.value.eval(ark) as ArkObject
     for (const [sym, val] of preludeObj.val) {
       globals.set(sym, new ArkValRef(val))
     }
@@ -168,7 +168,7 @@ async function main() {
       // Run the program
       let result
       if (source !== undefined) {
-        result = runWithTraceback(ark, compile(source))
+        result = await runWithTraceback(ark, compile(source))
       }
       if (source === undefined || args.interactive) {
         result = await repl()

src/compiler.ts

@@ -833,9 +833,9 @@ export function compile(
   return new PartialCompiledArk(compiled, freeVars, ast.boundVars)
 }
 
-export function runWithTraceback(ark: ArkState, compiledVal: CompiledArk): ArkVal {
+export async function runWithTraceback(ark: ArkState, compiledVal: CompiledArk): Promise<ArkVal> {
   try {
-    return ark.run(compiledVal)
+    return await ark.run(compiledVal)
   } catch (e) {
     if (e instanceof ArkRuntimeError) {
       throw new UrsaRuntimeError(ark, e.sourceLoc as Interval, e.message)

src/examples.test.ts

@@ -36,8 +36,7 @@ test('Test I/O', 'test/print', [], 'Hello, world!')
 
 test("'fs' module", 'test/fs', [], 'foo')
 
-// FIXME: make this work again
-// test('use fs', 'test/use-fs', 'foo')
+test('use fs', 'test/use-fs', [], 'foo')
 
 test('Find symbols in input', 'test/syms', ['./test/fs.ursa'], 'fs\nwriteSync\nfoo\nis\nstdout')
 

src/testutil.ts

@@ -24,13 +24,14 @@ function doTestGroup(
   compile: (expr: string) => CompiledArk,
   tests: [string, any][],
 ) {
-  test(title, (t) => {
+  test(title, async (t) => {
     for (const [source, expected] of tests) {
       const compiled = compile(source)
       if (process.env.DEBUG) {
         debug(compiled, null)
       }
-      t.deepEqual(toJs(new ArkState().run(compiled)), expected)
+      // eslint-disable-next-line no-await-in-loop
+      t.deepEqual(toJs(await new ArkState().run(compiled)), expected)
     }
   })
 }