syntax support 2 by nyariv · Pull Request #44 · nyariv/SandboxJS

nyariv · 2026-02-12T23:27:07Z

📊 Test Coverage & Code Quality Improvements

Test Coverage Increase: 851 → 991 tests (+140 tests, +16.4%)
Branch Coverage: 83% → 90% (+7%)

✨ New Features Implemented

Assignment Operators (ES2021)

✅ Logical AND assignment (&&=) - let x = 10; x &&= 5 → 5
✅ Logical OR assignment (||=) - let x = 0; x ||= 5 → 5
✅ Nullish coalescing assignment (??=) - let x = null; x ??= 5 → 5

Template Literals

✅ Tagged template functions - tag`hello ${"world"}` → function receives string parts and interpolated values

🐛 Bug Fixes

Exponentiation operator precedence - Fixed 2 * 3 ** 2 to correctly evaluate as 2 * (3 ** 2) = 18 (was incorrectly evaluating as 36)
eval spec compliance - Improvements to eval implementation behavior
Finally blocks - finally now supported in try/catch code
Object property shorthand - Fixed {x, y: 1, z} to correctly assigns key and value for object shorthands
Semicolon insertions - Semicolon insertions has been greatly improved and handles a much greater range of cases.

Copilot

Pull request overview

This PR expands SandboxJS’s JavaScript syntax/runtime support and updates the test suite + project config to validate the new behavior (logical assignment operators, tagged templates, exponentiation precedence, try/finally, eval behavior, and object shorthand).

Changes:

Add parsing/execution support for &&=, ||=, ??= and tagged template calls.
Fix/adjust operator precedence handling (notably **) and implement finally execution in try flows.
Increase test coverage and update Jest/TS config + TODO status documentation.

Reviewed changes

Copilot reviewed 13 out of 14 changed files in this pull request and generated 9 comments.

Show a summary per file

File	Description
`tsconfig.jest.json`	Enables `isolatedModules` for the Jest TS build.
`jest.config.js`	Adjusts worker settings and TS transform config.
`src/utils.ts`	Wires sandboxed `eval` with execution context; adds new `LispType` enum entries.
`src/parser.ts`	Adds tokens/AST nodes for `**` precedence, logical assignment ops, object shorthand, and tagged templates.
`src/executor.ts`	Implements logical assignment ops and `try/catch/finally` execution semantics.
`src/eval.ts`	Changes sandboxed eval to parse/execute code directly and attempt “completion value” behavior.
`test/ticksQuotaHalt.spec.ts`	Adds tests for halting/resuming when tick quota is exceeded.
`test/eval/testCases/*.data.ts`	Adds coverage for tagged templates, eval completion, `finally`, exponentiation precedence, shorthand objects, and logical assignment.
`TODO.md`	Updates feature/support status and coverage stats.

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.

Copilot · 2026-02-13T12:37:35Z

src/eval.ts

+function wrapLastStatementInReturn(tree: any[]): any[] {
+  if (tree.length === 0) return tree;
+  const newTree = [...tree];
+  const lastIndex = newTree.length - 1;
+  const lastStmt = newTree[lastIndex];
+  // Only wrap if it's not already a return or throw
+  if (Array.isArray(lastStmt) && lastStmt.length === 3) {
+    const op = lastStmt[0];
+    // LispType.Return = 8, LispType.Throw = 47
+    if (op !== 8 && op !== 47) {
+      // Wrap in return: [LispType.Return, LispType.None, expression]
+      newTree[lastIndex] = [LispType.Return, 0, lastStmt];
+    }
  }
+  return newTree;


wrapLastStatementInReturn wraps the last parsed node in a Return regardless of whether it's an expression statement. For statements like let/const/var, this will return the engine's internal Prop object (because Scope.declare returns Prop), which is both incorrect vs JS eval completion values (should be undefined) and can leak internal references into untrusted code. Consider only returning the completion value of an ExpressionStatement (and otherwise returning undefined), or add a dedicated eval execution path that computes the completion value without injecting a Return node.

Copilot · 2026-02-13T12:37:35Z

src/eval.ts

+    // LispType.Return = 8, LispType.Throw = 47
+    if (op !== 8 && op !== 47) {
+      // Wrap in return: [LispType.Return, LispType.None, expression]
+      newTree[lastIndex] = [LispType.Return, 0, lastStmt];


wrapLastStatementInReturn relies on hard-coded numeric op values (8/47) and uses 0 for LispType.None. This will silently break if LispType enum ordering changes (as it does in this PR), and makes the intent harder to follow. Use LispType.Return, LispType.Throw, and LispType.None comparisons/values instead of numeric literals.

Suggested change

// LispType.Return = 8, LispType.Throw = 47

if (op !== 8 && op !== 47) {

// Wrap in return: [LispType.Return, LispType.None, expression]

newTree[lastIndex] = [LispType.Return, 0, lastStmt];

// Avoid wrapping if the last statement is already a return or throw

if (op !== LispType.Return && op !== LispType.Throw) {

// Wrap in return: [LispType.Return, LispType.None, expression]

newTree[lastIndex] = [LispType.Return, LispType.None, lastStmt];

Copilot · 2026-02-13T12:37:36Z

src/parser.ts

+      stringParts.push(currentStr);
+      currentStr = '';
+      i += 2;
+      let exprIndex = '';
+      while (templateStr[i] !== '}') {
+        exprIndex += templateStr[i];
+        i++;
+      }
+      expressions.push(jsExprs[parseInt(exprIndex)]);
+      i++; // skip }


The tagged template parser treats any "${" sequence in the cooked template string as an interpolation marker and then loops until it finds a closing '}'. For escaped sequences like \${ (which unraw() turns into ${), there may be no matching '}', causing an infinite loop. Even when there is a '}', exprIndex may be non-numeric and jsExprs[parseInt(exprIndex)] becomes undefined. This should only treat placeholders of the form ${<digits>} (the internal placeholder format from extractConstants) as interpolations and otherwise leave the text in the string part, with a bounds check to avoid runaway loops.

Suggested change

stringParts.push(currentStr);

currentStr = '';

i += 2;

let exprIndex = '';

while (templateStr[i] !== '}') {

exprIndex += templateStr[i];

i++;

}

expressions.push(jsExprs[parseInt(exprIndex)]);

i++; // skip }

// Attempt to parse an internal placeholder of the form `${<digits>}`

const exprStart = i + 2;

const closingBraceIndex = templateStr.indexOf('}', exprStart);

// If there is no closing brace, treat the `${` as literal text

if (closingBraceIndex === -1) {

currentStr += '${';

i += 2;

continue;

}

const exprIndexStr = templateStr.slice(exprStart, closingBraceIndex);

// Only placeholders of the form `${<digits>}` are treated as interpolations

if (!/^\d+$/.test(exprIndexStr)) {

currentStr += '${' + exprIndexStr + '}';

i = closingBraceIndex + 1;

continue;

}

const exprIndexNum = parseInt(exprIndexStr, 10);

// Ensure the index is within bounds of jsExprs; otherwise, treat as literal

if (exprIndexNum < 0 || exprIndexNum >= jsExprs.length) {

currentStr += '${' + exprIndexStr + '}';

i = closingBraceIndex + 1;

continue;

}

// Valid placeholder: flush current string part and add the expression

stringParts.push(currentStr);

currentStr = '';

expressions.push(jsExprs[exprIndexNum]);

i = closingBraceIndex + 1; // skip past the closing '}'

Copilot · 2026-02-13T12:37:36Z

src/executor.ts

+addOps<unknown, unknown, Prop<any>>(LispType.AndEquals, ({ done, b, obj, context }) => {
+  assignCheck(obj, context);
+  done(undefined, (obj.context[obj.prop] &&= b));
+});
+
+addOps<unknown, unknown, Prop<any>>(LispType.OrEquals, ({ done, b, obj, context }) => {
+  assignCheck(obj, context);
+  done(undefined, (obj.context[obj.prop] ||= b));
+});
+
+addOps<unknown, unknown, Prop<any>>(
+  LispType.NullishCoalescingEquals,
+  ({ done, b, obj, context }) => {
+    assignCheck(obj, context);
+    done(undefined, (obj.context[obj.prop] ??= b));
+  },
+);


The implementation of logical assignment operators (&&=, ||=, ??=) is not short-circuiting: by the time these ops run, b has already been evaluated by execSync/execAsync, so RHS side effects will occur even when the assignment should not happen. These operators need special-casing similar to the existing NullishCoalescing short-circuit in execSync/execAsync so that tree[2] is only evaluated when the LHS value requires it.

Copilot · 2026-02-13T12:37:36Z

src/executor.ts

+                // If finally has a return statement, it overrides everything
+                if (finallyResult instanceof ExecReturn && finallyResult.returned) {
+                  done(undefined, finallyResult);
+                  return;
+                }
+
+                // Otherwise, return the original try/catch result/error
+                if (hadError) {
+                  done(errorOrResult);
+                } else if (errorOrResult instanceof ExecReturn) {
+                  // If try/catch returned or has some other control flow, pass that through
+                  if (
+                    errorOrResult.returned ||
+                    errorOrResult.breakLoop ||
+                    errorOrResult.continueLoop
+                  ) {
+                    done(undefined, errorOrResult);
+                  } else {


In the try/finally implementation, a finally block that completes with break/continue should override the prior try/catch completion (same as return/throw). Currently only finallyResult.returned is checked, so break/continue from finally will be ignored and the outer control flow will be wrong. Treat any ExecReturn with returned/breakLoop/continueLoop from finally as overriding the prior completion.

test/eval/testCases/operator-precedence.data.ts

Copilot · 2026-02-13T12:37:37Z

test/ticksQuotaHalt.spec.ts

@@ -0,0 +1,61 @@
+import Sandbox from '../src/Sandbox';
+import { SandboxExecutionQuotaExceededError, Scope } from '../src/utils';


Unused import Scope.

Suggested change

import { SandboxExecutionQuotaExceededError, Scope } from '../src/utils';

import { SandboxExecutionQuotaExceededError } from '../src/utils';

Copilot · 2026-02-13T12:37:37Z

test/ticksQuotaHalt.spec.ts

+      }
+    `;
+    const fn = sandbox.compile(code);
+    const { context, run } = fn();


Unused variable context.

Copilot · 2026-02-13T12:37:37Z

test/ticksQuotaHalt.spec.ts

+      return str.length;
+    `;
+    const fn = sandbox.compileAsync(code);
+    const { context, run } = fn();


Unused variable context.

nyariv · 2026-02-13T16:04:59Z

Resolves:

nyariv added 8 commits February 12, 2026 13:28

finally block support

89c52f2

added missing assignment operators

c139d53

improve tests speed

7fbef8a

fix power precedence

f9af6f8

string template tagging support

86005a7

fix eval spec compliance

b108f1a

TODO.md update

2e590af

fix Object propety shorthands

445c029

nyariv requested a review from Copilot February 13, 2026 12:27

Copilot started reviewing on behalf of nyariv February 13, 2026 12:27 View session

Copilot AI reviewed Feb 13, 2026

View reviewed changes

nyariv added 2 commits February 13, 2026 16:52

fix semicolon insertion

6b35daa

pr fixes

84c69dd

nyariv added 2 commits February 13, 2026 19:26

minor test fixes

a3c29a2

version bump

8fe7566

nyariv merged commit a6816b2 into main Feb 14, 2026
1 check passed

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Comments

syntax support 2#44

syntax support 2#44
nyariv merged 12 commits intomainfrom
feat/syntax-support-2

nyariv commented Feb 12, 2026 •

edited

Loading

Uh oh!

Copilot AI left a comment

Uh oh!

Copilot AI Feb 13, 2026

Uh oh!

Copilot AI Feb 13, 2026

Uh oh!

Copilot AI Feb 13, 2026

Uh oh!

Copilot AI Feb 13, 2026

Uh oh!

Copilot AI Feb 13, 2026

Uh oh!

Uh oh!

Copilot AI Feb 13, 2026

Uh oh!

Copilot AI Feb 13, 2026

Uh oh!

Copilot AI Feb 13, 2026

Uh oh!

nyariv commented Feb 13, 2026

Uh oh!

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

1 participant

-      stringParts.push(currentStr);
-      currentStr = '';
-      i += 2;
-      let exprIndex = '';
-      while (templateStr[i] !== '}') {
-        exprIndex += templateStr[i];
-        i++;
-      }
-      expressions.push(jsExprs[parseInt(exprIndex)]);
-      i++; // skip }
+      // Attempt to parse an internal placeholder of the form `${<digits>}`
+      const exprStart = i + 2;
+      const closingBraceIndex = templateStr.indexOf('}', exprStart);
+      // If there is no closing brace, treat the `${` as literal text
+      if (closingBraceIndex === -1) {
+        currentStr += '${';
+        i += 2;
+        continue;
+      }
+      const exprIndexStr = templateStr.slice(exprStart, closingBraceIndex);
+      // Only placeholders of the form `${<digits>}` are treated as interpolations
+      if (!/^\d+$/.test(exprIndexStr)) {
+        currentStr += '${' + exprIndexStr + '}';
+        i = closingBraceIndex + 1;
+        continue;
+      }
+      const exprIndexNum = parseInt(exprIndexStr, 10);
+      // Ensure the index is within bounds of jsExprs; otherwise, treat as literal
+      if (exprIndexNum < 0 || exprIndexNum >= jsExprs.length) {
+        currentStr += '${' + exprIndexStr + '}';
+        i = closingBraceIndex + 1;
+        continue;
+      }
+      // Valid placeholder: flush current string part and add the expression
+      stringParts.push(currentStr);
+      currentStr = '';
+      expressions.push(jsExprs[exprIndexNum]);
+      i = closingBraceIndex + 1; // skip past the closing '}'

		@@ -0,0 +1,61 @@
		import Sandbox from '../src/Sandbox';
		import { SandboxExecutionQuotaExceededError, Scope } from '../src/utils';

Comments

Conversation

nyariv commented Feb 12, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

📊 Test Coverage & Code Quality Improvements

✨ New Features Implemented

Assignment Operators (ES2021)

Template Literals

🐛 Bug Fixes

Uh oh!

Copilot AI left a comment

Choose a reason for hiding this comment

Pull request overview

Reviewed changes

Uh oh!

Copilot AI Feb 13, 2026

Choose a reason for hiding this comment

Uh oh!

Copilot AI Feb 13, 2026

Choose a reason for hiding this comment

Uh oh!

Copilot AI Feb 13, 2026

Choose a reason for hiding this comment

Uh oh!

Copilot AI Feb 13, 2026

Choose a reason for hiding this comment

Uh oh!

Copilot AI Feb 13, 2026

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Copilot AI Feb 13, 2026

Choose a reason for hiding this comment

Uh oh!

Copilot AI Feb 13, 2026

Choose a reason for hiding this comment

Uh oh!

Copilot AI Feb 13, 2026

Choose a reason for hiding this comment

Uh oh!

nyariv commented Feb 13, 2026

Uh oh!

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

1 participant

nyariv commented Feb 12, 2026 •

edited

Loading