rooklang 0.0.0-stage → 0.3.0

package/dist/parser/expressions.js

@@ -0,0 +1,255 @@
+import { BINARY_PRECEDENCE, isBinaryOperator, isUnaryOperator, RESERVED, describe, } from "./syntax.js";
+import { TypeParser } from "./types.js";
+// Expressions: operators with their precedence, member access, calls and indexing.
+export class ExpressionParser extends TypeParser {
+    parseExpression() {
+        const test = this.parseBinary(1);
+        if (!this.accept('?'))
+            return test;
+        const consequent = this.parseExpression();
+        this.expect(':');
+        const alternate = this.parseExpression();
+        return {
+            kind: 'ConditionalExpression',
+            test,
+            consequent,
+            alternate,
+            start: test.start,
+            end: alternate.end,
+        };
+    }
+    /** Precedence climbing: parses operators that bind at least as tight as `minPrecedence`. */
+    parseBinary(minPrecedence) {
+        let left = this.parseUnary();
+        while (true) {
+            const operator = this.peek().kind;
+            // `value as Type` binds like a comparison, as in TypeScript.
+            if (this.checkWord('as') && minPrecedence <= BINARY_PRECEDENCE['<']) {
+                this.next();
+                const type = this.parseType();
+                left = { kind: 'AsExpression', expression: left, type, start: left.start, end: type.end };
+                continue;
+            }
+            if (!isBinaryOperator(operator))
+                return left;
+            const precedence = BINARY_PRECEDENCE[operator];
+            if (precedence < minPrecedence)
+                return left;
+            this.next();
+            // `**` is right-associative, all other binary operators are left-associative.
+            const right = this.parseBinary(operator === '**' ? precedence : precedence + 1);
+            left = this.makeBinary(operator, left, right);
+        }
+    }
+    /** Rejects combinations that JS forbids without parentheses, since the output must be valid JS. */
+    makeBinary(operator, left, right) {
+        if (operator === '??') {
+            for (const operand of [left, right]) {
+                if (operand.kind === 'BinaryExpression' &&
+                    (operand.operator === '||' || operand.operator === '&&') &&
+                    !this.parenthesized.has(operand)) {
+                    this.error('"??" cannot be mixed with "||" or "&&" without parentheses', operand.start, operand.end);
+                }
+            }
+        }
+        if (operator === '**' && left.kind === 'UnaryExpression' && !this.parenthesized.has(left)) {
+            this.error('wrap the unary expression in parentheses: "(-a) ** b" or "-(a ** b)"', left.start, left.end);
+        }
+        return { kind: 'BinaryExpression', operator, left, right, start: left.start, end: right.end };
+    }
+    parseUnary() {
+        const token = this.peek();
+        if (isUnaryOperator(token.kind)) {
+            const operator = token.kind;
+            if (operator === 'await' || operator === '<-') {
+                this.requireAsync(operator, token.start, token.end);
+            }
+            this.next();
+            const argument = this.parseUnary();
+            return { kind: 'UnaryExpression', operator, argument, start: token.start, end: argument.end };
+        }
+        if (token.kind === '++' || token.kind === '--') {
+            this.fail(`"${token.kind}" must follow the variable: "i${token.kind}"`);
+        }
+        if (token.kind === 'go') {
+            this.next();
+            if (this.check('for')) {
+                this.fail('"go for" is a statement: it waits for its parts and gives no value');
+            }
+            const call = this.parsePostfix(this.parsePrimary());
+            if (call.kind !== 'CallExpression' || call.optional) {
+                this.failAt('"go" needs a call of a function, e.g. "go work(x)"', call.start, call.end);
+            }
+            return { kind: 'GoExpression', call, start: token.start, end: call.end };
+        }
+        return this.parsePostfix(this.parsePrimary());
+    }
+    /** `make([]float64` starts a `make`: an array literal is not followed by a name. */
+    isMake() {
+        return (this.checkWord('make') &&
+            this.peek(1).kind === '(' &&
+            this.peek(2).kind === '[' &&
+            this.peek(3).kind === ']' &&
+            this.peek(4).kind === 'Identifier');
+    }
+    /** Member access, indexing and calls: `a.b`, `a?.b`, `a[i]`, `a?.[i]`, `f(x)`, `f?.(x)`. */
+    parsePostfix(expression) {
+        while (true) {
+            const start = expression.start;
+            if (this.accept('.')) {
+                const property = this.parsePropertyName();
+                expression = {
+                    kind: 'MemberExpression',
+                    object: expression,
+                    property,
+                    optional: false,
+                    ...this.span(start),
+                };
+            }
+            else if (this.accept('?.')) {
+                if (this.check('(')) {
+                    const args = this.parseArguments();
+                    expression = {
+                        kind: 'CallExpression',
+                        callee: expression,
+                        arguments: args,
+                        optional: true,
+                        ...this.span(start),
+                    };
+                }
+                else if (this.accept('[')) {
+                    const index = this.nested(() => this.parseExpression());
+                    this.expect(']');
+                    expression = {
+                        kind: 'IndexExpression',
+                        object: expression,
+                        index,
+                        optional: true,
+                        ...this.span(start),
+                    };
+                }
+                else {
+                    const property = this.parsePropertyName();
+                    expression = {
+                        kind: 'MemberExpression',
+                        object: expression,
+                        property,
+                        optional: true,
+                        ...this.span(start),
+                    };
+                }
+            }
+            else if (this.check('(')) {
+                const args = this.parseArguments();
+                expression = {
+                    kind: 'CallExpression',
+                    callee: expression,
+                    arguments: args,
+                    optional: false,
+                    ...this.span(start),
+                };
+            }
+            else if (this.accept('[')) {
+                const index = this.nested(() => this.parseExpression());
+                this.expect(']');
+                expression = {
+                    kind: 'IndexExpression',
+                    object: expression,
+                    index,
+                    optional: false,
+                    ...this.span(start),
+                };
+            }
+            else {
+                return expression;
+            }
+        }
+    }
+    parsePrimary() {
+        const token = this.peek();
+        const { start, end } = token;
+        switch (token.kind) {
+            case 'Identifier':
+                if (this.peek(1).kind === '=>')
+                    return this.parseArrowFunction();
+                if (this.isDecoratorGet())
+                    return this.parseDecoratorGet();
+                if (this.isMake())
+                    return this.parseMake();
+                this.next();
+                return { kind: 'Identifier', name: token.text, start, end };
+            case 'Number':
+                this.next();
+                return { kind: 'NumberLiteral', value: token.value, raw: token.text, start, end };
+            case 'BigInt':
+                this.next();
+                return { kind: 'BigIntLiteral', raw: token.text, start, end };
+            case 'String':
+                return this.parseStringLiteral();
+            case 'Template':
+            case 'TemplateHead':
+                return this.parseTemplate(token);
+            case 'true':
+            case 'false':
+                this.next();
+                return { kind: 'BooleanLiteral', value: token.kind === 'true', start, end };
+            case 'null':
+                this.next();
+                return { kind: 'NullLiteral', start, end };
+            case 'this':
+                this.next();
+                return { kind: 'ThisExpression', start, end };
+            case 'super':
+                this.next();
+                if (!this.check('(') && !this.check('.'))
+                    this.fail('"super" must be followed by "(" or "."');
+                return { kind: 'SuperExpression', start, end };
+            case '(':
+                return this.isArrowFunctionAhead() ? this.parseArrowFunction() : this.parseParenthesized();
+            // `[]byte("text")`: no array literal is followed by a name.
+            case '[':
+                return this.peek(1).kind === ']' && this.peek(2).kind === 'Identifier'
+                    ? this.parseConversion()
+                    : this.parseArrayLiteral();
+            case '{':
+                if (this.context.noObjectLiteral) {
+                    this.fail('expected expression, found "{" (wrap object literals in parentheses here)');
+                }
+                return this.parseObjectLiteral();
+            case 'func':
+                return this.parseFuncExpression();
+            // `chan<number>(10)`: a new channel.
+            case 'chan': {
+                this.next();
+                this.expect('<', '"<": a channel is made as chan<T>(size), e.g. chan<number>(10)');
+                const element = this.parseType();
+                this.expectTypeClose('">" after the type of the values');
+                this.expect('(');
+                const size = this.check(')') ? null : this.nested(() => this.parseExpression());
+                this.expect(')');
+                return { kind: 'ChanExpression', element, size, ...this.span(start) };
+            }
+            case 'async': {
+                this.next();
+                const fn = this.check('func')
+                    ? this.parseFuncExpression(true)
+                    : (this.check('Identifier') && this.peek(1).kind === '=>') ||
+                        (this.check('(') && this.isArrowFunctionAhead())
+                        ? this.parseArrowFunction(true)
+                        : this.fail('expected a function after "async": "async func(...) { ... }" or "async x => ..."');
+                fn.start = start;
+                return fn;
+            }
+            case 'new':
+                return this.parseNew();
+            case 'JsxTagOpen':
+                return this.parseJsxElement();
+            case '@':
+                return this.parseDecoratorMember();
+            default:
+                if (RESERVED.has(token.kind))
+                    this.fail(`"${token.text}" is reserved for future use`);
+                return this.fail(`expected expression, found ${describe(token)}`);
+        }
+    }
+}

package/dist/parser/literals.d.ts

@@ -0,0 +1,27 @@
+import type * as ast from '../ast.ts';
+import { type StringToken, type TokenKind } from '../lexer/token.ts';
+import { ExpressionParser } from './expressions.ts';
+export declare abstract class LiteralParser extends ExpressionParser {
+    /** Whether the `(` at the current position opens arrow function parameters: `(...) =>`. */
+    protected isArrowFunctionAhead(): boolean;
+    protected parseArrowFunction(async?: boolean): ast.ArrowFunction;
+    protected parseParenthesized(): ast.Expression;
+    protected parseFuncExpression(async?: boolean): ast.FuncExpression;
+    protected parseNew(): ast.NewExpression;
+    protected parseArguments(): (ast.Expression | ast.SpreadElement)[];
+    /** An expression or `...spread` in array literals and call arguments. */
+    protected parseElement(): ast.Expression | ast.SpreadElement;
+    protected parseArrayLiteral(): ast.ArrayLiteral;
+    /** `make([]float64, n)` or `make([]float64, n, shared)`. */
+    protected parseMake(): ast.MakeExpression;
+    /** `[]byte("text")`: a type, then its value in parentheses. */
+    protected parseConversion(): ast.ConversionExpression;
+    protected parseObjectLiteral(): ast.ObjectLiteral;
+    protected parseProperty(): ast.Property | ast.SpreadElement;
+    protected parseTemplate(first: StringToken): ast.TemplateLiteral;
+    /** Parses `item, item, ...` up to `close`, which is consumed. A trailing comma is allowed. */
+    protected parseList<T>(close: TokenKind, parseItem: () => T): T[];
+    protected parseIdentifier(what?: string): ast.Identifier;
+    /** Names after `.`, object keys and member names, where keywords are allowed too. */
+    protected parsePropertyName(what?: string): ast.Identifier;
+}

package/dist/parser/literals.js

@@ -0,0 +1,206 @@
+import { isKeyword } from "../lexer/token.js";
+import { ExpressionParser } from "./expressions.js";
+import { FUNCTION_BODY, describe, templateElement } from "./syntax.js";
+// Functions, `new`, literals of arrays, objects and templates, names.
+export class LiteralParser extends ExpressionParser {
+    /** Whether the `(` at the current position opens arrow function parameters: `(...) =>`. */
+    isArrowFunctionAhead() {
+        let depth = 0;
+        for (let i = this.pos; i < this.tokens.length; i++) {
+            const kind = this.tokens[i].kind;
+            if (kind === '(' || kind === '[' || kind === '{') {
+                depth++;
+            }
+            else if (kind === ')' || kind === ']' || kind === '}') {
+                depth--;
+                if (depth === 0)
+                    return this.tokens[i + 1]?.kind === '=>';
+            }
+            else if (kind === 'EOF') {
+                return false;
+            }
+        }
+        return false;
+    }
+    parseArrowFunction(async = false) {
+        const start = this.peek().start;
+        let params;
+        if (this.check('Identifier')) {
+            const name = this.parseIdentifier();
+            params = [
+                {
+                    kind: 'Parameter',
+                    name,
+                    type: null,
+                    defaultValue: null,
+                    start: name.start,
+                    end: name.end,
+                },
+            ];
+        }
+        else {
+            params = this.parseParams(true);
+        }
+        this.expect('=>');
+        const body = this.withContext({ ...FUNCTION_BODY, inAsync: async }, () => this.check('{') ? this.parseBlock() : this.parseExpression());
+        return {
+            kind: 'ArrowFunction',
+            ...(async ? { async } : {}),
+            params,
+            body,
+            ...this.span(start),
+        };
+    }
+    parseParenthesized() {
+        this.expect('(');
+        const expression = this.nested(() => this.parseExpression());
+        this.expect(')');
+        this.parenthesized.add(expression);
+        return expression;
+    }
+    parseFuncExpression(async = false) {
+        const start = this.expect('func').start;
+        const params = this.parseParams(false);
+        const results = this.parseResults();
+        const body = this.parseFunctionBody(async);
+        return {
+            kind: 'FuncExpression',
+            ...(async ? { async } : {}),
+            params,
+            results,
+            body,
+            ...this.span(start),
+        };
+    }
+    parseNew() {
+        const start = this.expect('new').start;
+        // The class is a name or a member chain (`new ns.User()`); the parentheses are the arguments.
+        let callee = this.parsePrimary();
+        while (this.accept('.')) {
+            const property = this.parsePropertyName();
+            callee = {
+                kind: 'MemberExpression',
+                object: callee,
+                property,
+                optional: false,
+                ...this.span(callee.start),
+            };
+        }
+        const args = this.check('(') ? this.parseArguments() : [];
+        return { kind: 'NewExpression', callee, arguments: args, ...this.span(start) };
+    }
+    parseArguments() {
+        this.expect('(');
+        return this.nested(() => this.parseList(')', () => this.parseElement()));
+    }
+    /** An expression or `...spread` in array literals and call arguments. */
+    parseElement() {
+        if (!this.check('...'))
+            return this.parseExpression();
+        const start = this.next().start;
+        const argument = this.parseExpression();
+        return { kind: 'SpreadElement', argument, ...this.span(start) };
+    }
+    parseArrayLiteral() {
+        const start = this.expect('[').start;
+        const elements = this.nested(() => this.parseList(']', () => this.parseElement()));
+        return { kind: 'ArrayLiteral', elements, ...this.span(start) };
+    }
+    /** `make([]float64, n)` or `make([]float64, n, shared)`. */
+    parseMake() {
+        const start = this.next().start;
+        this.expect('(');
+        const [type, length, shared] = this.nested(() => {
+            const type = this.parseType();
+            this.expect(',', '"," and the length: e.g. make([]float64, 100)');
+            const length = this.parseExpression();
+            let shared = false;
+            if (this.accept(',') && !this.check(')')) {
+                if (!this.checkWord('shared')) {
+                    this.fail('the third argument of make is the word shared: make([]float64, n, shared)');
+                }
+                this.next();
+                shared = true;
+                this.accept(',');
+            }
+            return [type, length, shared];
+        });
+        this.expect(')');
+        return { kind: 'MakeExpression', type, length, shared, ...this.span(start) };
+    }
+    /** `[]byte("text")`: a type, then its value in parentheses. */
+    parseConversion() {
+        const { start } = this.peek();
+        const type = this.parseType();
+        this.expect('(', '"(" after the type: e.g. []byte("text") gives the bytes of a string');
+        const argument = this.nested(() => this.parseExpression());
+        this.expect(')');
+        return { kind: 'ConversionExpression', type, argument, ...this.span(start) };
+    }
+    parseObjectLiteral() {
+        const start = this.expect('{').start;
+        const properties = this.nested(() => this.parseList('}', () => this.parseProperty()));
+        return { kind: 'ObjectLiteral', properties, ...this.span(start) };
+    }
+    parseProperty() {
+        const token = this.peek();
+        if (token.kind === '...')
+            return this.parseElement();
+        const key = token.kind === 'String' ? this.parseStringLiteral() : this.parsePropertyName();
+        if (this.accept(':')) {
+            const value = this.parseExpression();
+            return { kind: 'Property', key, value, shorthand: false, ...this.span(token.start) };
+        }
+        // Shorthand `{ name }` means `{ name: name }`, so the key must be a plain name.
+        if (key.kind !== 'Identifier' || token.kind !== 'Identifier') {
+            this.fail(`expected ":" after property name, found ${describe(this.peek())}`);
+        }
+        return { kind: 'Property', key, value: { ...key }, shorthand: true, ...this.span(token.start) };
+    }
+    parseTemplate(first) {
+        this.next();
+        const quasis = [templateElement(first)];
+        const expressions = [];
+        if (first.kind === 'TemplateHead') {
+            while (true) {
+                expressions.push(this.nested(() => this.parseExpression()));
+                const part = this.peek();
+                if (part.kind !== 'TemplateMiddle' && part.kind !== 'TemplateTail') {
+                    this.fail(`expected "}" to close the template substitution, found ${describe(part)}`);
+                }
+                this.next();
+                quasis.push(templateElement(part));
+                if (part.kind === 'TemplateTail')
+                    break;
+            }
+        }
+        return { kind: 'TemplateLiteral', quasis, expressions, ...this.span(first.start) };
+    }
+    /** Parses `item, item, ...` up to `close`, which is consumed. A trailing comma is allowed. */
+    parseList(close, parseItem) {
+        const items = [];
+        while (!this.check(close)) {
+            items.push(parseItem());
+            if (!this.accept(','))
+                break;
+        }
+        this.expect(close);
+        return items;
+    }
+    parseIdentifier(what = 'name') {
+        const token = this.peek();
+        if (token.kind !== 'Identifier')
+            this.fail(`expected ${what}, found ${describe(token)}`);
+        this.next();
+        return { kind: 'Identifier', name: token.text, start: token.start, end: token.end };
+    }
+    /** Names after `.`, object keys and member names, where keywords are allowed too. */
+    parsePropertyName(what = 'property name') {
+        const token = this.peek();
+        if (token.kind !== 'Identifier' && !isKeyword(token.kind)) {
+            this.fail(`expected ${what}, found ${describe(token)}`);
+        }
+        this.next();
+        return { kind: 'Identifier', name: token.text, start: token.start, end: token.end };
+    }
+}

package/dist/parser/markup.d.ts

@@ -0,0 +1,22 @@
+import type * as ast from '../ast.ts';
+import { LiteralParser } from './literals.ts';
+export declare abstract class MarkupParser extends LiteralParser {
+    /** `<tag attributes>children</tag>`, `<tag ... />` or a fragment `<>children</>`. */
+    protected parseJsxElement(): ast.ElementExpression;
+    private parseMarkup;
+    /** `<section.content />`: a tag with a dot is the value `section.content`. */
+    private tagValue;
+    protected parseJsxName(what: string): ast.Identifier;
+    protected parseJsxAttribute(): ast.JsxAttribute | ast.JsxSpreadAttribute;
+    /**
+     * The value of an `on*` attribute: a function is the handler itself; anything else is a list of
+     * statements to run on the event, e.g. `{count++}` or `{event.preventDefault(); send()}`.
+     */
+    protected parseEventHandler(): ast.Expression | ast.EventHandler;
+    /**
+     * `{expression}` or `{if ...}` / `{for ...}` / `{switch ...}` among element children; `null` for
+     * `{}` or `{/* comment *\/}`.
+     */
+    protected parseJsxExpressionContainer(): ast.JsxExpressionContainer | ast.JsxStatementContainer | null;
+    protected parseStringLiteral(what?: string): ast.StringLiteral;
+}