lemmascript 0.1.0 → 0.3.0

package/tools/dist/specparser.js

@@ -2,7 +2,7 @@
  * Spec expression parser.
  * Parses //@ annotation expressions into RawExpr AST nodes.
  */
-const MULTI_OPS = ["==>", "===", "!==", ">=", "<=", "&&", "||"];
+const MULTI_OPS = ["==>", "===", "!==", "==", "!=", ">=", "<=", "&&", "||"];
 function tokenize(input) {
     const tokens = [];
     let i = 0;
@@ -28,10 +28,23 @@ function tokenize(input) {
             continue;
         }
         if (/[0-9]/.test(input[i])) {
-            let n = "";
-            while (i < input.length && /[0-9]/.test(input[i]))
-                n += input[i++];
-            tokens.push({ type: "num", value: parseInt(n) });
+            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])) {
@@ -116,9 +129,16 @@ class Parser {
     parseCmp() {
         const left = this.parseAdd();
         const t = this.peek();
-        if (t?.type === "op" && ["===", "!==", ">=", "<=", ">", "<"].includes(t.value)) {
+        // 'in' as infix membership operator (set/seq/map): x in S
+        if (t?.type === "ident" && t.value === "in") {
+            this.advance();
+            return { kind: "binop", op: "in", left, right: this.parseAdd() };
+        }
+        if (t?.type === "op" && ["===", "!==", "==", "!=", ">=", "<=", ">", "<"].includes(t.value)) {
             this.advance();
-            return { kind: "binop", op: t.value, left, right: this.parseAdd() };
+            // 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;
     }
@@ -201,6 +221,34 @@ class Parser {
                 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();
@@ -209,8 +257,6 @@ class Parser {
                 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", ",");
@@ -227,6 +273,17 @@ class Parser {
             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 = [];