@kernlang/core 3.3.9 → 3.4.1

package/dist/parser-expression.js

@@ -0,0 +1,774 @@
+/** Expression-mode tokenizer + recursive-descent parser producing ValueIR.
+ *  Supports: identifiers, literals (number/string/true/false/null/undefined/none),
+ *  member access (. and ?.), call (() and ?.()), spread (...), logical ?? || &&,
+ *  parenthesized grouping, template literals with ${...} interpolation,
+ *  `await` prefix, propagation `?` postfix on call/await-call.
+ *
+ *  `none` is a KERN-side alias for `null` — both produce nullLit. Per native-handler
+ *  spec, `none` is the canonical empty-value form in `lang=kern` bodies; `null` is
+ *  retained for legacy/round-trip compatibility.
+ *
+ *  Intentionally NOT yet supported: arithmetic, comparisons, ternary, indexing,
+ *  bitwise, assignment. Those land in a later slice. */
+const KEYWORDS = {
+    null: 'kwNull',
+    none: 'kwNull',
+    undefined: 'kwUndef',
+    true: 'kwTrue',
+    false: 'kwFalse',
+    await: 'kwAwait',
+    // Slice 4c+4d review fix (Codex P2): `new` is prefix-position-only.
+    // Tokenizing it as `kwNew` globally broke `obj.new` and `{ new: 1 }`
+    // for property/key names. Now an `ident` token; parseUnary checks
+    // `value === 'new'` to recognize the prefix-position usage.
+};
+function isDigit(ch) {
+    return ch >= '0' && ch <= '9';
+}
+function isIdentStart(ch) {
+    return (ch >= 'A' && ch <= 'Z') || (ch >= 'a' && ch <= 'z') || ch === '_' || ch === '$';
+}
+function isIdentChar(ch) {
+    return isIdentStart(ch) || isDigit(ch);
+}
+function isHexDigit(ch) {
+    return isDigit(ch) || (ch >= 'a' && ch <= 'f') || (ch >= 'A' && ch <= 'F');
+}
+function consumeDigitsStrict(input, start, isValid) {
+    let i = start;
+    let started = false;
+    let lastWasUnderscore = false;
+    while (i < input.length) {
+        const c = input[i];
+        if (isValid(c)) {
+            lastWasUnderscore = false;
+            started = true;
+            i++;
+        }
+        else if (c === '_' && started && !lastWasUnderscore && i + 1 < input.length && isValid(input[i + 1])) {
+            lastWasUnderscore = true;
+            i++;
+        }
+        else {
+            break;
+        }
+    }
+    return i;
+}
+function consumeNumber(input, start) {
+    let i = start;
+    const ch = input[i];
+    if (ch === '0' && i + 1 < input.length) {
+        const next = input[i + 1];
+        let validator = null;
+        if (next === 'x' || next === 'X')
+            validator = isHexDigit;
+        else if (next === 'b' || next === 'B')
+            validator = (c) => c === '0' || c === '1';
+        else if (next === 'o' || next === 'O')
+            validator = (c) => c >= '0' && c <= '7';
+        if (validator) {
+            const after = consumeDigitsStrict(input, i + 2, validator);
+            if (after === i + 2)
+                return start;
+            i = after;
+            if (i < input.length && input[i] === 'n')
+                i++;
+            return i;
+        }
+    }
+    const hasInt = isDigit(ch);
+    let j = hasInt ? consumeDigitsStrict(input, i, isDigit) : i;
+    let hasFrac = false;
+    if (j < input.length && input[j] === '.' && j + 1 < input.length && isDigit(input[j + 1])) {
+        j++;
+        j = consumeDigitsStrict(input, j, isDigit);
+        hasFrac = true;
+    }
+    if (!hasInt && !hasFrac)
+        return start;
+    if (!hasFrac && j < input.length && input[j] === 'n') {
+        j++;
+    }
+    else if (hasFrac && j < input.length && input[j] === 'n') {
+        throw new Error(`BigInt literal cannot have a fractional part at column ${start + 1}`);
+    }
+    return j;
+}
+function consumeString(input, start) {
+    const quote = input[start];
+    let i = start + 1;
+    let value = '';
+    while (i < input.length && input[i] !== quote) {
+        if (input[i] === '\\' && i + 1 < input.length) {
+            const next = input[i + 1];
+            if (next === quote) {
+                value += quote;
+                i += 2;
+            }
+            else if (next === '\\') {
+                value += '\\';
+                i += 2;
+            }
+            else if (next === 'n') {
+                value += '\n';
+                i += 2;
+            }
+            else if (next === 't') {
+                value += '\t';
+                i += 2;
+            }
+            else {
+                value += input[i];
+                i++;
+            }
+        }
+        else {
+            value += input[i];
+            i++;
+        }
+    }
+    if (i >= input.length)
+        throw new Error(`Unclosed string starting at column ${start + 1}`);
+    return { end: i + 1, value };
+}
+/** Tokenize an expression source. Stops at end of input. */
+export function tokenizeExpression(input) {
+    const tokens = [];
+    let i = 0;
+    while (i < input.length) {
+        const ch = input[i];
+        if (ch === ' ' || ch === '\t' || ch === '\n') {
+            i++;
+            continue;
+        }
+        if (ch === '`') {
+            const start = i;
+            i = scanTemplateEnd(input, i + 1);
+            tokens.push({ kind: 'tmplStart', value: '`', pos: start });
+            continue;
+        }
+        if (ch === '?' && input[i + 1] === '.') {
+            tokens.push({ kind: 'optDot', value: '?.', pos: i });
+            i += 2;
+            continue;
+        }
+        if (ch === '?' && input[i + 1] === '?') {
+            tokens.push({ kind: 'nullish', value: '??', pos: i });
+            i += 2;
+            continue;
+        }
+        if (ch === '?') {
+            tokens.push({ kind: 'qmark', value: '?', pos: i });
+            i++;
+            continue;
+        }
+        // Slice 2c — equality / strict-equality / negation. Multi-char first.
+        if (ch === '=' && input[i + 1] === '=' && input[i + 2] === '=') {
+            tokens.push({ kind: 'strictEq', value: '===', pos: i });
+            i += 3;
+            continue;
+        }
+        if (ch === '=' && input[i + 1] === '=') {
+            tokens.push({ kind: 'eq', value: '==', pos: i });
+            i += 2;
+            continue;
+        }
+        if (ch === '!' && input[i + 1] === '=' && input[i + 2] === '=') {
+            tokens.push({ kind: 'strictNeq', value: '!==', pos: i });
+            i += 3;
+            continue;
+        }
+        if (ch === '!' && input[i + 1] === '=') {
+            tokens.push({ kind: 'neq', value: '!=', pos: i });
+            i += 2;
+            continue;
+        }
+        if (ch === '!') {
+            tokens.push({ kind: 'bang', value: '!', pos: i });
+            i++;
+            continue;
+        }
+        // Slice 2c — relational. Multi-char first so `<=` / `>=` win over bare `<` / `>`.
+        if (ch === '<' && input[i + 1] === '=') {
+            tokens.push({ kind: 'lte', value: '<=', pos: i });
+            i += 2;
+            continue;
+        }
+        if (ch === '<') {
+            tokens.push({ kind: 'lt', value: '<', pos: i });
+            i++;
+            continue;
+        }
+        if (ch === '>' && input[i + 1] === '=') {
+            tokens.push({ kind: 'gte', value: '>=', pos: i });
+            i += 2;
+            continue;
+        }
+        if (ch === '>') {
+            tokens.push({ kind: 'gt', value: '>', pos: i });
+            i++;
+            continue;
+        }
+        // Slice 2c — arithmetic. `-` could be sign of a number, but the number
+        // tokenizer below handles only unsigned literals; unary minus is a parser
+        // concern (see parseUnary), so keep `-` as its own token here.
+        if (ch === '+') {
+            tokens.push({ kind: 'plus', value: '+', pos: i });
+            i++;
+            continue;
+        }
+        if (ch === '-') {
+            tokens.push({ kind: 'minus', value: '-', pos: i });
+            i++;
+            continue;
+        }
+        if (ch === '*') {
+            tokens.push({ kind: 'star', value: '*', pos: i });
+            i++;
+            continue;
+        }
+        if (ch === '/') {
+            tokens.push({ kind: 'slash', value: '/', pos: i });
+            i++;
+            continue;
+        }
+        if (ch === '%') {
+            tokens.push({ kind: 'percent', value: '%', pos: i });
+            i++;
+            continue;
+        }
+        if (ch === '|' && input[i + 1] === '|') {
+            tokens.push({ kind: 'or', value: '||', pos: i });
+            i += 2;
+            continue;
+        }
+        if (ch === '&' && input[i + 1] === '&') {
+            tokens.push({ kind: 'and', value: '&&', pos: i });
+            i += 2;
+            continue;
+        }
+        if (ch === '.' && input[i + 1] === '.' && input[i + 2] === '.') {
+            tokens.push({ kind: 'spread', value: '...', pos: i });
+            i += 3;
+            continue;
+        }
+        // Number must be checked BEFORE bare-dot so leading-dot floats (.5) lex as num
+        if (isDigit(ch) || (ch === '.' && i + 1 < input.length && isDigit(input[i + 1]))) {
+            const end = consumeNumber(input, i);
+            if (end > i) {
+                tokens.push({ kind: 'num', value: input.slice(i, end), pos: i });
+                i = end;
+                continue;
+            }
+        }
+        if (ch === '.') {
+            tokens.push({ kind: 'dot', value: '.', pos: i });
+            i++;
+            continue;
+        }
+        if (ch === '(') {
+            tokens.push({ kind: 'lparen', value: '(', pos: i });
+            i++;
+            continue;
+        }
+        if (ch === ')') {
+            tokens.push({ kind: 'rparen', value: ')', pos: i });
+            i++;
+            continue;
+        }
+        if (ch === '{') {
+            tokens.push({ kind: 'lbrace', value: '{', pos: i });
+            i++;
+            continue;
+        }
+        if (ch === '}') {
+            tokens.push({ kind: 'rbrace', value: '}', pos: i });
+            i++;
+            continue;
+        }
+        if (ch === '[') {
+            tokens.push({ kind: 'lbracket', value: '[', pos: i });
+            i++;
+            continue;
+        }
+        if (ch === ']') {
+            tokens.push({ kind: 'rbracket', value: ']', pos: i });
+            i++;
+            continue;
+        }
+        if (ch === ':') {
+            tokens.push({ kind: 'colon', value: ':', pos: i });
+            i++;
+            continue;
+        }
+        if (ch === ',') {
+            tokens.push({ kind: 'comma', value: ',', pos: i });
+            i++;
+            continue;
+        }
+        if (ch === '"' || ch === "'") {
+            const { end, value } = consumeString(input, i);
+            tokens.push({ kind: 'str', value, pos: i });
+            // Preserve raw form for codegen quote-style preservation
+            tokens[tokens.length - 1].quote = ch;
+            i = end;
+            continue;
+        }
+        if (isIdentStart(ch)) {
+            const start = i;
+            while (i < input.length && isIdentChar(input[i]))
+                i++;
+            const word = input.slice(start, i);
+            const kw = KEYWORDS[word];
+            if (kw) {
+                tokens.push({ kind: kw, value: word, pos: start });
+            }
+            else {
+                tokens.push({ kind: 'ident', value: word, pos: start });
+            }
+            continue;
+        }
+        throw new Error(`Unexpected character '${ch}' at column ${i + 1}`);
+    }
+    tokens.push({ kind: 'eof', value: '', pos: i });
+    return tokens;
+}
+// ── Parser ───────────────────────────────────────────────────────────────
+class Parser {
+    tokens;
+    input;
+    i = 0;
+    constructor(tokens, input) {
+        this.tokens = tokens;
+        this.input = input;
+    }
+    peek(offset = 0) {
+        return this.tokens[this.i + offset];
+    }
+    advance() {
+        return this.tokens[this.i++];
+    }
+    expect(kind) {
+        const t = this.peek();
+        if (t.kind !== kind)
+            throw new Error(`Expected ${kind}, got ${t.kind} ('${t.value}') at column ${t.pos + 1}`);
+        return this.advance();
+    }
+    parse() {
+        const result = this.parseNullish();
+        if (this.peek().kind !== 'eof') {
+            const t = this.peek();
+            throw new Error(`Unexpected token ${t.kind} ('${t.value}') at column ${t.pos + 1}`);
+        }
+        return result;
+    }
+    parseNullish() {
+        let left = this.parseOr();
+        while (this.peek().kind === 'nullish') {
+            this.advance();
+            const right = this.parseOr();
+            left = { kind: 'binary', op: '??', left, right };
+        }
+        return left;
+    }
+    parseOr() {
+        let left = this.parseAnd();
+        while (this.peek().kind === 'or') {
+            this.advance();
+            const right = this.parseAnd();
+            left = { kind: 'binary', op: '||', left, right };
+        }
+        return left;
+    }
+    parseAnd() {
+        let left = this.parseEquality();
+        while (this.peek().kind === 'and') {
+            this.advance();
+            const right = this.parseEquality();
+            left = { kind: 'binary', op: '&&', left, right };
+        }
+        return left;
+    }
+    // Slice 2c — equality (==, !=, ===, !==), left-associative.
+    parseEquality() {
+        let left = this.parseRelational();
+        while (true) {
+            const k = this.peek().kind;
+            if (k !== 'eq' && k !== 'neq' && k !== 'strictEq' && k !== 'strictNeq')
+                break;
+            const op = this.advance().value;
+            const right = this.parseRelational();
+            left = { kind: 'binary', op, left, right };
+        }
+        return left;
+    }
+    // Slice 2c — relational (<, <=, >, >=), left-associative.
+    parseRelational() {
+        let left = this.parseAdditive();
+        while (true) {
+            const k = this.peek().kind;
+            if (k !== 'lt' && k !== 'lte' && k !== 'gt' && k !== 'gte')
+                break;
+            const op = this.advance().value;
+            const right = this.parseAdditive();
+            left = { kind: 'binary', op, left, right };
+        }
+        return left;
+    }
+    // Slice 2c — additive (+, -), left-associative.
+    parseAdditive() {
+        let left = this.parseMultiplicative();
+        while (true) {
+            const k = this.peek().kind;
+            if (k !== 'plus' && k !== 'minus')
+                break;
+            const op = this.advance().value;
+            const right = this.parseMultiplicative();
+            left = { kind: 'binary', op, left, right };
+        }
+        return left;
+    }
+    // Slice 2c — multiplicative (*, /, %), left-associative.
+    parseMultiplicative() {
+        let left = this.parseUnary();
+        while (true) {
+            const k = this.peek().kind;
+            if (k !== 'star' && k !== 'slash' && k !== 'percent')
+                break;
+            const op = this.advance().value;
+            const right = this.parseUnary();
+            left = { kind: 'binary', op, left, right };
+        }
+        return left;
+    }
+    parseUnary() {
+        if (this.peek().kind === 'spread') {
+            this.advance();
+            return { kind: 'spread', argument: this.parseUnary() };
+        }
+        if (this.peek().kind === 'bang') {
+            this.advance();
+            return { kind: 'unary', op: '!', argument: this.parseUnary() };
+        }
+        if (this.peek().kind === 'minus') {
+            this.advance();
+            return { kind: 'unary', op: '-', argument: this.parseUnary() };
+        }
+        if (this.peek().kind === 'kwAwait') {
+            this.advance();
+            // Use parseCall (not parsePostfix) so the trailing `?` stays available
+            // for the outer await + propagation composition. With parsePostfix the
+            // `?` would bind to the call alone, producing `await(propagate(call()))`
+            // instead of the semantically-correct `propagate(await(call()))`.
+            const argument = this.parseCall();
+            const awaited = { kind: 'await', argument };
+            if (this.peek().kind === 'qmark') {
+                this.advance();
+                return { kind: 'propagate', argument: awaited, op: '?' };
+            }
+            return awaited;
+        }
+        // Slice 4c+4d review fix (Codex P2) — match `new` only in prefix
+        // position so `obj.new` and `{ new: 1 }` keep working as identifier
+        // / property-name uses.
+        if (this.peek().kind === 'ident' && this.peek().value === 'new') {
+            this.advance();
+            const argument = this.parseCall();
+            return { kind: 'new', argument };
+        }
+        return this.parsePostfix();
+    }
+    parsePostfix() {
+        const node = this.parseCall();
+        if (this.peek().kind === 'qmark') {
+            this.advance();
+            return { kind: 'propagate', argument: node, op: '?' };
+        }
+        return node;
+    }
+    parseCall() {
+        let node = this.parsePrimary();
+        while (true) {
+            const t = this.peek();
+            if (t.kind === 'dot') {
+                this.advance();
+                const name = this.expect('ident');
+                node = { kind: 'member', object: node, property: name.value, optional: false };
+            }
+            else if (t.kind === 'optDot') {
+                this.advance();
+                const next = this.peek();
+                if (next.kind === 'lparen') {
+                    this.advance();
+                    const args = this.parseArgs();
+                    this.expect('rparen');
+                    node = { kind: 'call', callee: node, args, optional: true };
+                }
+                else {
+                    const name = this.expect('ident');
+                    node = { kind: 'member', object: node, property: name.value, optional: true };
+                }
+            }
+            else if (t.kind === 'lparen') {
+                this.advance();
+                const args = this.parseArgs();
+                this.expect('rparen');
+                node = { kind: 'call', callee: node, args, optional: false };
+            }
+            else {
+                break;
+            }
+        }
+        return node;
+    }
+    parseArgs() {
+        const args = [];
+        if (this.peek().kind === 'rparen')
+            return args;
+        args.push(this.parseNullish());
+        while (this.peek().kind === 'comma') {
+            this.advance();
+            args.push(this.parseNullish());
+        }
+        return args;
+    }
+    parsePrimary() {
+        const t = this.peek();
+        switch (t.kind) {
+            case 'ident':
+                this.advance();
+                return { kind: 'ident', name: t.value };
+            case 'num': {
+                this.advance();
+                const raw = t.value;
+                const isBig = raw.endsWith('n');
+                const numStr = isBig ? raw.slice(0, -1).replace(/_/g, '') : raw.replace(/_/g, '');
+                const value = isBig ? 0 : Number(numStr);
+                return isBig ? { kind: 'numLit', value, bigint: true, raw } : { kind: 'numLit', value, raw };
+            }
+            case 'str': {
+                this.advance();
+                const quote = (t.quote ?? '"');
+                return { kind: 'strLit', value: t.value, quote };
+            }
+            case 'kwTrue':
+                this.advance();
+                return { kind: 'boolLit', value: true };
+            case 'kwFalse':
+                this.advance();
+                return { kind: 'boolLit', value: false };
+            case 'kwNull':
+                this.advance();
+                return { kind: 'nullLit' };
+            case 'kwUndef':
+                this.advance();
+                return { kind: 'undefLit' };
+            case 'lparen': {
+                this.advance();
+                const inner = this.parseNullish();
+                this.expect('rparen');
+                return inner;
+            }
+            case 'lbrace':
+                this.advance();
+                return this.parseObjectLiteral();
+            case 'lbracket':
+                this.advance();
+                return this.parseArrayLiteral();
+            case 'tmplStart':
+                this.advance();
+                return this.parseTemplate(t.pos);
+            default:
+                throw new Error(`Unexpected token ${t.kind} ('${t.value}') at column ${t.pos + 1}`);
+        }
+    }
+    // Slice 2d — object literal: `{ key: value, "str-key": value }`. Computed
+    // keys (`[expr]:`) defer to slice 3.
+    parseObjectLiteral() {
+        const entries = [];
+        if (this.peek().kind === 'rbrace') {
+            this.advance();
+            return { kind: 'objectLit', entries };
+        }
+        while (true) {
+            const keyTok = this.peek();
+            if (keyTok.kind === 'spread') {
+                this.advance();
+                const argument = this.parseNullish();
+                entries.push({ kind: 'spread', argument });
+            }
+            else {
+                let key;
+                if (keyTok.kind === 'ident') {
+                    key = keyTok.value;
+                    this.advance();
+                }
+                else if (keyTok.kind === 'str') {
+                    key = keyTok.value;
+                    this.advance();
+                }
+                else {
+                    throw new Error(`Object literal key must be an identifier, string, or spread at column ${keyTok.pos + 1}`);
+                }
+                this.expect('colon');
+                const value = this.parseNullish();
+                entries.push({ key, value });
+            }
+            if (this.peek().kind === 'comma') {
+                this.advance();
+                // Trailing comma allowed.
+                if (this.peek().kind === 'rbrace')
+                    break;
+                continue;
+            }
+            break;
+        }
+        this.expect('rbrace');
+        return { kind: 'objectLit', entries };
+    }
+    // Slice 2d — array literal: `[a, b, c]`.
+    parseArrayLiteral() {
+        const items = [];
+        if (this.peek().kind === 'rbracket') {
+            this.advance();
+            return { kind: 'arrayLit', items };
+        }
+        while (true) {
+            items.push(this.parseNullish());
+            if (this.peek().kind === 'comma') {
+                this.advance();
+                if (this.peek().kind === 'rbracket')
+                    break;
+                continue;
+            }
+            break;
+        }
+        this.expect('rbracket');
+        return { kind: 'arrayLit', items };
+    }
+    parseTemplate(startPos) {
+        // After consuming opening backtick, scan source from token's source position + 1
+        // We don't have nice token-stream coverage of template guts (the tokenizer treated
+        // ` as just a marker), so re-scan the raw input.
+        const quasis = [];
+        const expressions = [];
+        let pos = startPos + 1;
+        let buf = '';
+        while (pos < this.input.length) {
+            const ch = this.input[pos];
+            if (ch === '`') {
+                quasis.push(buf);
+                // Re-sync the parent tokenizer by setting `i` past this template.
+                // Find the corresponding eof or token at this pos.
+                this.resyncAfter(pos + 1);
+                return { kind: 'tmplLit', quasis, expressions };
+            }
+            if (ch === '\\' && pos + 1 < this.input.length) {
+                const next = this.input[pos + 1];
+                if (next === '`') {
+                    buf += '`';
+                    pos += 2;
+                    continue;
+                }
+                if (next === '\\') {
+                    buf += '\\';
+                    pos += 2;
+                    continue;
+                }
+                if (next === '$') {
+                    buf += '$';
+                    pos += 2;
+                    continue;
+                }
+                if (next === 'n') {
+                    buf += '\n';
+                    pos += 2;
+                    continue;
+                }
+                if (next === 't') {
+                    buf += '\t';
+                    pos += 2;
+                    continue;
+                }
+                buf += ch;
+                pos++;
+                continue;
+            }
+            if (ch === '$' && this.input[pos + 1] === '{') {
+                quasis.push(buf);
+                buf = '';
+                pos += 2;
+                const exprEnd = findMatchingBrace(this.input, pos);
+                const exprSrc = this.input.slice(pos, exprEnd);
+                const innerTokens = tokenizeExpression(exprSrc);
+                const innerParser = new Parser(innerTokens, exprSrc);
+                expressions.push(innerParser.parse());
+                pos = exprEnd + 1;
+                continue;
+            }
+            buf += ch;
+            pos++;
+        }
+        throw new Error(`Unclosed template literal starting at column ${startPos + 1}`);
+    }
+    resyncAfter(pos) {
+        // Drop any tokens whose pos < `pos` from being re-consumed; jump past them.
+        while (this.i < this.tokens.length && this.tokens[this.i].pos < pos)
+            this.i++;
+    }
+}
+function scanTemplateEnd(input, start) {
+    let i = start;
+    while (i < input.length) {
+        const ch = input[i];
+        if (ch === '\\' && i + 1 < input.length) {
+            i += 2;
+            continue;
+        }
+        if (ch === '`')
+            return i + 1;
+        if (ch === '$' && input[i + 1] === '{') {
+            i = findMatchingBrace(input, i + 2) + 1;
+            continue;
+        }
+        i++;
+    }
+    throw new Error(`Unclosed template literal starting at column ${start}`);
+}
+function findMatchingBrace(input, start) {
+    let depth = 1;
+    let i = start;
+    while (i < input.length) {
+        const ch = input[i];
+        if (ch === '{')
+            depth++;
+        else if (ch === '}') {
+            depth--;
+            if (depth === 0)
+                return i;
+        }
+        else if (ch === '`') {
+            i = scanTemplateEnd(input, i + 1);
+            continue;
+        }
+        else if (ch === '"' || ch === "'") {
+            let j = i + 1;
+            while (j < input.length && input[j] !== ch) {
+                if (input[j] === '\\')
+                    j += 2;
+                else
+                    j++;
+            }
+            i = j;
+        }
+        i++;
+    }
+    throw new Error(`Unclosed \${...} substitution starting at column ${start + 1}`);
+}
+export function parseExpression(input) {
+    const tokens = tokenizeExpression(input);
+    const parser = new Parser(tokens, input);
+    return parser.parse();
+}
+//# sourceMappingURL=parser-expression.js.map