Handle keywords as props

Author: dy

feature/block.js

@@ -1,19 +1,20 @@
 // Block parsing helpers
-import { expr, skip, space, lookup, err, parse, seek, cur, idx, parens, loc, operator, compile } from '../parse.js';
+import { expr, skip, space, lookup, err, parse, seek, cur, idx, parens, loc, operator, compile, peek } from '../parse.js';
 
 const STATEMENT = 5, OBRACE = 123, CBRACE = 125;
 
-// keyword(op, prec, fn) - prefix-only word token
+// keyword(op, prec, fn) - prefix-only word token with object property support
 // keyword('while', 6, () => ['while', parens(), body()])
 // keyword('break', 6, () => ['break'])
-// attaches .loc to array results for source mapping
+// Allows property names: {while:1} won't match keyword, falls back to identifier
 export const keyword = (op, prec, map, c = op.charCodeAt(0), l = op.length, prev = lookup[c], r) =>
   lookup[c] = (a, curPrec, curOp, from = idx) =>
     !a &&
     (curOp ? op == curOp : (l < 2 || cur.substr(idx, l) == op) && (curOp = op)) &&
     curPrec < prec &&
     !parse.id(cur.charCodeAt(idx + l)) &&
-    (seek(idx + l), (r = map()) ? loc(r, from) : (seek(from), !prev && err()), r) ||
+    peek(idx + l) !== 58 &&  // allow {keyword:value}
+    (seek(idx + l), (r = map()) ? loc(r, from) : seek(from), r) ||
     prev?.(a, curPrec, curOp);
 
 // infix(op, prec, fn) - infix word token (requires left operand)

feature/class.js

@@ -1,6 +1,6 @@
 // Class declarations and expressions
 // class A extends B { ... }
-import { binary, unary, token, expr, space, next, parse, literal, word, operator, compile, skip } from '../parse.js';
+import { binary, unary, token, expr, space, next, parse, literal, word, operator, compile, skip, cur, idx } from '../parse.js';
 import { keyword, block } from './block.js';
 
 const TOKEN = 200, PREFIX = 140, COMP = 90;

feature/literal.js

@@ -7,11 +7,12 @@
  * [, undefined] serializes to [null, null] which would compile to null.
  * [] serializes to [] and compiles back to undefined.
  */
-import { literal, token } from '../parse.js';
+import { literal } from '../parse.js';
+import { keyword } from './block.js';
 
 literal('true', true);
 literal('false', false);
 literal('null', null);
-token('undefined', 200, a => !a && []);  // [] for JSON compatibility
+keyword('undefined', 200, () => []);  // [] for JSON compatibility
 literal('NaN', NaN);
 literal('Infinity', Infinity);

feature/loop.js

@@ -17,8 +17,7 @@ keyword('for', STATEMENT + 1, () => {
   // for await (x of y)
   if (word('await')) {
     skip(5);
-    space();
-    return ['for await', parens(), body()];
+    return (space(), ['for await', parens(), body()]);
   }
   return ['for', parens(), body()];
 });
@@ -55,8 +54,7 @@ keyword('continue', STATEMENT + 1, () => {
 });
 keyword('return', STATEMENT + 1, () => {
   parse.asi && (parse.newline = false);
-  space();
-  const c = cur.charCodeAt(idx);
+  const c = space();
   return !c || c === CBRACE || c === SEMI || parse.newline ? ['return'] : ['return', expr(STATEMENT)];
 });
 

feature/op/unary.js

@@ -8,17 +8,18 @@
  *
  * JS-specific keywords
  */
-import { unary, operator, compile, token, space, skip, expr, word } from '../../parse.js';
+import { unary, operator, compile, skip, expr, word } from '../../parse.js';
+import { keyword } from '../block.js';
 
 const PREFIX = 140;
 
 unary('typeof', PREFIX);
 unary('void', PREFIX);
 unary('delete', PREFIX);
-// new X() or new.target - can't use two unary() because both start with 'n' (lookup collision)
-token('new', PREFIX, a => !a && (
+// new X() or new.target
+keyword('new', PREFIX, () =>
   word('.target') ? (skip(7), ['new.target']) : ['new', expr(PREFIX)]
-));
+);
 
 // Compile
 operator('typeof', a => (a = compile(a), ctx => typeof a(ctx)));

feature/switch.js

@@ -1,15 +1,18 @@
 // Switch/case/default
 // AST: ['switch', val, ['case', test, body], ['default', body], ...]
-import { expr, skip, space, parens, operator, compile, idx, err, seek, parse, lookup, word } from '../parse.js';
+import { expr, skip, space, parens, operator, compile, idx, err, seek, parse, lookup, word, cur } from '../parse.js';
 import { keyword } from './block.js';
 import { BREAK } from './control.js';
 
 const STATEMENT = 5, ASSIGN = 20, COLON = 58, SEMI = 59, CBRACE = 125;
 
+// Flag to track if we're inside switch body (case/default parsing)
+let inSwitch = 0;
+
 // Reserve 'case' and 'default' as keywords that fail outside switch body
-// This prevents them becoming identifiers for colon operator
-const reserve = (w, c = w.charCodeAt(0), prev = lookup[c]) =>
-  lookup[c] = (a, prec, op) => (word(w) && !a && (parse.reserved = 1)) || prev?.(a, prec, op);
+// Allows property names like {case:1} ONLY when not in switch context
+const reserve = (w, l = w.length, c = w.charCodeAt(0), prev = lookup[c]) =>
+  lookup[c] = (a, prec, op) => (word(w) && !a && inSwitch) || prev?.(a, prec, op);
 reserve('case');
 reserve('default');
 
@@ -26,24 +29,27 @@ const caseBody = (c) => {
 // switchBody() - parse case/default statements
 const switchBody = () => {
   space() === 123 || err('Expected {'); skip();
+  inSwitch++;
   const cases = [];
-  while (space() !== CBRACE) {
-    if (word('case')) {
-      seek(idx + 4); space();
-      const test = expr(ASSIGN - .5);
-      space() === COLON && skip();
-      cases.push(['case', test, caseBody()]);
-    } else if (word('default')) {
-      seek(idx + 7); space() === COLON && skip();
-      cases.push(['default', caseBody()]);
-    } else err('Expected case or default');
-  }
+  try {
+    while (space() !== CBRACE) {
+      if (word('case')) {
+        seek(idx + 4); space();
+        const test = expr(ASSIGN - .5);
+        space() === COLON && skip();
+        cases.push(['case', test, caseBody()]);
+      } else if (word('default')) {
+        seek(idx + 7); space() === COLON && skip();
+        cases.push(['default', caseBody()]);
+      } else err('Expected case or default');
+    }
+  } finally { inSwitch--; }
   skip();
   return cases;
 };
 
 // switch (x) { ... }
-keyword('switch', STATEMENT + 1, () => (space(), ['switch', parens(), ...switchBody()]));
+keyword('switch', STATEMENT + 1, () => space() === 40 && ['switch', parens(), ...switchBody()]);
 
 // Compile
 operator('switch', (val, ...cases) => {

feature/var.js

@@ -8,7 +8,7 @@
  *   for (let x in o)  → ['for', ['in', ['let', 'x'], 'o'], body]
  *   var x             → ['var', 'x']   (acts as assignment target)
  */
-import { token, expr, space, operator, compile } from '../parse.js';
+import { expr, space, operator, compile } from '../parse.js';
 import { keyword } from './block.js';
 import { destructure } from './destruct.js';
 
@@ -28,8 +28,8 @@ const decl = keyword => {
   return [keyword, node];
 };
 
-token('let', STATEMENT + 1, a => !a && decl('let'));
-token('const', STATEMENT + 1, a => !a && decl('const'));
+keyword('let', STATEMENT + 1, () => decl('let'));
+keyword('const', STATEMENT + 1, () => decl('const'));
 
 // var: just declares identifier, assignment happens separately
 // var x = 5 → ['=', ['var', 'x'], 5]

parse.js

@@ -37,9 +37,8 @@ export let idx, cur,
 
   // a + b - c
   expr = (p = 0, end) => {
-    let cc, token, newNode, fn, prevReserved = parse.reserved, nl;
+    let cc, token, newNode, fn, nl;
     if (end) parse.asi && (parse.newline = false);
-    parse.reserved = 0;
 
     while (
       (cc = parse.space()) &&
@@ -48,10 +47,9 @@ export let idx, cur,
       (newNode =
         ((fn = lookup[cc]) && fn(token, p)) ??
         (token && nl && parse.asi?.(token, p, expr)) ??
-        (!token && !parse.reserved && next(parse.id))
+        (!token && next(parse.id))
       )
-    ) token = newNode, parse.reserved = 0;
-    parse.reserved = prevReserved;
+    ) token = newNode;
 
     if (end) cc == end ? idx++ : err('Unclosed ' + String.fromCharCode(end - (end > 42 ? 2 : 1)));
 
@@ -67,6 +65,9 @@ export let idx, cur,
     return cc
   },
 
+  // peek at next non-space char without modifying idx
+  peek = (from = idx) => { while (cur.charCodeAt(from) <= SPACE) from++; return cur.charCodeAt(from); },
+
   // is char an id?
   id = parse.id = c =>
     (c >= 48 && c <= 57) ||
@@ -87,7 +88,8 @@ export let idx, cur,
   // precedence registry - features register via token(), others can read
   prec = {},
 
-  // create operator checker/mapper
+  // create operator checker/mapper - for symbols and special cases
+  // For prefix word operators, prefer keyword() from block.js
   token = (
     op,
     p = SPACE,
@@ -104,17 +106,17 @@ export let idx, cur,
         (l < 2 || (op.charCodeAt(1) === cur.charCodeAt(idx + 1) && (l < 3 || cur.substr(idx, l) == op))) && (!word || !parse.id(cur.charCodeAt(idx + l))) && (matched = curOp = op)
       ) &&
       curPrec < p &&
-      (idx += l, (r = map(a)) ? loc(r, from) : (idx = from, matched = 0, word && r !== false && (parse.reserved = 1), !word && !prev && err()), r)
+      (idx += l, (r = map(a)) ? loc(r, from) : (idx = from, matched = 0, !word && !prev && err()), r)
     ) ||
     prev?.(a, curPrec, matched)),
 
-  binary = (op, p, right = false) => token(op, p, (a, b) => a && (b = expr(p - (right ? .5 : 0))) && [op, a, b]),
+  binary = (op, p, right = false) => token(op, p, a => a && (b => b && [op, a, b])(expr(p - (right ? .5 : 0)))),
 
   unary = (op, p, post) => token(op, p, a => post ? (a && [op, a]) : (!a && (a = expr(p - .5)) && [op, a])),
 
   literal = (op, val) => token(op, 200, a => !a && [, val]),
 
-  nary = (op, p, right) => {
+  nary = (op, p, right) =>
     token(op, p,
       (a, b) => (
         b = expr(p - (right ? .5 : 0)),
@@ -124,7 +126,7 @@ export let idx, cur,
           a
         ))
     )
-  },
+  ,
 
   group = (op, p) => token(op[0], p, a => (!a && [op, expr(0, op.charCodeAt(1)) || null])),
 

test/jessie.js

@@ -76,6 +76,15 @@ test('jessie: block vs object detection', () => {
   is(parse('{a:1}'), ['{}', [':', 'a', [, 1]]])
   is(parse('{a,b}'), ['{}', [',', 'a', 'b']])
 
+  // Objects - keyword property names
+  is(parse('{for:1}'), ['{}', [':', 'for', [, 1]]])
+  is(parse('{for:1, title:2}'), ['{}', [',', [':', 'for', [, 1]], [':', 'title', [, 2]]]])
+  is(parse('{let:1}'), ['{}', [':', 'let', [, 1]]])
+  is(parse('{new:1}'), ['{}', [':', 'new', [, 1]]])
+  is(parse('{undefined:1}'), ['{}', [':', 'undefined', [, 1]]])
+  is(parse('{if:1, while:2, for:3}'), ['{}', [',', [':', 'if', [, 1]], [':', 'while', [, 2]], [':', 'for', [, 3]]]])
+  is(run('{for:1, title:2}'), {for: 1, title: 2})
+
   // Block evaluation - creates scope, returns last value
   is(run('{let x=1; x+1}'), 2)
   is(run('{let x=1}; x', {x: 5}), 5)  // block scope doesn't leak