lemmascript 0.5.18 → 0.5.20

package/tools/dist/extract.js

@@ -6,15 +6,43 @@
  */
 import { Project, Node, SyntaxKind, ScriptTarget, ts } from "ts-morph";
 import { initTypeParser } from "./types.js";
+import { normalizeBigIntLiteral } from "./rawir.js";
 import { setUserNames, freshName } from "./names.js";
 // ── Expression extraction ────────────────────────────────────
 /** When set, calls whose function/method name matches this key are replaced with havoc. */
 let _havocKey = null;
+/** A leading `//@ havoc`, `//@ havoc : Type`, or `//@ havoc <key>` directive. */
+function havocDirective(s) {
+    const m = s.getLeadingCommentRanges()
+        .map(r => r.getText().trim().match(/^\/\/@ havoc(?:\s*:\s*(.+)|(?:\s+(\S+)))?$/))
+        .find(m => m !== null);
+    return m ? { type: m[1]?.trim() ?? null, key: m[2] ?? null } : null;
+}
+/** Run `fn` with `key` as the subexpression havoc key, restoring the outer one. */
+function withHavocKey(key, fn) {
+    const saved = _havocKey;
+    if (key)
+        _havocKey = key;
+    try {
+        return fn();
+    }
+    finally {
+        _havocKey = saved;
+    }
+}
 /** Auto-detected cross-file calls. Populated by `extractExpr` whenever it sees
  *  a call `Obj.method(...)` or `foo(...)` whose ts-morph symbol resolves to a
  *  different `.ts` source file. Emitted in Dafny as `function {:axiom} <flat>`.
  *  Cleared at the start of every `extractModule`. */
 const _externs = new Map();
+/** Signature types of *kept* externs, for the imported-type resolver: a type
+ *  reachable ONLY through an imported function's signature (e.g. an extern
+ *  returning PresentFact that no local signature mentions) must still be
+ *  resolved into a full decl, or it synthesizes opaque. Filled only after the
+ *  extern survives the `_externs` dedup — a cross-file signature superseded by a
+ *  same-file `//@ extern` contributes nothing to the output, so resolving its
+ *  types would emit decls that no emitted declaration mentions. */
+const _externSigTypes = [];
 let _currentSourceFile = null;
 /** True only while extracting a function body. Module-level constants that
  *  reference cross-file callees (e.g., `BusEvent.define(...)` inside a
@@ -30,10 +58,14 @@ let _destrCounter = 0;
  *  lifted `requires`/`ensures` see all the symbols they reference). Idempotent
  *  via the `_externs` dedup. */
 function registerExternIfCrossFile(callee, sourceFile) {
-    const ext = detectCrossFileExtern(callee, sourceFile);
+    const sigTypes = [];
+    const ext = detectCrossFileExtern(callee, sourceFile, sigTypes);
     if (!ext || _externs.has(ext.qualified))
         return;
     _externs.set(ext.qualified, ext);
+    // Only now that the extern is kept do its signature types become resolver
+    // seeds — see `_externSigTypes`.
+    _externSigTypes.push(...sigTypes);
     // Recurse: scan the source decl's body for nested cross-file calls so any
     // symbol referenced by the copied spec is itself declared in the output.
     let symbol = callee.getSymbol();
@@ -56,7 +88,7 @@ function registerExternIfCrossFile(callee, sourceFile) {
         }
     }
 }
-function detectCrossFileExtern(callee, sourceFile) {
+function detectCrossFileExtern(callee, sourceFile, sigTypesOut) {
     let symbol = callee.getSymbol();
     if (!symbol)
         return null;
@@ -92,12 +124,32 @@ function detectCrossFileExtern(callee, sourceFile) {
     // kept): a bare `TMsg`, not `import("/abs/path/transcript").TMsg` — the
     // importing module declares the datatype locally, so the axiom must use the
     // local name.
-    const externTypeText = (t) => t.getText(callee, ts.TypeFormatFlags.UseAliasDefinedOutsideCurrentScope);
+    // NoTruncation: a wide expansion (e.g. an alias for a large string-literal
+    // union, not importable at the call site) must print whole — a truncated
+    // union is unparseable and synthesizes an opaque decl named by its own text.
+    const externTypeText = (t) => t.getText(callee, ts.TypeFormatFlags.UseAliasDefinedOutsideCurrentScope | ts.TypeFormatFlags.NoTruncation);
     const params = sig.getParameters().map(p => ({
         name: p.getName(),
         tsType: externTypeText(p.getTypeAtLocation(callee)),
     }));
     const returnType = externTypeText(sig.getReturnType());
+    for (const p of sig.getParameters()) {
+        sigTypesOut.push({ type: p.getTypeAtLocation(callee), node: callee });
+    }
+    sigTypesOut.push({ type: sig.getReturnType(), node: callee });
+    // Also seed from the source declaration's syntactic type nodes: symbol-based
+    // types can drop the alias symbol (the printed signature then names an alias
+    // like `TypeDecls` that would otherwise synthesize opaque), while a type
+    // node's type keeps it.
+    const srcDecl = externalDecl;
+    for (const sp of srcDecl.getParameters?.() ?? []) {
+        const tn = sp.getTypeNode?.();
+        if (tn)
+            sigTypesOut.push({ type: tn.getType(), node: tn });
+    }
+    const rtn = srcDecl.getReturnTypeNode?.();
+    if (rtn)
+        sigTypesOut.push({ type: rtn.getType(), node: rtn });
     let qualified;
     if (Node.isPropertyAccessExpression(callee)) {
         qualified = `${callee.getExpression().getText()}.${callee.getName()}`;
@@ -293,24 +345,29 @@ function _eraseGenerics(tsType) {
     return tsType;
 }
 function extractExpr(node) {
-    // Havoc key matching: replace matching calls with havoc expression
-    if (_havocKey && Node.isCallExpression(node)) {
+    // Havoc key matching: replace matching calls or new expressions with havoc expression
+    if (_havocKey && (Node.isCallExpression(node) || Node.isNewExpression(node))) {
         const fnExpr = node.getExpression();
         const name = Node.isPropertyAccessExpression(fnExpr) ? fnExpr.getName()
             : Node.isIdentifier(fnExpr) ? fnExpr.getText()
                 : null;
         if (name === _havocKey) {
-            return { kind: "havoc", tsType: typeToString(node.getType()) };
+            // Prefer the contextual type: the abstracted value stands in where the
+            // surrounding code expects it, and a subclass (`new SdkError` into an
+            // `Error` field) has no subtyping relation once both are opaque.
+            const ty = node.getContextualType() ?? node.getType();
+            return { kind: "havoc", tsType: typeToString(ty) };
         }
     }
     // Numeric literal
     if (Node.isNumericLiteral(node)) {
         return { kind: "num", value: Number(node.getLiteralValue()) };
     }
-    // BigInt literal (e.g. 32n, 0xffffn) — integer, with bigint division semantics
+    // BigInt literal (e.g. 32n, 0xffffn) — exact integer, with bigint division
+    // semantics. Kept as a decimal string: `getLiteralValue()`/`Number()` would
+    // round anything past 2^53 (`9007199254740993n` → `9007199254740992`).
     if (Node.isBigIntLiteral(node)) {
-        const text = node.getText().replace(/n$/, '');
-        return { kind: "num", value: Number(text), big: true };
+        return { kind: "bigint", value: normalizeBigIntLiteral(node.getText()) };
     }
     // Template literal: `foo${x}bar` → "foo" + x + "bar"
     if (Node.isTemplateExpression(node)) {
@@ -462,10 +519,9 @@ function extractExpr(node) {
             const typeNode = p.getTypeNode();
             return { name: p.getName(), tsType: typeNode ? typeNode.getText() : undefined };
         });
-        // Capture an explicit return annotation (`(x): Out => …`) so resolve can type
-        // return-position record literals to their named type instead of a tuple.
-        const retNode = node.getReturnTypeNode();
-        const returnTsType = retNode ? typeToString(node.getReturnType()) : undefined;
+        // Return type from the checker — inferred when unannotated — so resolve can
+        // type return-position record literals and give the lambda a real fn type.
+        const returnTsType = typeToString(node.getReturnType());
         const body = node.getBody();
         if (Node.isExpression(body)) {
             return { kind: "lambda", params, body: extractExpr(body), returnTsType };
@@ -688,8 +744,14 @@ function extractTypeDecl(decl, extraDecls) {
                             continue;
                         let tsType = typeToString(prop.getTypeAtLocation(decl));
                         const propDecl = prop.getDeclarations()[0];
-                        if (propDecl && propDecl.hasQuestionToken?.() && !tsType.includes(" | undefined")) {
-                            tsType = `${tsType} | undefined`;
+                        tsType = declaredTypeTextIfBetter(propDecl, tsType);
+                        if (propDecl && propDecl.hasQuestionToken?.()) {
+                            // Normalize checker output that puts `undefined` first, then
+                            // ensure exactly one trailing `| undefined`.
+                            if (tsType.startsWith("undefined | "))
+                                tsType = `${tsType.slice("undefined | ".length)} | undefined`;
+                            else if (!tsType.includes(" | undefined"))
+                                tsType = `${tsType} | undefined`;
                         }
                         fields.push({ name: prop.getName(), tsType });
                     }
@@ -780,12 +842,18 @@ function extractRecord(name, type, locationNode, overrides, extraDecls) {
         }
         const propType = prop.getTypeAtLocation(locationNode);
         let tsType = typeToString(propType);
+        const propDecl = prop.getDeclarations()[0];
+        tsType = declaredTypeTextIfBetter(propDecl, tsType);
         // Optional property: `foo?: T` reports as `T` (ts-morph strips the
         // `| undefined` from a question-token type). Add it back so the field
         // resolves to `Optional<T>`.
-        const propDecl = prop.getDeclarations()[0];
-        if (propDecl && propDecl.hasQuestionToken?.() && !tsType.includes(" | undefined")) {
-            tsType = `${tsType} | undefined`;
+        if (propDecl && propDecl.hasQuestionToken?.()) {
+            // Normalize checker output that puts `undefined` first, then ensure
+            // exactly one trailing `| undefined`.
+            if (tsType.startsWith("undefined | "))
+                tsType = `${tsType.slice("undefined | ".length)} | undefined`;
+            else if (!tsType.includes(" | undefined"))
+                tsType = `${tsType} | undefined`;
         }
         // Inline anonymous object types: ts-morph names them __type.
         // Generate a synthetic named record and reference it by name instead.
@@ -832,6 +900,23 @@ function findDiscriminant(members) {
     }
     return null;
 }
+/** Recover a field's *declared* type text when the semantic printer degraded
+ *  to ts-morph's anonymous `__type` — a self-referential alias reached
+ *  through a `| null` union expands structurally and loses its name. The
+ *  syntactic node text preserves the alias spelling (`TExpr | null`). Only
+ *  plain reference text is used: inline object literals (containing `{`)
+ *  keep the `__type` marker so record synthesis can handle them. */
+function declaredTypeTextIfBetter(propDecl, tsType) {
+    if (!tsType.includes("__type") || !propDecl)
+        return tsType;
+    const tn = propDecl.getTypeNode?.();
+    if (!tn)
+        return tsType;
+    const text = tn.getText();
+    if (text.includes("__type") || text.includes("{"))
+        return tsType;
+    return text;
+}
 function typeToString(type) {
     if (type.isUndefined())
         return "undefined";
@@ -1031,6 +1116,7 @@ function renameRawExpr(e, from, to) {
     switch (e.kind) {
         case "var": return e.name === from ? { kind: "var", name: to } : e;
         case "num":
+        case "bigint":
         case "str":
         case "bool":
         case "result":
@@ -1179,12 +1265,10 @@ function extractStmts(stmts) {
             continue;
         }
         if (Node.isVariableStatement(s)) {
-            const havocMatch = s.getLeadingCommentRanges()
-                .map(r => r.getText().trim().match(/^\/\/@ havoc(?:\s*:\s*(.+)|(?:\s+(\S+)))?$/))
-                .find(m => m !== null);
-            const havocType = havocMatch?.[1]?.trim() ?? null; // //@ havoc : Type
-            const havocKey = havocMatch?.[2] ?? null; // //@ havoc key
-            const isHavoc = !!havocMatch;
+            const havoc = havocDirective(s);
+            const havocType = havoc?.type ?? null; // //@ havoc : Type
+            const havocKey = havoc?.key ?? null; // //@ havoc key
+            const isHavoc = !!havoc;
             for (const d of s.getDeclarations()) {
                 // Havoc on destructuring: emit each named binding as a separate havoced variable
                 const nameNode = d.getNameNode();
@@ -1625,7 +1709,11 @@ function extractStmts(stmts) {
             // functions this would emit the wrong shape, but lsc has no current
             // examples of explicit bare return in void functions; revisit if one
             // appears.
-            result.push({ kind: "return", value: expr ? extractExpr(expr) : { kind: "var", name: "undefined" }, line });
+            // `//@ havoc <key>` on a return abstracts the matching calls or new
+            // expressions inside the returned expression — there is no variable to
+            // hang a whole-value havoc on, so only the key form applies here.
+            const value = withHavocKey(havocDirective(s)?.key ?? null, () => expr ? extractExpr(expr) : { kind: "var", name: "undefined" });
+            result.push({ kind: "return", value, line });
             continue;
         }
         if (Node.isBreakStatement(s)) {
@@ -1641,14 +1729,12 @@ function extractStmts(stmts) {
             // //@ havoc before `x = e` — discard the RHS, assign a nondeterministic
             // value of x's type. Only applies to plain `=` with an identifier LHS;
             // compound assigns, `arr[i] = v`, and `x++` fall through to desugaring.
-            const havocMatch = s.getLeadingCommentRanges()
-                .map(r => r.getText().trim().match(/^\/\/@ havoc(?:\s*:\s*(.+))?$/))
-                .find(m => m !== null);
-            if (havocMatch && Node.isBinaryExpression(expr)
+            const havoc = havocDirective(s);
+            if (havoc && !havoc.key && Node.isBinaryExpression(expr)
                 && expr.getOperatorToken().getText() === "="
                 && Node.isIdentifier(expr.getLeft())) {
                 const target = expr.getLeft().getText();
-                const tsType = havocMatch[1]?.trim() ?? _eraseGenerics(typeToString(expr.getLeft().getType()));
+                const tsType = havoc.type ?? _eraseGenerics(typeToString(expr.getLeft().getType()));
                 result.push({ kind: "assign", target, value: { kind: "havoc", tsType }, line });
                 continue;
             }
@@ -1838,6 +1924,12 @@ function extractFunctionInner(fn, parentAnnotations) {
                 return "void"; // Promise<void>
             }
             const node = fn.getReturnTypeNode();
+            // A type predicate (`x is T` / `asserts x is T`) is a `boolean` at
+            // runtime; the narrowing it performs is a TS-only refinement with no
+            // counterpart in the model. Without this, `getText()` yields "x is T"
+            // and the type mapper reads the subject name as an opaque type.
+            if (node && node.getKind() === SyntaxKind.TypePredicate)
+                return "boolean";
             if (node && Node.isUnionTypeNode(node))
                 return _eraseGenerics(_tsTypeFromUnionNode(node));
             if (node)
@@ -1870,6 +1962,7 @@ export function extractModule(sourceFile) {
     // `extractExpr` during call extraction (only symbols *actually used* end up
     // here), deduped by qualified name.
     _externs.clear();
+    _externSigTypes.length = 0;
     // Share the module's ts-morph Project with parseTsType (scratch source file
     // for type-string parsing). Done before declare-type parsing so any
     // parseTsType call downstream uses the same Project.
@@ -2397,6 +2490,28 @@ export function extractModule(sourceFile) {
                 }
             }
         }
+        // A constant's initializer can reference other constants
+        // (`const ZERO_NINE = ZERO + nthDigit(-1)`). Close over those initializers
+        // before filtering — mirroring the transitive type filter below — or a
+        // constant reachable only from another constant is dropped and the backend
+        // sees an undefined name.
+        // Snapshot first: what the closure adds are VALUE references, and a value
+        // and a type can share a name (`const Action = Schema.Literals(…)` next to
+        // `type Action = Schema.Schema.Type<typeof Action>`). Keeping the constant
+        // alive must not also drag in the unrelated type alias, so the type filter
+        // below runs off the pre-closure set.
+        const typeReferencedNames = new Set(referencedNames);
+        for (let grew = true; grew;) {
+            grew = false;
+            for (const c of constants) {
+                if (!referencedNames.has(c.name))
+                    continue;
+                const before = referencedNames.size;
+                collectNamesExpr(c.value);
+                if (referencedNames.size !== before)
+                    grew = true;
+            }
+        }
         constants.splice(0, constants.length, ...constants.filter(c => referencedNames.has(c.name)));
         // Filter types to only those referenced by verified functions (transitive)
         const neededTypes = new Set();
@@ -2415,7 +2530,7 @@ export function extractModule(sourceFile) {
                     for (const m of f.tsType.matchAll(/\b([A-Z]\w*)\b/g))
                         markType(m[1]);
         }
-        for (const name of referencedNames)
+        for (const name of typeReferencedNames)
             markType(name);
         // Signature types also mark their base after stripping array/optional
         // WRAPPERS (`Out[]`/`Msg | undefined` → `Out`/`Msg`), so a function returning
@@ -2431,13 +2546,12 @@ export function extractModule(sourceFile) {
     // Resolve imported types: extract types referenced in function signatures but not in this file
     const knownTypes = new Set(typeDecls.map(d => d.name));
     const builtins = new Set(["Map", "Set", "Array", "String", "Number", "Boolean", "Promise", "Date", "RegExp", "Error"]);
+    const visitedTypes = new Set();
     function resolveType(t, locationNode) {
-        // Unwrap arrays and generics to find user-defined types
-        if (t.isArray()) {
-            resolveType(t.getArrayElementTypeOrThrow(), locationNode);
-            return;
-        }
-        // Resolve type aliases (e.g. string unions imported from other files)
+        // Resolve type aliases (e.g. string unions imported from other files).
+        // BEFORE the visited guard: the same interned compilerType can arrive both
+        // with and without its alias symbol (getTypeAtLocation drops it), and an
+        // aliasless first visit must not suppress the alias extraction.
         const alias = t.getAliasSymbol();
         if (alias) {
             const aliasName = alias.getName();
@@ -2470,6 +2584,18 @@ export function extractModule(sourceFile) {
                 }
             }
         }
+        // Recursion guard: recursive unions (Expr → variant → body: Expr) are
+        // reachable now that anonymous variant fields are walked below. Keyed on
+        // the compiler's interned Type object — alias names are not enough,
+        // because getTypeAtLocation can drop the alias symbol.
+        if (visitedTypes.has(t.compilerType))
+            return;
+        visitedTypes.add(t.compilerType);
+        // Unwrap arrays and generics to find user-defined types
+        if (t.isArray()) {
+            resolveType(t.getArrayElementTypeOrThrow(), locationNode);
+            return;
+        }
         if (t.isUnion()) {
             for (const u of t.getUnionTypes())
                 resolveType(u, locationNode);
@@ -2492,6 +2618,15 @@ export function extractModule(sourceFile) {
                 }
             }
         }
+        else if (t.isObject() && (!name || name.startsWith("__")) && t.getCallSignatures().length === 0) {
+            // Anonymous object type — typically a variant of an imported
+            // discriminated union. There is no decl to extract, but its fields can
+            // reference named types (`arms: MatchArm[]`) that downstream passes
+            // need declared, so walk them.
+            for (const prop of t.getProperties()) {
+                resolveType(prop.getTypeAtLocation(locationNode), locationNode);
+            }
+        }
     }
     for (let i = 0; i < fnsToExtract.length; i++) {
         const f = fnsToExtract[i];
@@ -2507,6 +2642,9 @@ export function extractModule(sourceFile) {
             resolveType(p.getType(), p);
         }
     }
+    // Extern signature types: see _externSigTypes.
+    for (const r of _externSigTypes)
+        resolveType(r.type, r.node);
     // Resolve anonymous object return types into synthetic named types
     for (let i = 0; i < fnsToExtract.length; i++) {
         const f = fnsToExtract[i];

package/tools/dist/info-command.js

@@ -36,3 +36,71 @@ export function runInfo(raw, outPath) {
     writeFileSync(outPath, JSON.stringify(out, null, 2) + "\n");
     console.log(`Wrote ${outPath}`);
 }
+/** Statement/expression kinds present anywhere in a function body — a cheap
+ *  structural census so consumers can classify (havoc/assume/throw usage)
+ *  without receiving the whole body. */
+function bodyKinds(fn) {
+    // Keys under which a Ty (not a statement/expression) hangs — their `kind`
+    // tags belong to the type grammar and would pollute the census.
+    const TY_KEYS = new Set(["ty", "binderTy", "varTy", "nameTypes"]);
+    const kinds = new Set();
+    const walk = (node) => {
+        if (Array.isArray(node)) {
+            node.forEach(walk);
+            return;
+        }
+        if (node && typeof node === "object") {
+            const o = node;
+            if (typeof o.kind === "string") {
+                kinds.add(o.kind === "assert" && o.assumed === true ? "assume" : o.kind);
+            }
+            for (const [k, v] of Object.entries(o))
+                if (!TY_KEYS.has(k))
+                    walk(v);
+        }
+    };
+    walk(fn.body);
+    return [...kinds].sort();
+}
+function typedFn(fn, rawFn) {
+    // Carry the original TS type string per parameter: Ty conflates types whose
+    // runtime shapes differ (Map<K,V> and Record<K,V> both map to kind "map"),
+    // and satellites that construct runtime values need to tell them apart.
+    const rawTsTypes = new Map((rawFn?.params ?? []).map(p => [p.name, p.tsType]));
+    return {
+        name: fn.name,
+        exported: rawFn?.exported ?? false,
+        typeParams: fn.typeParams,
+        params: fn.params.map(p => ({ ...p, tsType: rawTsTypes.get(p.name) })),
+        returnTy: fn.returnTy,
+        requires: fn.requires,
+        ensures: fn.ensures,
+        decreases: fn.decreases,
+        contract: rawFn?.contract ?? [],
+        isPure: fn.isPure,
+        forcePure: fn.forcePure,
+        autohavoc: fn.autohavoc,
+        bodyKinds: bodyKinds(fn),
+    };
+}
+export function runTypedInfo(raw, typed, version, backendDirective, dafny) {
+    const rawByName = new Map(raw.functions.map(f => [f.name, f]));
+    const rawMethods = new Map(raw.classes.flatMap(c => c.methods.map(m => [`${c.name}.${m.name}`, m])));
+    const out = {
+        schema: 1,
+        lemmascript: version,
+        file: typed.file,
+        backendDirective,
+        typeDecls: typed.typeDecls,
+        externs: typed.externs,
+        constants: typed.constants,
+        functions: typed.functions.map(f => typedFn(f, rawByName.get(f.name))),
+        classes: typed.classes.map(c => ({
+            name: c.name,
+            fields: c.fields,
+            methods: c.methods.map(m => typedFn(m, rawMethods.get(`${c.name}.${m.name}`))),
+        })),
+        dafny,
+    };
+    console.log(JSON.stringify(out, null, 2));
+}

package/tools/dist/ir.js

@@ -5,7 +5,7 @@
  * The emit phase pretty-prints them to backend syntax (Lean or Dafny).
  */
 export const pWild = () => ({ kind: "wild" });
-export const pCtor = (ctor, ...binders) => ({ kind: "ctor", ctor, binders });
+export const pCtor = (c, ...binders) => ({ kind: "ctor", ctor: c, binders });
 /** Binder identifiers a pattern introduces (`[]` for wildcard / nullary ctor). */
 export function patternBinders(p) {
     return p.kind === "ctor" ? p.binders : [];
@@ -17,19 +17,40 @@ export function patternCtor(p) {
 export function patternBinds(p, name) {
     return patternBinders(p).includes(name);
 }
+// ── Literal queries ──────────────────────────────────────────
+/** The exact value of an integer-literal operand (possibly negated), or null
+ *  when `e` isn't one. Answers in compiler-side `bigint` so a backend folding a
+ *  literal into arithmetic stays exact: JS bitwise operators truncate to 32 bits
+ *  and `Math.pow(2, n)` is a double, both of which lie past 2^53. A `num`
+ *  outside the safe-integer range has already lost precision, so it is not a
+ *  usable answer — hence null. */
+export function exactIntegerLiteral(e) {
+    if (e.kind === "bigint")
+        return BigInt(e.value);
+    if (e.kind === "num")
+        return Number.isSafeInteger(e.value) ? BigInt(e.value) : null;
+    // Transform folds `-<num>` into a negative `num`, but leaves a negated
+    // `bigint` structural (folding it would coerce the payload through Number).
+    if (e.kind === "unop" && e.op === "-") {
+        const inner = exactIntegerLiteral(e.expr);
+        return inner === null ? null : -inner;
+    }
+    return null;
+}
 export function anyExpr(e, pred) {
     if (pred(e))
         return true;
     switch (e.kind) {
         case "var":
         case "num":
+        case "bigint":
         case "bool":
         case "str":
         case "emptyMap":
         case "emptySet":
         case "havoc":
         case "default": return false;
-        case "constructor": return (e.args ?? []).some(a => anyExpr(a, pred));
+        case "constructor": return e.args.some(a => anyExpr(a, pred));
         case "binop": return anyExpr(e.left, pred) || anyExpr(e.right, pred);
         case "unop":
         case "toNat":
@@ -46,7 +67,7 @@ export function anyExpr(e, pred) {
         case "methodCall": return anyExpr(e.obj, pred) || e.args.some(a => anyExpr(a, pred));
         case "lambda": return e.body.some(s => anyExprInStmt(s, pred));
         case "if": return anyExpr(e.cond, pred) || anyExpr(e.then, pred) || anyExpr(e.else, pred);
-        case "match": return (typeof e.scrutinee !== "string" && anyExpr(e.scrutinee, pred)) || e.arms.some(a => anyExpr(a.body, pred));
+        case "match": return anyExpr(e.scrutinee, pred) || e.arms.some(a => anyExpr(a.body, pred));
         case "forall":
         case "exists": return anyExpr(e.body, pred);
         case "let": return anyExpr(e.value, pred) || anyExpr(e.body, pred);
@@ -65,7 +86,7 @@ export function anyExprInStmt(s, pred) {
         case "break":
         case "continue": return false;
         case "if": return anyExpr(s.cond, pred) || anyExprInStmts(s.then, pred) || anyExprInStmts(s.else, pred);
-        case "match": return (typeof s.scrutinee !== "string" && anyExpr(s.scrutinee, pred)) || s.arms.some(a => anyExprInStmts(a.body, pred));
+        case "match": return anyExpr(s.scrutinee, pred) || s.arms.some(a => anyExprInStmts(a.body, pred));
         case "while": return anyExpr(s.cond, pred) || s.invariants.some(i => anyExpr(i, pred))
             || (s.decreasing ? anyExpr(s.decreasing, pred) : false) || (s.doneWith ? anyExpr(s.doneWith, pred) : false)
             || anyExprInStmts(s.body, pred);
@@ -80,10 +101,9 @@ export function anyExprInStmts(stmts, pred) {
 // function. These drive the *local* freshness checks for user-facing binders
 // (the result out-parameter, comprehension binders): a binder is checked only
 // against the expressions/scope it actually wraps, not the whole module.
-const _refsName = (name) => e => (e.kind === "var" && e.name === name) ||
+const _refsName = (name) => (e) => (e.kind === "var" && e.name === name) ||
     (e.kind === "app" && e.fn === name) ||
-    (e.kind === "constructor" && e.name === name) ||
-    (e.kind === "match" && typeof e.scrutinee === "string" && e.scrutinee === name);
+    (e.kind === "constructor" && e.name === name);
 export function usesName(e, name) {
     return anyExpr(e, _refsName(name));
 }