lemmascript 0.0.1 → 0.2.0

package/tools/dist/specparser.js

@@ -0,0 +1,305 @@
+/**
+ * Spec expression parser.
+ * Parses //@ annotation expressions into RawExpr AST nodes.
+ */
+const MULTI_OPS = ["==>", "===", "!==", "==", "!=", ">=", "<=", "&&", "||"];
+function tokenize(input) {
+    const tokens = [];
+    let i = 0;
+    while (i < input.length) {
+        if (/\s/.test(input[i])) {
+            i++;
+            continue;
+        }
+        if (input[i] === "\\" && input.slice(i + 1, i + 7) === "result") {
+            tokens.push({ type: "result", value: undefined });
+            i += 7;
+            continue;
+        }
+        if (input[i] === '"' || input[i] === "'") {
+            const quote = input[i];
+            i++;
+            let s = "";
+            while (i < input.length && input[i] !== quote)
+                s += input[i++];
+            if (i < input.length)
+                i++;
+            tokens.push({ type: "str", value: s });
+            continue;
+        }
+        if (/[0-9]/.test(input[i])) {
+            let value;
+            if (input[i] === "0" && i + 1 < input.length && input[i + 1] === "x") {
+                i += 2;
+                let hex = "";
+                while (i < input.length && /[0-9a-fA-F]/.test(input[i]))
+                    hex += input[i++];
+                value = parseInt(hex, 16);
+            }
+            else {
+                let dec = "";
+                while (i < input.length && /[0-9]/.test(input[i]))
+                    dec += input[i++];
+                value = parseInt(dec, 10);
+            }
+            if (i < input.length && input[i] === "n")
+                i++;
+            tokens.push({ type: "num", value });
+            continue;
+        }
+        if (/[a-zA-Z_]/.test(input[i])) {
+            let id = "";
+            while (i < input.length && /[a-zA-Z_0-9]/.test(input[i]))
+                id += input[i++];
+            tokens.push({ type: "ident", value: id });
+            continue;
+        }
+        let matched = false;
+        for (const op of MULTI_OPS) {
+            if (input.slice(i, i + op.length) === op) {
+                tokens.push({ type: "op", value: op });
+                i += op.length;
+                matched = true;
+                break;
+            }
+        }
+        if (matched)
+            continue;
+        const ch = input[i];
+        if ("+-*/%><!".includes(ch)) {
+            tokens.push({ type: "op", value: ch });
+        }
+        else if ("()[],:.{}".includes(ch)) {
+            tokens.push({ type: "punc", value: ch });
+        }
+        else {
+            throw new Error(`Unexpected '${ch}' at ${i} in: ${input}`);
+        }
+        i++;
+    }
+    return tokens;
+}
+// ── Parser ───────────────────────────────────────────────────
+class Parser {
+    tokens;
+    pos = 0;
+    constructor(tokens) {
+        this.tokens = tokens;
+    }
+    peek() { return this.tokens[this.pos]; }
+    advance() { return this.tokens[this.pos++]; }
+    expect(type, value) {
+        const t = this.advance();
+        if (!t || t.type !== type || (value !== undefined && t.value !== value))
+            throw new Error(`Expected ${type}${value ? ` '${value}'` : ""}, got ${t ? JSON.stringify(t) : "EOF"}`);
+        return t;
+    }
+    match(type, value) {
+        const t = this.peek();
+        if (t && t.type === type && (value === undefined || t.value === value)) {
+            this.pos++;
+            return true;
+        }
+        return false;
+    }
+    parse() {
+        const r = this.parseImplies();
+        if (this.pos < this.tokens.length)
+            throw new Error(`Unexpected: ${JSON.stringify(this.peek())}`);
+        return r;
+    }
+    parseImplies() {
+        const left = this.parseOr();
+        if (this.match("op", "==>"))
+            return { kind: "binop", op: "==>", left, right: this.parseImplies() };
+        return left;
+    }
+    parseOr() {
+        let left = this.parseAnd();
+        while (this.match("op", "||"))
+            left = { kind: "binop", op: "||", left, right: this.parseAnd() };
+        return left;
+    }
+    parseAnd() {
+        let left = this.parseCmp();
+        while (this.match("op", "&&"))
+            left = { kind: "binop", op: "&&", left, right: this.parseCmp() };
+        return left;
+    }
+    parseCmp() {
+        const left = this.parseAdd();
+        const t = this.peek();
+        if (t?.type === "op" && ["===", "!==", "==", "!=", ">=", "<=", ">", "<"].includes(t.value)) {
+            this.advance();
+            // Normalize == to ===, != to !== so downstream sees one spelling
+            const op = t.value === "==" ? "===" : t.value === "!=" ? "!==" : t.value;
+            return { kind: "binop", op, left, right: this.parseAdd() };
+        }
+        return left;
+    }
+    parseAdd() {
+        let left = this.parseMul();
+        while (this.peek()?.type === "op" && ["+", "-"].includes(this.peek().value)) {
+            const op = this.advance().value;
+            left = { kind: "binop", op, left, right: this.parseMul() };
+        }
+        return left;
+    }
+    parseMul() {
+        let left = this.parseUnary();
+        while (this.peek()?.type === "op" && ["*", "/", "%"].includes(this.peek().value)) {
+            const op = this.advance().value;
+            left = { kind: "binop", op, left, right: this.parseUnary() };
+        }
+        return left;
+    }
+    parseUnary() {
+        if (this.match("op", "!"))
+            return { kind: "unop", op: "!", expr: this.parseUnary() };
+        if (this.peek()?.type === "op" && this.peek().value === "-") {
+            const prev = this.pos > 0 ? this.tokens[this.pos - 1] : undefined;
+            if (!prev || prev.type === "op" || (prev.type === "punc" && prev.value !== ")")) {
+                this.advance();
+                return { kind: "unop", op: "-", expr: this.parseUnary() };
+            }
+        }
+        return this.parsePostfix();
+    }
+    parsePostfix() {
+        let expr = this.parseAtom();
+        while (true) {
+            if (this.match("punc", ".")) {
+                expr = { kind: "field", obj: expr, field: this.expect("ident").value };
+            }
+            else if (this.match("punc", "[")) {
+                const idx = this.parseImplies();
+                this.expect("punc", "]");
+                expr = { kind: "index", obj: expr, idx };
+            }
+            else if (this.match("punc", "(")) {
+                const args = [];
+                if (!this.match("punc", ")")) {
+                    args.push(this.parseImplies());
+                    while (this.match("punc", ","))
+                        args.push(this.parseImplies());
+                    this.expect("punc", ")");
+                }
+                expr = { kind: "call", fn: expr, args };
+            }
+            else
+                break;
+        }
+        return expr;
+    }
+    parseAtom() {
+        const t = this.peek();
+        if (!t)
+            throw new Error("Unexpected end of expression");
+        if (t.type === "result") {
+            this.advance();
+            return { kind: "result" };
+        }
+        if (t.type === "num") {
+            this.advance();
+            return { kind: "num", value: t.value };
+        }
+        if (t.type === "str") {
+            this.advance();
+            return { kind: "str", value: t.value };
+        }
+        if (t.type === "ident") {
+            if (t.value === "true") {
+                this.advance();
+                return { kind: "bool", value: true };
+            }
+            if (t.value === "false") {
+                this.advance();
+                return { kind: "bool", value: false };
+            }
+            // new Set<T>() / new Map<K,V>()
+            if (t.value === "new") {
+                this.advance();
+                const name = this.expect("ident").value;
+                if (name !== "Set" && name !== "Map")
+                    throw new Error(`Unsupported constructor: new ${name}`);
+                // Skip <T> or <K,V> type arguments
+                let tsType = name;
+                if (this.match("op", "<")) {
+                    let depth = 1;
+                    let typeArgs = "";
+                    while (depth > 0) {
+                        const next = this.advance();
+                        if (next.value === "<")
+                            depth++;
+                        else if (next.value === ">") {
+                            depth--;
+                            if (depth === 0)
+                                break;
+                        }
+                        typeArgs += next.value;
+                    }
+                    tsType = `${name}<${typeArgs}>`;
+                }
+                this.expect("punc", "(");
+                this.expect("punc", ")");
+                return { kind: "emptyCollection", collectionType: name, tsType };
+            }
+            if (t.value === "forall" || t.value === "exists") {
+                const q = t.value;
+                this.advance();
+                this.expect("punc", "(");
+                const v = this.expect("ident").value;
+                let varType = "int";
+                if (this.match("punc", ":")) {
+                    const ty = this.expect("ident").value;
+                    if (ty !== "nat" && ty !== "int")
+                        throw new Error(`Unknown type '${ty}'`);
+                    varType = ty;
+                }
+                this.expect("punc", ",");
+                const body = this.parseImplies();
+                this.expect("punc", ")");
+                return { kind: q, var: v, varType, body };
+            }
+            this.advance();
+            return { kind: "var", name: t.value };
+        }
+        if (t.type === "punc" && t.value === "(") {
+            this.advance();
+            const expr = this.parseImplies();
+            this.expect("punc", ")");
+            return expr;
+        }
+        if (t.type === "punc" && t.value === "[") {
+            this.advance();
+            const elems = [];
+            if (!this.match("punc", "]")) {
+                elems.push(this.parseImplies());
+                while (this.match("punc", ","))
+                    elems.push(this.parseImplies());
+                this.expect("punc", "]");
+            }
+            return { kind: "arrayLiteral", elems };
+        }
+        if (t.type === "punc" && t.value === "{") {
+            this.advance();
+            const fields = [];
+            if (!this.match("punc", "}")) {
+                const name = this.expect("ident").value;
+                this.expect("punc", ":");
+                fields.push({ name, value: this.parseImplies() });
+                while (this.match("punc", ",")) {
+                    const n = this.expect("ident").value;
+                    this.expect("punc", ":");
+                    fields.push({ name: n, value: this.parseImplies() });
+                }
+                this.expect("punc", "}");
+            }
+            return { kind: "record", spread: null, fields };
+        }
+        throw new Error(`Unexpected: ${JSON.stringify(t)}`);
+    }
+}
+export function parseExpr(input) {
+    return new Parser(tokenize(input)).parse();
+}