fix: optional property access support

Author: kedrzu

packages/core/src/runtime/executeAgent.ts

@@ -522,7 +522,12 @@ async function runMemberExpression(
         unsafe = unsafe || propertyResult.unsafe;
     }
 
-    const value = (objectResult.value as Record<string, unknown>)[property];
+    let value: unknown;
+    if (expr.optional && objectResult.value == null) {
+        value = undefined;
+    } else {
+        value = (objectResult.value as Record<string, unknown>)[property];
+    }
 
     unsafe = unsafe || !isSafeValue(value);
 

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

@@ -436,3 +436,64 @@ test('assign value to unsafe object', async () => {
         'Assigning to unsafe value is not allowed',
     );
 });
+
+test('optional property access with value', async () => {
+    const script = parseScript([
+        //
+        'const a = { b: 1 };',
+        'a?.b;',
+    ]);
+
+    const agent = createAgent({ script });
+    const result = await executeAgent({ agent });
+
+    const expectedStack = rootFrame({
+        status: 'done',
+        variables: { a: { b: 1 } },
+        children: [
+            completedFrame({
+                node: 'var',
+                children: [completedFrame({ node: 'literal', value: { b: 1 } })],
+            }),
+            completedFrame({
+                node: 'member',
+                value: 1,
+                children: [completedFrame({ node: 'ident', value: { b: 1 } })],
+            }),
+        ],
+    });
+
+    expect(result).toEqual(agentResult({ ticks: 0 }));
+    expect(agent.root).toEqual(expectedStack);
+    expect(agent.status).toBe('done');
+});
+
+test('optional property access without value', async () => {
+    const script = parseScript([
+        //
+        'const a = null;',
+        'a?.b;',
+    ]);
+
+    const agent = createAgent({ script });
+    const result = await executeAgent({ agent });
+
+    const expectedStack = rootFrame({
+        status: 'done',
+        variables: { a: null },
+        children: [
+            completedFrame({
+                node: 'var',
+            }),
+            completedFrame({
+                node: 'member',
+                value: undefined,
+                children: [completedFrame({ node: 'ident', value: null })],
+            }),
+        ],
+    });
+
+    expect(result).toEqual(agentResult({ ticks: 0 }));
+    expect(agent.root).toEqual(expectedStack);
+    expect(agent.status).toBe('done');
+});

packages/parser/src/astTypes.ts

@@ -188,6 +188,10 @@ export interface MemberExpression extends AstNodeBase {
      * Object to access the property on.
      */
     obj: Expression;
+    /**
+     * Whether the property access is optional.
+     */
+    optional?: boolean;
 }
 
 /**

packages/parser/src/parseScript.objects.test.ts

@@ -141,3 +141,21 @@ test('object prop assignment dynamic', () => {
 
     expect(script).toEqual(expected);
 });
+
+test('optional property access', () => {
+    const code = 'a?.b';
+    const script = parseScript(code);
+    const expected: Script = {
+        code,
+        ast: [
+            {
+                type: 'member',
+                prop: 'b',
+                obj: { type: 'ident', name: 'a' },
+                optional: true,
+            },
+        ],
+    };
+
+    expect(script).toEqual(expected);
+});

packages/parser/src/parseScript.ts

@@ -44,6 +44,10 @@ export function parseScript(code: string | string[]): Script {
             ast: parsed,
         };
     } catch (error) {
+        if (error instanceof ParseError) {
+            throw error;
+        }
+
         throw new ParseError('Failed to parse script', {
             cause: error,
         });
@@ -180,6 +184,7 @@ function parseExpression(expression: babel.Expression): Expression {
             };
 
         case 'MemberExpression':
+        case 'OptionalMemberExpression':
             return parseMemberExpression(expression);
 
         case 'CallExpression': {
@@ -266,17 +271,25 @@ function parseExpression(expression: babel.Expression): Expression {
     });
 }
 
-function parseMemberExpression(expression: babel.MemberExpression): MemberExpression {
+function parseMemberExpression(
+    expression: babel.MemberExpression | babel.OptionalMemberExpression,
+): MemberExpression {
     const prop =
         !expression.computed && expression.property.type === 'Identifier'
             ? expression.property.name
             : parseExpression(expression.property as babel.Expression);
 
-    return {
+    const expr: MemberExpression = {
         type: 'member',
         prop,
         obj: parseExpression(expression.object),
     };
+
+    if (expression.optional) {
+        expr.optional = true;
+    }
+
+    return expr;
 }
 
 function parseObjectExpression(