lemmascript 0.1.0 → 0.2.0

package/tools/dist/resolve.js

@@ -33,12 +33,96 @@ function coerceStr(expr, targetTy) {
     return expr;
 }
 // ── Helpers ──────────────────────────────────────────────────
+/** Detect `v !== undefined` or `undefined !== v` where v: optional<T>. */
+function narrowOptional(cond, env) {
+    if (cond.kind !== "binop" || (cond.op !== "!==" && cond.op !== "==="))
+        return null;
+    // v !== undefined  OR  undefined !== v
+    let varName = null;
+    if (cond.left.kind === "var" && cond.right.kind === "var" && cond.right.name === "undefined")
+        varName = cond.left.name;
+    if (cond.right.kind === "var" && cond.left.kind === "var" && cond.left.name === "undefined")
+        varName = cond.right.name;
+    if (!varName)
+        return null;
+    const ty = lookup(env, varName);
+    if (!ty || ty.kind !== "optional")
+        return null;
+    return { varName, innerTy: ty.inner, inThen: cond.op === "!==" };
+}
+/** TS reference types that become value types in Dafny/Lean — const bindings need mutable var. */
+function isRefMutableInTS(ty) {
+    return ty.kind === "array" || ty.kind === "map" || ty.kind === "set";
+}
 function findDecl(ctx, name) {
     return ctx.typeDecls.find(d => d.name === name);
 }
 function getDiscriminant(ctx, typeName) {
     return findDecl(ctx, typeName)?.discriminant;
 }
+/** Infer quantifier variable type from usage in body.
+ *  If the variable is used as a map/set key (e.g. map.has(k), map.get(k)),
+ *  return the collection's key type. Otherwise return null (default to int). */
+function inferQuantVarType(varName, body, ctx) {
+    // Look for calls like map.has(k), map.get(k), or array.includes(k) where k is our variable
+    if (body.kind === "call" && body.fn.kind === "field" &&
+        (body.fn.field === "has" || body.fn.field === "get" || body.fn.field === "includes") &&
+        body.args.length === 1 && body.args[0].kind === "var" && body.args[0].name === varName) {
+        const objTy = lookup(ctx.env, body.fn.obj.kind === "var" ? body.fn.obj.name : "");
+        if (objTy?.kind === "map")
+            return objTy.key;
+        if (objTy?.kind === "set")
+            return objTy.elem;
+        if (objTy?.kind === "array")
+            return objTy.elem;
+    }
+    // Recurse into subexpressions
+    if (body.kind === "binop") {
+        return inferQuantVarType(varName, body.left, ctx) ?? inferQuantVarType(varName, body.right, ctx);
+    }
+    if (body.kind === "unop")
+        return inferQuantVarType(varName, body.expr, ctx);
+    if (body.kind === "call") {
+        for (const a of body.args) {
+            const r = inferQuantVarType(varName, a, ctx);
+            if (r)
+                return r;
+        }
+        return inferQuantVarType(varName, body.fn, ctx);
+    }
+    if (body.kind === "field")
+        return inferQuantVarType(varName, body.obj, ctx);
+    if (body.kind === "index") {
+        return inferQuantVarType(varName, body.obj, ctx) ?? inferQuantVarType(varName, body.idx, ctx);
+    }
+    if (body.kind === "conditional") {
+        return inferQuantVarType(varName, body.cond, ctx) ??
+            inferQuantVarType(varName, body.then, ctx) ?? inferQuantVarType(varName, body.else, ctx);
+    }
+    if ((body.kind === "forall" || body.kind === "exists") && body.var !== varName) {
+        return inferQuantVarType(varName, body.body, ctx);
+    }
+    if (body.kind === "arrayLiteral") {
+        for (const el of body.elems) {
+            const r = inferQuantVarType(varName, el, ctx);
+            if (r)
+                return r;
+        }
+    }
+    if (body.kind === "record") {
+        if (body.spread) {
+            const r = inferQuantVarType(varName, body.spread, ctx);
+            if (r)
+                return r;
+        }
+        for (const f of body.fields) {
+            const r = inferQuantVarType(varName, f.value, ctx);
+            if (r)
+                return r;
+        }
+    }
+    return null;
+}
 function classifyCall(fn, ctx) {
     if (fn.kind === "field" && fn.obj.kind === "var" && fn.obj.name === "Math")
         return "pure";
@@ -59,11 +143,23 @@ function resolveExpr(e, ctx) {
         case "var":
             return { kind: "var", name: e.name, ty: lookup(ctx.env, e.name) ?? { kind: "unknown" } };
         case "num":
+            if (!Number.isInteger(e.value))
+                return { kind: "num", value: e.value, ty: { kind: "real" } };
             return { kind: "num", value: e.value, ty: e.value >= 0 ? { kind: "nat" } : { kind: "int" } };
         case "str":
             return { kind: "str", value: e.value, ty: { kind: "string" } };
         case "bool":
             return { kind: "bool", value: e.value, ty: { kind: "bool" } };
+        case "nonNull": {
+            const expr = resolveExpr(e.expr, ctx);
+            // Unwrap optional type; for map.get()!, force to direct access type
+            if (expr.kind === "call" && expr.fn.kind === "field" &&
+                expr.fn.obj.ty.kind === "map" && expr.fn.field === "get") {
+                return { ...expr, ty: expr.fn.obj.ty.value };
+            }
+            const ty = expr.ty.kind === "optional" ? expr.ty.inner : expr.ty;
+            return { ...expr, ty };
+        }
         case "binop": {
             let left = resolveExpr(e.left, ctx);
             let right = resolveExpr(e.right, ctx);
@@ -72,18 +168,80 @@ function resolveExpr(e, ctx) {
                 right = coerceStr(right, left.ty);
             }
             let ty = { kind: "unknown" };
-            if (["===", "!==", ">=", "<=", ">", "<", "&&", "||"].includes(e.op))
+            if (["===", "!==", ">=", "<=", ">", "<"].includes(e.op))
                 ty = { kind: "bool" };
-            else if (["+", "-", "*", "/", "%"].includes(e.op))
-                ty = left.ty;
+            else if (e.op === "&&")
+                ty = right.ty;
+            else if (e.op === "||" && left.ty.kind === "optional")
+                ty = left.ty.inner;
+            else if (e.op === "||")
+                ty = right.ty;
+            else if (["+", "-", "*", "/", "%"].includes(e.op)) {
+                ty = (left.ty.kind === "real" || right.ty.kind === "real") ? { kind: "real" } : left.ty;
+            }
             return { kind: "binop", op: e.op, left, right, ty };
         }
         case "unop": {
             const expr = resolveExpr(e.expr, ctx);
             return { kind: "unop", op: e.op, expr, ty: e.op === "!" ? { kind: "bool" } : expr.ty };
         }
-        case "call":
-            return { kind: "call", fn: resolveExpr(e.fn, ctx), args: e.args.map(a => resolveExpr(a, ctx)), ty: { kind: "unknown" }, callKind: classifyCall(e.fn, ctx) };
+        case "call": {
+            const fn = resolveExpr(e.fn, ctx);
+            let args = e.args.map(a => resolveExpr(a, ctx));
+            // Coerce non-optional args to Option when callee expects optional param: wrap in Some
+            if (fn.kind === "var" && ctx.fnParams.has(fn.name)) {
+                const paramTys = ctx.fnParams.get(fn.name);
+                args = args.map((a, i) => {
+                    if (i < paramTys.length && a.ty.kind !== "optional" && paramTys[i].kind === "optional") {
+                        return {
+                            kind: "call",
+                            fn: { kind: "var", name: "Some", ty: paramTys[i] },
+                            args: [a],
+                            ty: paramTys[i],
+                            callKind: "pure",
+                        };
+                    }
+                    return a;
+                });
+            }
+            let ty = { kind: "unknown" };
+            // Infer return types for collection methods
+            if (fn.kind === "field" && fn.obj.ty.kind === "map") {
+                if (fn.field === "get")
+                    ty = ctx.inSpec ? fn.obj.ty.value : { kind: "optional", inner: fn.obj.ty.value };
+                else if (fn.field === "has")
+                    ty = { kind: "bool" };
+                else if (fn.field === "set")
+                    ty = fn.obj.ty;
+            }
+            else if (fn.kind === "field" && fn.obj.ty.kind === "set") {
+                if (fn.field === "has")
+                    ty = { kind: "bool" };
+                else if (fn.field === "add")
+                    ty = fn.obj.ty;
+                else if (fn.field === "delete")
+                    ty = fn.obj.ty;
+            }
+            else if (fn.kind === "field" && fn.obj.ty.kind === "array") {
+                if (fn.field === "includes")
+                    ty = { kind: "bool" };
+                else if (fn.field === "shift")
+                    ty = fn.obj.ty.elem;
+                else if (fn.field === "push")
+                    ty = fn.obj.ty;
+            }
+            else if (fn.kind === "field" && fn.obj.ty.kind === "string") {
+                if (fn.field === "trim")
+                    ty = { kind: "string" };
+                else if (fn.field === "toLowerCase")
+                    ty = { kind: "string" };
+                else if (fn.field === "toUpperCase")
+                    ty = { kind: "string" };
+                else if (fn.field === "includes")
+                    ty = { kind: "bool" };
+            }
+            return { kind: "call", fn, args, ty, callKind: classifyCall(e.fn, ctx) };
+        }
         case "index": {
             const obj = resolveExpr(e.obj, ctx);
             const idx = resolveExpr(e.idx, ctx);
@@ -96,6 +254,9 @@ function resolveExpr(e, ctx) {
             if (e.field === "length" && (obj.ty.kind === "array" || obj.ty.kind === "string")) {
                 ty = { kind: "nat" };
             }
+            else if (e.field === "size" && (obj.ty.kind === "map" || obj.ty.kind === "set")) {
+                ty = { kind: "nat" };
+            }
             else if (obj.ty.kind === "user") {
                 if (getDiscriminant(ctx, obj.ty.name) === e.field)
                     isDiscriminant = true;
@@ -128,11 +289,13 @@ function resolveExpr(e, ctx) {
                 throw new Error("\\result is only valid in ensures");
             return { kind: "result", ty: ctx.returnTy };
         case "forall": {
-            const varTy = e.varType === "nat" ? { kind: "nat" } : { kind: "int" };
+            const varTy = e.varType === "nat" ? { kind: "nat" }
+                : inferQuantVarType(e.var, e.body, ctx) ?? { kind: "int" };
             return { kind: "forall", var: e.var, varTy, body: resolveExpr(e.body, withEnv(ctx, extend(ctx.env, e.var, varTy))), ty: { kind: "bool" } };
         }
         case "exists": {
-            const varTy = e.varType === "nat" ? { kind: "nat" } : { kind: "int" };
+            const varTy = e.varType === "nat" ? { kind: "nat" }
+                : inferQuantVarType(e.var, e.body, ctx) ?? { kind: "int" };
             return { kind: "exists", var: e.var, varTy, body: resolveExpr(e.body, withEnv(ctx, extend(ctx.env, e.var, varTy))), ty: { kind: "bool" } };
         }
         case "arrayLiteral": {
@@ -166,6 +329,12 @@ function resolveExpr(e, ctx) {
             const ty = then_.ty.kind !== "unknown" ? then_.ty : else_.ty;
             return { kind: "conditional", cond, then: then_, else: else_, ty };
         }
+        case "emptyCollection": {
+            const ty = parseTsType(e.tsType);
+            return { kind: "arrayLiteral", elems: [], ty };
+        }
+        case "havoc":
+            return { kind: "havoc", ty: resolveTsType(e.tsType, ctx.overrides) };
     }
 }
 // ── Resolve specs ────────────────────────────────────────────
@@ -202,7 +371,9 @@ function resolveStmt(s, ctx) {
         case "let": {
             const ty = resolveTsType(s.tsType, ctx.overrides, s.name);
             const init = coerceStr(resolveExpr(s.init, ctx), ty);
-            return [{ kind: "let", name: s.name, ty, mutable: s.mutable, init }, extend(ctx.env, s.name, ty)];
+            // const collections are mutable in value-semantics world (TS mutates in place, Dafny/Lean reassign)
+            const mutable = s.mutable || isRefMutableInTS(ty);
+            return [{ kind: "let", name: s.name, ty, mutable, init }, extend(ctx.env, s.name, ty)];
         }
         case "assign": {
             const targetTy = lookup(ctx.env, s.target) ?? { kind: "unknown" };
@@ -216,8 +387,19 @@ function resolveStmt(s, ctx) {
             return [{ kind: "continue" }, ctx.env];
         case "expr":
             return [{ kind: "expr", expr: resolveExpr(s.expr, ctx) }, ctx.env];
-        case "if":
-            return [{ kind: "if", cond: resolveExpr(s.cond, ctx), then: resolveBlock(s.then, ctx), else: resolveBlock(s.else, ctx) }, ctx.env];
+        case "if": {
+            // Narrow optional<T> → T when checking !== undefined or undefined !==
+            let thenCtx = ctx, elseCtx = ctx;
+            const narrowed = narrowOptional(s.cond, ctx.env);
+            if (narrowed) {
+                const env = extend(ctx.env, narrowed.varName, narrowed.innerTy);
+                if (narrowed.inThen)
+                    thenCtx = withEnv(ctx, env);
+                else
+                    elseCtx = withEnv(ctx, env);
+            }
+            return [{ kind: "if", cond: resolveExpr(s.cond, ctx), then: resolveBlock(s.then, thenCtx), else: resolveBlock(s.else, elseCtx) }, ctx.env];
+        }
         case "while": {
             const whileSpecCtx = { ...ctx, inSpec: true };
             return [{
@@ -231,24 +413,66 @@ function resolveStmt(s, ctx) {
         }
         case "forof": {
             const iterable = resolveExpr(s.iterable, ctx);
-            const elemTy = iterable.ty.kind === "array" ? iterable.ty.elem : { kind: "unknown" };
-            const idxName = `_${s.varName}_idx`;
-            const withIdx = extend(ctx.env, idxName, { kind: "nat" });
-            const withElem = extend(withIdx, s.varName, elemTy);
-            const bodyCtx = withEnv(ctx, withElem);
+            // Determine element types for each destructured name
+            const nameTypes = [];
+            let env = ctx.env;
+            if (s.names.length === 1) {
+                // Single name: element type from array/set
+                const elemTy = iterable.ty.kind === "array" ? iterable.ty.elem
+                    : iterable.ty.kind === "set" ? iterable.ty.elem
+                        : { kind: "unknown" };
+                nameTypes.push(elemTy);
+            }
+            else if (s.names.length >= 2 && iterable.ty.kind === "map") {
+                // Map destructuring: [key, value]
+                nameTypes.push(iterable.ty.key, iterable.ty.value);
+            }
+            else {
+                // General tuple destructuring: all unknown
+                for (const _ of s.names)
+                    nameTypes.push({ kind: "unknown" });
+            }
+            const idxName = `_${s.names[0]}_idx`;
+            env = extend(env, idxName, { kind: "nat" });
+            for (let j = 0; j < s.names.length; j++) {
+                env = extend(env, s.names[j], nameTypes[j] ?? { kind: "unknown" });
+            }
+            const bodyCtx = withEnv(ctx, env);
             return [{
-                    kind: "forof", varName: s.varName, varTy: elemTy, iterable,
+                    kind: "forof", names: s.names, nameTypes, iterable,
                     invariants: resolveSpecs(s.invariants, { ...bodyCtx, inSpec: true }),
                     doneWith: s.doneWith ? resolveSpec(s.doneWith, { ...bodyCtx, inSpec: true }) : null,
                     body: resolveBlock(s.body, bodyCtx),
                 }, ctx.env];
         }
+        case "throw":
+            return [{ kind: "throw" }, ctx.env];
         case "switch":
             return [{
                     kind: "switch", expr: resolveExpr(s.expr, ctx), discriminant: s.discriminant,
                     cases: s.cases.map(c => ({ label: c.label, body: resolveBlock(c.body, ctx) })),
                     defaultBody: resolveBlock(s.defaultBody, ctx),
                 }, ctx.env];
+        case "ghostLet": {
+            const specCtx = { ...ctx, inSpec: true };
+            // Handle new Set<T>() / new Map<K,V>() constructors
+            const collMatch = s.init.match(/^new\s+(Set|Map)<(.+)>\(\)$/);
+            const init = collMatch
+                ? resolveExpr({ kind: "emptyCollection", collectionType: collMatch[1], tsType: `${collMatch[1]}<${collMatch[2]}>` }, specCtx)
+                : resolveExpr(parseExpr(s.init), specCtx);
+            const ty = s.tsType ? parseTsType(s.tsType) : init.ty;
+            return [{ kind: "ghostLet", name: s.name, ty, init }, extend(ctx.env, s.name, ty)];
+        }
+        case "ghostAssign": {
+            const specCtx = { ...ctx, inSpec: true };
+            const value = resolveExpr(parseExpr(s.value), specCtx);
+            return [{ kind: "ghostAssign", target: s.target, value }, ctx.env];
+        }
+        case "assert": {
+            const specCtx = { ...ctx, inSpec: true };
+            const expr = resolveExpr(parseExpr(s.expr), specCtx);
+            return [{ kind: "assert", expr }, ctx.env];
+        }
     }
 }
 // ── Pure / return-in-loop detection ──────────────────────────
@@ -420,7 +644,7 @@ function containsReturn(stmts) {
     return false;
 }
 // ── Resolve function / module ────────────────────────────────
-function resolveFunction(fn, typeDecls, pureFns) {
+function resolveFunction(fn, typeDecls, pureFns, fnParams = new Map()) {
     if (hasReturnInLoop(fn.body)) {
         throw new Error(`${fn.name}: return inside a loop is not supported.`);
     }
@@ -430,7 +654,7 @@ function resolveFunction(fn, typeDecls, pureFns) {
     let env = null;
     for (const p of params)
         env = extend(env, p.name, p.ty);
-    const baseCtx = { env, typeDecls, overrides, allowResult: false, returnTy, pureFns, inSpec: false, inLambda: false };
+    const baseCtx = { env, typeDecls, overrides, allowResult: false, returnTy, pureFns, fnParams, inSpec: false, inLambda: false };
     const requiresCtx = { ...baseCtx, inSpec: true };
     const ensuresCtx = { ...baseCtx, allowResult: true, inSpec: true };
     return {
@@ -441,11 +665,53 @@ function resolveFunction(fn, typeDecls, pureFns) {
         body: resolveBlock(fn.body, baseCtx),
     };
 }
+function resolveClass(cls, typeDecls, pureFns, fnParams = new Map()) {
+    const fields = cls.fields.map(f => ({ name: f.name, ty: parseTsType(f.tsType) }));
+    // Create a synthetic record type for 'this' so field access resolves
+    const thisType = { kind: "user", name: cls.name };
+    const thisDecl = { name: cls.name, kind: "record", fields: cls.fields.map(f => ({ name: f.name, tsType: f.tsType })) };
+    const allTypeDecls = [...typeDecls, thisDecl];
+    const methods = cls.methods.map(fn => {
+        // Add 'this' to the environment
+        const overrides = new Map(fn.typeAnnotations.map(a => [a.name, a.type]));
+        const params = fn.params.map(p => ({ name: p.name, ty: resolveTsType(p.tsType, overrides, p.name) }));
+        const returnTy = resolveTsType(fn.returnType, overrides, "\\result");
+        let env = null;
+        env = extend(env, "this", thisType);
+        for (const p of params)
+            env = extend(env, p.name, p.ty);
+        const baseCtx = { env, typeDecls: allTypeDecls, overrides, allowResult: false, returnTy, pureFns, fnParams, inSpec: false, inLambda: false };
+        const requiresCtx = { ...baseCtx, inSpec: true };
+        const ensuresCtx = { ...baseCtx, allowResult: true, inSpec: true };
+        return {
+            name: fn.name, params, returnTy,
+            requires: resolveSpecs(fn.requires, requiresCtx),
+            ensures: resolveSpecs(fn.ensures, ensuresCtx),
+            isPure: false, // class methods are never pure (they access this)
+            body: resolveBlock(fn.body, baseCtx),
+        };
+    });
+    return { name: cls.name, fields, methods };
+}
 export function resolveModule(raw) {
     const pureFns = computePureFns(raw.functions);
+    // Pre-compute function parameter types for optional coercion
+    const fnParams = new Map();
+    for (const fn of raw.functions) {
+        const overrides = new Map(fn.typeAnnotations.map(a => [a.name, a.type]));
+        fnParams.set(fn.name, fn.params.map(p => resolveTsType(p.tsType, overrides, p.name)));
+    }
+    const emptyCtx = { env: null, typeDecls: raw.typeDecls, overrides: new Map(), allowResult: false, returnTy: { kind: "int" }, pureFns, fnParams, inSpec: false, inLambda: false };
+    const constants = (raw.constants ?? []).map(c => ({
+        name: c.name,
+        ty: parseTsType(c.tsType),
+        value: resolveExpr(c.value, emptyCtx),
+    }));
     return {
         file: raw.file,
         typeDecls: raw.typeDecls,
-        functions: raw.functions.map(fn => resolveFunction(fn, raw.typeDecls, pureFns)),
+        constants,
+        functions: raw.functions.map(fn => resolveFunction(fn, raw.typeDecls, pureFns, fnParams)),
+        classes: (raw.classes ?? []).map(cls => resolveClass(cls, raw.typeDecls, pureFns, fnParams)),
     };
 }

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,11 @@ class Parser {
     parseCmp() {
         const left = this.parseAdd();
         const t = this.peek();
-        if (t?.type === "op" && ["===", "!==", ">=", "<=", ">", "<"].includes(t.value)) {
+        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 +216,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();
@@ -227,6 +270,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 = [];