feat: support early return from the script

Author: kedrzu

packages/core/src/runtime/tests/ifelse.test.ts

@@ -253,3 +253,68 @@ test('if statement, else if', async () => {
     expect(agent.root).toEqual(expectedStack);
     expect(agent.status).toBe('done');
 });
+
+test('early return in if statement', async () => {
+    const code = joinLines([
+        //
+        'let a = 2',
+        'if (a > 1) {',
+        '    a = 3',
+        '    return',
+        '}',
+        'let b = 3',
+    ]);
+
+    const script = parseScript(code);
+    const agent = createAgent({ script });
+
+    await executeAgent({ agent });
+
+    const expectedStack = rootFrame({
+        status: 'done',
+        children: [
+            // var a declaration
+            completedFrame({ node: 'var' }),
+            // if statement
+            completedFrame({
+                node: 'if',
+                children: [
+                    // condition
+                    completedFrame({
+                        node: 'binary',
+                        value: true,
+                        children: [
+                            // left operand
+                            completedFrame({
+                                node: 'ident',
+                                value: 2,
+                            }),
+                        ],
+                    }),
+                    // body
+                    completedFrame({
+                        node: 'block',
+                        children: [
+                            // assignment
+                            completedFrame({
+                                node: 'assign',
+                                value: 3,
+                            }),
+                            // return
+                            completedFrame({
+                                node: 'return',
+                            }),
+                        ],
+                    }),
+                ],
+            }),
+        ],
+        value: undefined,
+        variables: {
+            a: 3,
+        },
+    });
+
+    expect(agent.root).toEqual(expectedStack);
+    expect(agent.status).toBe('done');
+});

packages/core/src/runtime/tests/nativeCalls.test.ts

@@ -210,3 +210,39 @@ test('array.push()', async () => {
     expect(agent.root).toEqual(expectedStack);
     expect(agent.status).toBe('done');
 });
+
+test('array.filter(Boolean)', async () => {
+    const script = parseScript([
+        //
+        'const a = [0, 1, 2, 3];',
+        'a.filter(Boolean)',
+    ]);
+
+    const agent = createAgent({ script });
+    const result = await executeAgent({ agent });
+
+    const expectedStack = rootFrame({
+        status: 'done',
+        children: [
+            // variable init
+            completedFrame({ node: 'var' }),
+            // filter()
+            completedFrame({
+                node: 'call',
+                value: [1, 2, 3],
+                children: [
+                    // this
+                    completedFrame({
+                        node: 'ident',
+                        value: [0, 1, 2, 3],
+                    }),
+                ],
+            }),
+        ],
+        variables: { a: [0, 1, 2, 3] },
+    });
+
+    expect(result).toEqual(agentResult({ ticks: 0 }));
+    expect(agent.root).toEqual(expectedStack);
+    expect(agent.status).toBe('done');
+});

packages/parser/src/parseScript.test.ts

@@ -434,3 +434,14 @@ test('array map with function', () => {
 
     expect(script).toEqual(expected);
 });
+
+test('top level return', () => {
+    const code = 'return 1';
+    const script = parseScript(code);
+    const expected: Script = {
+        code,
+        ast: [{ type: 'return', value: { type: 'literal', value: 1 } }],
+    };
+
+    expect(script).toEqual(expected);
+});

packages/parser/src/parseScript.ts

@@ -26,7 +26,9 @@ export function parseScript(code: string | string[]): Script {
         code = code.join('\n');
     }
 
-    const ast = parse(code);
+    const ast = parse(code, {
+        allowReturnOutsideFunction: true,
+    });
     const parsed: AstNode[] = [];
 
     for (const node of ast.program.body) {