septima-lang 0.0.7 → 0.0.8

package/dist/src/parser.js

@@ -0,0 +1,483 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Parser = void 0;
+const ast_node_1 = require("./ast-node");
+const switch_on_1 = require("./switch-on");
+class Parser {
+    constructor(scanner) {
+        this.scanner = scanner;
+    }
+    parse() {
+        const ret = this.unit();
+        if (!this.scanner.eof()) {
+            throw new Error(`Loitering input ${this.scanner.sourceRef}`);
+        }
+        return ret;
+    }
+    unit() {
+        const imports = this.imports();
+        const expression = this.expression('TOP_LEVEL');
+        return { tag: 'unit', imports, expression };
+    }
+    imports() {
+        const ret = [];
+        while (true) {
+            const start = this.scanner.consumeIf('import');
+            if (!start) {
+                return ret;
+            }
+            this.scanner.consume('*');
+            this.scanner.consume('as');
+            const ident = this.identifier();
+            this.scanner.consume('from');
+            const pathToImportFrom = this.maybePrimitiveLiteral();
+            if (pathToImportFrom === undefined) {
+                throw new Error(`Expected a literal ${this.scanner.sourceRef}`);
+            }
+            const notString = () => {
+                throw new Error(`Expected a string literal ${this.scanner.sourceCode.sourceRef((0, ast_node_1.span)(pathToImportFrom))}`);
+            };
+            (0, switch_on_1.switchOn)(pathToImportFrom.type, {
+                bool: notString,
+                num: notString,
+                str: () => { },
+                sink: notString,
+                'sink!': notString,
+                'sink!!': notString,
+            });
+            ret.push({ start, ident, pathToImportFrom: pathToImportFrom.t });
+            this.scanner.consumeIf(';');
+        }
+    }
+    definitions(kind) {
+        const ret = [];
+        while (true) {
+            if (kind === 'NESTED') {
+                if (this.scanner.headMatches('export ')) {
+                    throw new Error(`non-top-level definition cannot be export ${this.scanner.sourceRef}`);
+                }
+            }
+            let start = this.scanner.consumeIf('let ');
+            if (!start && kind === 'TOP_LEVEL') {
+                start = this.scanner.consumeIf('export let ');
+            }
+            if (!start) {
+                return ret;
+            }
+            const ident = this.identifier();
+            this.scanner.consume('=');
+            const value = this.lambda();
+            ret.push({ start, ident, value });
+            this.scanner.consumeIf(';');
+            if (!this.scanner.headMatches('let ')) {
+                return ret;
+            }
+        }
+    }
+    expression(kind = 'NESTED') {
+        const definitions = this.definitions(kind);
+        if (kind === 'TOP_LEVEL' && this.scanner.eof()) {
+            return { tag: 'topLevelExpression', definitions };
+        }
+        this.scanner.consumeIf('return');
+        const computation = this.lambda();
+        if (definitions.length === 0) {
+            return computation;
+        }
+        return { tag: 'topLevelExpression', definitions, computation };
+    }
+    lambda() {
+        const start = this.scanner.consumeIf('fun');
+        if (!start) {
+            return this.arrowFunction();
+        }
+        this.scanner.consume('(');
+        const args = [];
+        if (this.scanner.consumeIf(')')) {
+            // no formal args
+        }
+        else {
+            while (true) {
+                const arg = this.identifier();
+                args.push(arg);
+                if (this.scanner.consumeIf(')')) {
+                    break;
+                }
+                this.scanner.consume(',');
+            }
+        }
+        const body = this.expression();
+        return { tag: 'lambda', start, formalArgs: args, body };
+    }
+    arrowFunction() {
+        if (this.scanner.headMatches('(', ')', '=>')) {
+            const start = this.scanner.consume('(');
+            this.scanner.consume(')');
+            this.scanner.consume('=>');
+            const body = this.lambdaBody();
+            return { tag: 'lambda', start, formalArgs: [], body };
+        }
+        if (this.scanner.headMatches(IDENT_PATTERN, '=>')) {
+            const ident = this.identifier();
+            this.scanner.consume('=>');
+            const body = this.lambdaBody();
+            return { tag: 'lambda', start: ident.t, formalArgs: [ident], body };
+        }
+        if (this.scanner.headMatches('(', IDENT_PATTERN, ')', '=>')) {
+            const start = this.scanner.consume('(');
+            const ident = this.identifier();
+            this.scanner.consume(')');
+            this.scanner.consume('=>');
+            const body = this.lambdaBody();
+            return { tag: 'lambda', start, formalArgs: [ident], body };
+        }
+        if (this.scanner.headMatches('(', IDENT_PATTERN, ',')) {
+            const start = this.scanner.consume('(');
+            const formalArgs = [];
+            while (true) {
+                const ident = this.identifier();
+                formalArgs.push(ident);
+                if (this.scanner.consumeIf(')')) {
+                    break;
+                }
+                this.scanner.consume(',');
+            }
+            this.scanner.consume('=>');
+            const body = this.lambdaBody();
+            return { tag: 'lambda', start, formalArgs, body };
+        }
+        return this.ifExpression();
+    }
+    lambdaBody() {
+        if (this.scanner.consumeIf('{')) {
+            const ret = this.expression();
+            this.scanner.consume('}');
+            return ret;
+        }
+        return this.expression();
+    }
+    ifExpression() {
+        if (!this.scanner.consumeIf('if')) {
+            return this.ternary();
+        }
+        this.scanner.consume('(');
+        const condition = this.expression();
+        this.scanner.consume(')');
+        const positive = this.expression();
+        this.scanner.consume('else');
+        const negative = this.expression();
+        return { tag: 'if', condition, positive, negative };
+    }
+    ternary() {
+        const condition = this.unsink();
+        if (!this.scanner.consumeIf('? ')) {
+            return condition;
+        }
+        const positive = this.expression();
+        this.scanner.consume(':');
+        const negative = this.expression();
+        return { tag: 'ternary', condition, positive, negative };
+    }
+    unsink() {
+        const lhs = this.or();
+        if (this.scanner.consumeIf('??')) {
+            return { tag: 'binaryOperator', operator: '??', lhs, rhs: this.unsink() };
+        }
+        return lhs;
+    }
+    or() {
+        const lhs = this.and();
+        if (this.scanner.consumeIf('||')) {
+            return { tag: 'binaryOperator', operator: '||', lhs, rhs: this.or() };
+        }
+        return lhs;
+    }
+    and() {
+        const lhs = this.equality();
+        if (this.scanner.consumeIf('&&')) {
+            return { tag: 'binaryOperator', operator: '&&', lhs, rhs: this.and() };
+        }
+        return lhs;
+    }
+    equality() {
+        const lhs = this.comparison();
+        if (this.scanner.consumeIf('==')) {
+            return { tag: 'binaryOperator', operator: '==', lhs, rhs: this.equality() };
+        }
+        if (this.scanner.consumeIf('!=')) {
+            return { tag: 'binaryOperator', operator: '!=', lhs, rhs: this.equality() };
+        }
+        return lhs;
+    }
+    comparison() {
+        const lhs = this.addition();
+        if (this.scanner.consumeIf('>=')) {
+            return { tag: 'binaryOperator', operator: '>=', lhs, rhs: this.comparison() };
+        }
+        if (this.scanner.consumeIf('<=')) {
+            return { tag: 'binaryOperator', operator: '<=', lhs, rhs: this.comparison() };
+        }
+        if (this.scanner.consumeIf('>')) {
+            return { tag: 'binaryOperator', operator: '>', lhs, rhs: this.comparison() };
+        }
+        if (this.scanner.consumeIf('<')) {
+            return { tag: 'binaryOperator', operator: '<', lhs, rhs: this.comparison() };
+        }
+        return lhs;
+    }
+    addition() {
+        const lhs = this.multiplication();
+        if (this.scanner.consumeIf('+')) {
+            return { tag: 'binaryOperator', operator: '+', lhs, rhs: this.addition() };
+        }
+        if (this.scanner.consumeIf('-')) {
+            return { tag: 'binaryOperator', operator: '-', lhs, rhs: this.addition() };
+        }
+        return lhs;
+    }
+    multiplication() {
+        const lhs = this.power();
+        if (this.scanner.consumeIf('*')) {
+            return { tag: 'binaryOperator', operator: '*', lhs, rhs: this.multiplication() };
+        }
+        if (this.scanner.consumeIf('/')) {
+            return { tag: 'binaryOperator', operator: '/', lhs, rhs: this.multiplication() };
+        }
+        if (this.scanner.consumeIf('%')) {
+            return { tag: 'binaryOperator', operator: '%', lhs, rhs: this.multiplication() };
+        }
+        return lhs;
+    }
+    power() {
+        const lhs = this.unary();
+        if (this.scanner.consumeIf('**')) {
+            return { tag: 'binaryOperator', operator: '**', lhs, rhs: this.power() };
+        }
+        return lhs;
+    }
+    unary() {
+        let operatorToken = this.scanner.consumeIf('!');
+        if (operatorToken) {
+            return { tag: 'unaryOperator', operand: this.unary(), operator: '!', operatorToken };
+        }
+        operatorToken = this.scanner.consumeIf('+');
+        if (operatorToken) {
+            return { tag: 'unaryOperator', operand: this.unary(), operator: '+', operatorToken };
+        }
+        operatorToken = this.scanner.consumeIf('-');
+        if (operatorToken) {
+            return { tag: 'unaryOperator', operand: this.unary(), operator: '-', operatorToken };
+        }
+        return this.call();
+    }
+    call() {
+        const callee = this.memberAccess();
+        if (!this.scanner.consumeIf('(')) {
+            return callee;
+        }
+        const { actualArgs, end } = this.actualArgList();
+        return { tag: 'functionCall', actualArgs, callee, end };
+    }
+    actualArgList() {
+        const actualArgs = [];
+        const endEmpty = this.scanner.consumeIf(')');
+        if (endEmpty) {
+            // no actual args
+            return { actualArgs, end: endEmpty };
+        }
+        while (true) {
+            const arg = this.expression();
+            actualArgs.push(arg);
+            let end = this.scanner.consumeIf(')');
+            if (end) {
+                return { actualArgs, end };
+            }
+            this.scanner.consume(',');
+            end = this.scanner.consumeIf(')');
+            if (end) {
+                return { actualArgs, end };
+            }
+        }
+    }
+    memberAccess() {
+        let ret = this.parenthesized();
+        while (true) {
+            if (this.scanner.consumeIf('.')) {
+                ret = { tag: 'dot', receiver: ret, ident: this.identifier() };
+                continue;
+            }
+            if (this.scanner.consumeIf('[')) {
+                ret = { tag: 'indexAccess', receiver: ret, index: this.expression() };
+                this.scanner.consume(']');
+                continue;
+            }
+            if (this.scanner.consumeIf('(')) {
+                const { actualArgs, end } = this.actualArgList();
+                ret = { tag: 'functionCall', actualArgs, callee: ret, end };
+                continue;
+            }
+            return ret;
+        }
+    }
+    parenthesized() {
+        if (this.scanner.consumeIf('(')) {
+            const ret = this.expression();
+            this.scanner.consume(')');
+            return ret;
+        }
+        return this.literalOrIdent();
+    }
+    literalOrIdent() {
+        const ret = this.maybeLiteral() ?? this.maybeIdentifier();
+        if (!ret) {
+            throw new Error(`Unparsable input ${this.scanner.sourceRef}`);
+        }
+        return ret;
+    }
+    maybeLiteral() {
+        return this.maybePrimitiveLiteral() ?? this.maybeCompositeLiteral();
+    }
+    maybePrimitiveLiteral() {
+        let t = this.scanner.consumeIf('sink!!') || this.scanner.consumeIf('undefined!!');
+        if (t) {
+            return { tag: 'literal', type: 'sink!!', t };
+        }
+        t = this.scanner.consumeIf('sink!') || this.scanner.consumeIf('undefined!');
+        if (t) {
+            return { tag: 'literal', type: 'sink!', t };
+        }
+        t = this.scanner.consumeIf('sink') || this.scanner.consumeIf('undefined');
+        if (t) {
+            return { tag: 'literal', type: 'sink', t };
+        }
+        t = this.scanner.consumeIf('true');
+        if (t) {
+            return { tag: 'literal', type: 'bool', t };
+        }
+        t = this.scanner.consumeIf('false');
+        if (t) {
+            return { tag: 'literal', type: 'bool', t };
+        }
+        t = this.scanner.consumeIf(/([0-9]*[.])?[0-9]+/);
+        if (t) {
+            return { tag: 'literal', type: 'num', t };
+        }
+        // double-quotes-enclosd string
+        if (this.scanner.consumeIf(`"`, false)) {
+            t = this.scanner.consume(/[^"]*/);
+            this.scanner.consume(`"`);
+            return { tag: 'literal', type: 'str', t };
+        }
+        // single-quotes-enclosd string
+        if (this.scanner.consumeIf(`'`, false)) {
+            t = this.scanner.consume(/[^']*/);
+            this.scanner.consume(`'`);
+            return { tag: 'literal', type: 'str', t };
+        }
+        return undefined;
+    }
+    maybeCompositeLiteral() {
+        let t = this.scanner.consumeIf('[');
+        if (t) {
+            return this.arrayBody(t);
+        }
+        t = this.scanner.consumeIf('{');
+        if (t) {
+            return this.objectBody(t);
+        }
+        return undefined;
+    }
+    /**
+     * This method assumes that the caller consumed the opening '[' token. It consumes the array's elements
+     * (comma-separated list of expressions) as well as the closing ']' token.
+     */
+    arrayBody(start) {
+        const t = this.scanner.consumeIf(']');
+        if (t) {
+            // an empty array literal
+            return { tag: 'arrayLiteral', start, parts: [], end: t };
+        }
+        const parts = [];
+        while (true) {
+            if (this.scanner.consumeIf(',')) {
+                const end = this.scanner.consumeIf(']');
+                if (end) {
+                    return { tag: 'arrayLiteral', start, parts, end };
+                }
+                continue;
+            }
+            if (this.scanner.consumeIf('...')) {
+                parts.push({ tag: 'spread', v: this.expression() });
+            }
+            else {
+                const exp = this.expression();
+                parts.push({ tag: 'element', v: exp });
+            }
+            let end = this.scanner.consumeIf(']');
+            if (end) {
+                return { tag: 'arrayLiteral', start, parts, end };
+            }
+            this.scanner.consume(',');
+            end = this.scanner.consumeIf(']');
+            if (end) {
+                return { tag: 'arrayLiteral', start, parts, end };
+            }
+        }
+    }
+    /**
+     * This method assumes that the caller consumed the opening '{' token. It consumes the object's attributes
+     * (comma-separated list of key:value parirs) as well as the closing '}' token.
+     */
+    objectBody(start) {
+        const t = this.scanner.consumeIf('}');
+        if (t) {
+            // an empty array literal
+            return { tag: 'objectLiteral', start, parts: [], end: t };
+        }
+        const parts = [];
+        while (true) {
+            if (this.scanner.consumeIf('...')) {
+                parts.push({ tag: 'spread', o: this.expression() });
+            }
+            else if (this.scanner.consumeIf('[')) {
+                const k = this.expression();
+                this.scanner.consume(']');
+                this.scanner.consume(':');
+                const v = this.expression();
+                parts.push({ tag: 'computedName', k, v });
+            }
+            else {
+                const k = this.identifier();
+                this.scanner.consume(':');
+                const v = this.expression();
+                parts.push({ tag: 'hardName', k, v });
+            }
+            let end = this.scanner.consumeIf('}');
+            if (end) {
+                return { tag: 'objectLiteral', start, parts, end };
+            }
+            this.scanner.consume(',');
+            end = this.scanner.consumeIf('}');
+            if (end) {
+                return { tag: 'objectLiteral', start, parts, end };
+            }
+        }
+    }
+    identifier() {
+        const ret = this.maybeIdentifier();
+        if (!ret) {
+            throw new Error(`Expected an identifier ${this.scanner.sourceRef}`);
+        }
+        return ret;
+    }
+    maybeIdentifier() {
+        const t = this.scanner.consumeIf(IDENT_PATTERN);
+        if (t) {
+            return { tag: 'ident', t };
+        }
+        return undefined;
+    }
+}
+exports.Parser = Parser;
+const IDENT_PATTERN = /[a-zA-Z][0-9A-Za-z_]*/;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"parser.js","sourceRoot":"","sources":["../../src/parser.ts"],"names":[],"mappings":"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"}

package/dist/src/result.d.ts

@@ -0,0 +1,24 @@
+import { Span } from './location';
+import { SourceCode } from './source-code';
+import { Value } from './value';
+export declare type ResultSink = {
+    tag: 'sink';
+    where: Span | undefined;
+    trace: string | undefined;
+    symbols: Record<string, unknown> | undefined;
+    message: string;
+};
+export declare type Result = {
+    tag: 'ok';
+    value: unknown;
+} | ResultSink;
+export declare class ResultSinkImpl {
+    private readonly sink;
+    private readonly sourceCode;
+    readonly tag = "sink";
+    constructor(sink: Value, sourceCode: SourceCode);
+    get where(): Span | undefined;
+    get trace(): string | undefined;
+    get symbols(): Record<string, unknown> | undefined;
+    get message(): string;
+}

package/dist/src/result.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResultSinkImpl = void 0;
+class ResultSinkImpl {
+    constructor(sink, sourceCode) {
+        this.sink = sink;
+        this.sourceCode = sourceCode;
+        this.tag = 'sink';
+    }
+    get where() {
+        return this.sink.span();
+    }
+    get trace() {
+        const trace = this.sink.trace();
+        if (trace) {
+            return this.sourceCode.formatTrace(trace);
+        }
+        return undefined;
+    }
+    get symbols() {
+        return this.sink.symbols()?.export();
+    }
+    get message() {
+        const at = this.trace ?? this.sourceCode.sourceRef(this.where);
+        return `Evaluated to sink: ${at}`;
+    }
+}
+exports.ResultSinkImpl = ResultSinkImpl;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVzdWx0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3Jlc3VsdC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFtQkEsTUFBYSxjQUFjO0lBRXpCLFlBQTZCLElBQVcsRUFBbUIsVUFBc0I7UUFBcEQsU0FBSSxHQUFKLElBQUksQ0FBTztRQUFtQixlQUFVLEdBQVYsVUFBVSxDQUFZO1FBRHhFLFFBQUcsR0FBRyxNQUFNLENBQUE7SUFDK0QsQ0FBQztJQUVyRixJQUFJLEtBQUs7UUFDUCxPQUFPLElBQUksQ0FBQyxJQUFJLENBQUMsSUFBSSxFQUFFLENBQUE7SUFDekIsQ0FBQztJQUVELElBQUksS0FBSztRQUNQLE1BQU0sS0FBSyxHQUFHLElBQUksQ0FBQyxJQUFJLENBQUMsS0FBSyxFQUFFLENBQUE7UUFDL0IsSUFBSSxLQUFLLEVBQUU7WUFDVCxPQUFPLElBQUksQ0FBQyxVQUFVLENBQUMsV0FBVyxDQUFDLEtBQUssQ0FBQyxDQUFBO1NBQzFDO1FBRUQsT0FBTyxTQUFTLENBQUE7SUFDbEIsQ0FBQztJQUVELElBQUksT0FBTztRQUNULE9BQU8sSUFBSSxDQUFDLElBQUksQ0FBQyxPQUFPLEVBQUUsRUFBRSxNQUFNLEVBQUUsQ0FBQTtJQUN0QyxDQUFDO0lBRUQsSUFBSSxPQUFPO1FBQ1QsTUFBTSxFQUFFLEdBQUcsSUFBSSxDQUFDLEtBQUssSUFBSSxJQUFJLENBQUMsVUFBVSxDQUFDLFNBQVMsQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLENBQUE7UUFDOUQsT0FBTyxzQkFBc0IsRUFBRSxFQUFFLENBQUE7SUFDbkMsQ0FBQztDQUNGO0FBekJELHdDQXlCQyJ9

package/dist/src/runtime.d.ts

@@ -0,0 +1,28 @@
+import { AstNode, Unit } from './ast-node';
+import { Value } from './value';
+export declare type Verbosity = 'quiet' | 'trace';
+export declare class Runtime {
+    private readonly root;
+    private readonly verbosity;
+    private readonly preimports;
+    private readonly getAstOf;
+    private readonly args;
+    private stack;
+    constructor(root: AstNode, verbosity: Verbosity, preimports: Record<string, Value>, getAstOf: (fileName: string) => Unit, args: Record<string, unknown>);
+    private buildInitialSymbolTable;
+    compute(): {
+        value: Value;
+        expressionTrace?: undefined;
+        errorMessage?: undefined;
+        stack?: undefined;
+    } | {
+        expressionTrace: AstNode[];
+        errorMessage: unknown;
+        stack: string[] | undefined;
+        value?: undefined;
+    };
+    private evalNode;
+    private importDefinitions;
+    private evalNodeImpl;
+    call(callee: Value, argValues: Value[]): Value;
+}