Fix reserved words being consumed as keywords after .

Member property names are IdentifierNames, not expressions, so `a.class`,
`a?.function` etc. wrongly invoked keyword handlers. Add a `member`
registrar whose right side is parsed as a name (falling back to expr for
#private/numeric), replace `binary('.')` in access/prop with it, and use
the shared `propName` for `?.` too.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

Author: dy

feature/access.js

@@ -2,15 +2,15 @@
  * Property access: a.b, a[b], a(b), [1,2,3] - parse half
  * For private fields (#x), see class.js
  */
-import { access, binary } from '../parse.js';
+import { access, member } from '../parse.js';
 
 const ACCESS = 170;
 
 // a[b]
 access('[]', ACCESS);
 
-// a.b
-binary('.', ACCESS);
+// a.b - property name is an IdentifierName (reserved words allowed)
+member('.', ACCESS);
 
 // a(b,c,d), a()
 access('()', ACCESS);

feature/op/optional.js

@@ -5,7 +5,7 @@
  * a?.[x] → optional computed access
  * a?.() → optional call
  */
-import { parse, token, expr, skip } from '../../parse.js';
+import { parse, token, expr, skip, propName } from '../../parse.js';
 
 const ACCESS = 170;
 
@@ -16,7 +16,7 @@ token('?.', ACCESS, (a, b) => {
   if (cc === 40) { skip(); return ['?.()', a, expr(0, 41) || null]; }
   // Optional computed: a?.[x]
   if (cc === 91) { skip(); return ['?.[]', a, expr(0, 93)]; }
-  // Optional member: a?.b
-  b = expr(ACCESS);
+  // Optional member: a?.b - property name is an IdentifierName
+  b = propName(ACCESS);
   return b ? ['?.', a, b] : void 0;
 });

feature/prop.js

@@ -2,15 +2,15 @@
  * Minimal property access: a.b, a[b], f() - parse half
  * For array literals, private fields, see member.js
  */
-import { access, binary, group } from '../parse.js';
+import { access, member, group } from '../parse.js';
 
 const ACCESS = 170;
 
 // a[b] - computed member access only (no array literal support)
 access('[]', ACCESS);
 
-// a.b - dot member access
-binary('.', ACCESS);
+// a.b - dot member access; property name is an IdentifierName
+member('.', ACCESS);
 
 // (a) - grouping only (no sequences)
 group('()', ACCESS);

parse.js

@@ -1,4 +1,12 @@
-// Pratt parser core + operator registry + compile
+// Pratt parser core + operator registry + compile.
+//
+// Language-agnostic by design: the core (token / lookup / prec / the expr loop)
+// assumes no particular language. The registrars below — binary, unary, nary,
+// literal, group, access, member, keyword — are a shared toolkit of common
+// operator *shapes*; each is parameterized by operator string + precedence, so a
+// dialect composes its grammar from them. Keep language-specific rules in
+// feature/*, not here.
+
 // Character codes
 const SPACE = 32;
 
@@ -116,6 +124,16 @@ export let idx, cur,
 
   access = (op, p) => token(op[0], p, a => (a && [op, a, expr(0, op.charCodeAt(1)) || null])),
 
+  // propName(p) - parse the right side of a name-access operator. A bare name
+  // beats keyword/operator matching, so reserved words read as plain identifiers
+  // (a.class). Non-name starts (digit, #, ...) fall back to expr(p), keeping the
+  // door open for any dialect-defined token there. Uses the live parse.id.
+  propName = (p, c) => (parse.space(), c = cur.charCodeAt(idx), parse.id(c) && (c < 48 || c > 57) ? next(parse.id) : expr(p)),
+
+  // member(op, p) - binary operator whose right side is a name, not an expression
+  // (a.b, a::b, a->b). Same [op, a, b] shape as binary().
+  member = (op, p) => token(op, p, a => a && (b => b && [op, a, b])(propName(p))),
+
   // keyword(op, prec, fn) - prefix word token with property name support
   // parse.prop set by collection.js to prevent matching {keyword: value}
   keyword = (op, prec, map, c = op.charCodeAt(0), l = op.length, prev = lookup[c], r) =>

subscript.d.ts

@@ -28,6 +28,8 @@ export function literal(op: string, val: any): void;
 export function nary(op: string, prec: number, right?: boolean): void;
 export function group(op: string, prec: number): void;
 export function access(op: string, prec: number): void;
+export function member(op: string, prec: number): void;
+export function propName(prec: number): AST;
 
 // Compile exports
 export const operators: Record<string, Operator>;

test/jessie.js

@@ -24,6 +24,21 @@ test('jessie: inherits justin', () => {
   is(parse('{a: 1}'), ['{}', [':', 'a', [, 1]]])
 })
 
+// === reserved words as member property names ===
+// After `.`/`?.` the grammar is an IdentifierName - reserved words are plain names.
+
+test('jessie: reserved words in member access', () => {
+  is(parse('record.class.name'), ['.', ['.', 'record', 'class'], 'name'])
+  is(parse('record.function.kind'), ['.', ['.', 'record', 'function'], 'kind'])
+  is(parse('a.if.else'), ['.', ['.', 'a', 'if'], 'else'])
+  is(parse('a?.class'), ['?.', 'a', 'class'])
+  is(parse('a?.function'), ['?.', 'a', 'function'])
+  is(parse('a. class'), ['.', 'a', 'class'])  // whitespace before name
+  is(parse('a.#x'), ['.', 'a', '#x'])         // private name still works
+  is(parse('a.b(class X{})'), ['()', ['.', 'a', 'b'], ['class', 'X', null, null]])  // class arg unaffected
+  is(run('o.class + o.function', { o: { class: 2, function: 3 } }), 5)
+})
+
 // === variables ===
 
 test('jessie: variables', () => {