lemmascript 0.5.21 → 0.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lemmascript",
-  "version": "0.5.21",
+  "version": "0.6.0",
   "description": "A verification toolchain for TypeScript — generates Lean 4 or Dafny from annotated TS",
   "type": "module",
   "engines": {

package/tools/dist/dafny-emit.js

@@ -1583,10 +1583,8 @@ export function emitDafnyFile(file, tsFileName, opts) {
     // skipped when the corresponding pure def was actually emitted.
     const emittedPureDefs = new Set();
     // Emit a decl, rolling back any preamble requirements it registered if it
-    // throws. A skipped decl must contribute neither text nor preambles — else a
-    // side-effecting `needPreamble` from a half-emitted decl leaves an unused
-    // preamble (e.g. `type Unknown` from a skipped const whose head is
-    // `unknown`-typed but whose value expr is unsupported).
+    // throws, so callers that catch an emission error never observe partial
+    // emitter state.
     const emitDeclTx = (d) => {
         const saved = new Set(_neededPreambles);
         try {
@@ -1601,13 +1599,12 @@ export function emitDafnyFile(file, tsFileName, opts) {
     };
     // Emit declarations
     const declLines = [];
-    const skipped = [];
     for (const decl of file.decls) {
         if (decl.kind === "method" && emittedPureDefs.has(decl.name))
             continue;
         if (decl.kind === "namespace") {
-            // Emit each inner decl individually — if one fails, the rest survive
-            // and failed defs fall back to their method wrappers
+            // Emit each inner declaration separately so failures name the exact
+            // pure declaration that could not be translated.
             for (const inner of decl.decls) {
                 try {
                     declLines.push("");
@@ -1617,10 +1614,9 @@ export function emitDafnyFile(file, tsFileName, opts) {
                 }
                 catch (e) {
                     const name = "name" in inner ? inner.name : "unknown";
-                    const msg = e.message;
-                    console.error(`WARNING: skipping pure '${name}': ${msg}`);
-                    declLines.push(`\n// LemmaScript: skipped pure ${name}`);
-                    skipped.push(name);
+                    const reason = e instanceof Error ? e.message : String(e);
+                    const source = tsFileName ? ` in ${tsFileName}` : "";
+                    throw new Error(`Dafny emission failed for '${name}'${source}: ${reason}`);
                 }
             }
             continue;
@@ -1633,15 +1629,11 @@ export function emitDafnyFile(file, tsFileName, opts) {
         }
         catch (e) {
             const name = "name" in decl ? decl.name : "unknown";
-            const msg = e.message;
-            console.error(`WARNING: skipping '${name}': ${msg}`);
-            declLines.push(`// LemmaScript: skipped ${name}`);
-            skipped.push(name);
+            const reason = e instanceof Error ? e.message : String(e);
+            const source = tsFileName ? ` in ${tsFileName}` : "";
+            throw new Error(`Dafny emission failed for '${name}'${source}: ${reason}`);
         }
     }
-    if (skipped.length > 0) {
-        console.error(`WARNING: ${skipped.length} declaration(s) skipped: ${skipped.join(", ")}`);
-    }
     // Build output with needed preambles
     const lines = [];
     if (tsFileName)

package/tools/dist/extract.js

@@ -2028,6 +2028,17 @@ export function extractModule(sourceFile) {
     // here), deduped by qualified name.
     _externs.clear();
     _externSigTypes.length = 0;
+    // Match a `//@ <kw>` directive only as the first non-whitespace on a line,
+    // so prose mentioning an annotation does not activate it.
+    function hasLineDirective(text, kw) {
+        return new RegExp(String.raw `^[ \t]*//@ ${kw}\b`, "m").test(text);
+    }
+    // Declaration-level directives must be attached as leading comments. Do
+    // not scan a function's whole body: a statement-level `//@ skip` inside it
+    // must not omit the enclosing function.
+    function hasLeadingDirective(node, kw) {
+        return node.getLeadingCommentRanges().some(r => hasLineDirective(r.getText(), kw));
+    }
     // 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.
@@ -2124,6 +2135,8 @@ export function extractModule(sourceFile) {
     const constants = [];
     for (const stmt of sourceFile.getStatements()) {
         if (Node.isVariableStatement(stmt)) {
+            if (hasLeadingDirective(stmt, "skip"))
+                continue;
             for (const decl of stmt.getDeclarationList().getDeclarations()) {
                 if (stmt.getDeclarationList().getFlags() & 2 /* const */) {
                     const init = decl.getInitializer();
@@ -2145,7 +2158,8 @@ export function extractModule(sourceFile) {
                             });
                         }
                         catch (e) {
-                            console.error(`WARNING: skipping const '${decl.getName()}': ${e.message}`);
+                            const reason = e instanceof Error ? e.message : String(e);
+                            throw new Error(`Failed to extract const '${decl.getName()}' at ${sourceFile.getBaseName()}:${decl.getStartLineNumber()}: ${reason}`);
                         }
                     }
                 }
@@ -2206,11 +2220,9 @@ export function extractModule(sourceFile) {
     // regex — but its callers should still be verifiable against an
     // uninterpreted predicate. Parallel to auto-extern for cross-file calls,
     // and emitted the same way (`function {:axiom} foo(...)` in Dafny).
-    // Match a `//@ <kw>` directive only as the first non-whitespace on a line, so
-    // a mention mid-line in prose or inside a block/JSDoc comment (e.g. "the
-    // `//@ extern` annotation", or ` * //@ extern`) doesn't falsely trigger it.
-    function hasLineDirective(text, kw) {
-        return new RegExp(String.raw `^[ \t]*//@ ${kw}\b`, "m").test(text);
+    function hasSkip(f) {
+        return hasLeadingDirective(f.parentStmt ?? f.node, "skip")
+            || (!!f.parentStmt && hasLeadingDirective(f.node, "skip"));
     }
     function hasExtern(f) {
         if (hasLineDirective(f.node.getFullText(), "extern"))
@@ -2243,7 +2255,7 @@ export function extractModule(sourceFile) {
         return null;
     }
     for (const f of allFns) {
-        if (!hasExtern(f))
+        if (hasSkip(f) || !hasExtern(f))
             continue;
         const qualified = externName(f) ?? f.name;
         const flat = qualified.replace(/\./g, "_");
@@ -2280,8 +2292,9 @@ export function extractModule(sourceFile) {
         }
         return false;
     }
-    const hasVerifyDirective = hasLineDirective(sourceFile.getFullText(), "verify");
-    const nonExternFns = allFns.filter(f => !hasExtern(f));
+    const nonExternFns = allFns.filter(f => !hasSkip(f) && !hasExtern(f));
+    const hasVerifiedClassMethod = sourceFile.getClasses().some(cls => !hasLeadingDirective(cls, "skip") && cls.getMethods().some(method => !hasLeadingDirective(method, "skip") && hasLineDirective(method.getFullText(), "verify")));
+    const hasVerifyDirective = nonExternFns.some(hasVerify) || hasVerifiedClassMethod;
     const fnsToExtract = hasVerifyDirective ? nonExternFns.filter(hasVerify) : nonExternFns;
     // `//@ autohavoc` — enable the auto-havoc abstraction (see autohavoc.ts).
     // File-level: a directive at column 0 (top of file) enables it for every
@@ -2795,8 +2808,12 @@ export function extractModule(sourceFile) {
     // Extract classes with //@ verify methods
     const classes = [];
     for (const cls of sourceFile.getClasses()) {
+        if (hasLeadingDirective(cls, "skip"))
+            continue;
         const methods = [];
         for (const method of cls.getMethods()) {
+            if (hasLeadingDirective(method, "skip"))
+                continue;
             if (!method.getFullText().includes('//@ verify'))
                 continue;
             methods.push(extractFunction(method));

package/tools/dist/lsc.js

@@ -337,4 +337,10 @@ function runFile(cmd, filePath, backend, timeLimit, extraFlags, noVerify = false
     console.error(`Unknown command: ${cmd}`);
     process.exit(1);
 }
-main();
+try {
+    main();
+}
+catch (e) {
+    console.error(`ERROR: ${e instanceof Error ? e.message : String(e)}`);
+    process.exitCode = 1;
+}

package/tools/dist/specparser.js

@@ -4,11 +4,11 @@
  */
 import { normalizeBigIntLiteral } from "./rawir.js";
 const MULTI_OPS = ["<==>", "==>", "===", "!==", "==", "!=", ">=", "<=", "&&", "||"];
-/** Hex / binary / octal / decimal integer, with optional numeric separators and
- *  an optional `n` (BigInt) suffix in capture group 1. Deliberately integer-only:
- *  a trailing `.` is left for the tokenizer to emit as punctuation, exactly as
- *  the previous digit-scanning loop did. */
-const INTEGER_LITERAL = /^(?:(?:0[xX][0-9a-fA-F](?:_?[0-9a-fA-F])*)|(?:0[bB][01](?:_?[01])*)|(?:0[oO][0-7](?:_?[0-7])*)|(?:[0-9](?:_?[0-9])*))(n)?/;
+/** Numeric literals accepted in specs. BigInts are recognized first so their
+ *  exact value never passes through Number; ordinary numbers additionally
+ *  allow TypeScript's fractional and exponent forms. */
+const BIGINT_LITERAL = /^(?:(?:0[xX][0-9a-fA-F](?:_?[0-9a-fA-F])*)|(?:0[bB][01](?:_?[01])*)|(?:0[oO][0-7](?:_?[0-7])*)|(?:[0-9](?:_?[0-9])*))n/;
+const NUMBER_LITERAL = /^(?:(?:0[xX][0-9a-fA-F](?:_?[0-9a-fA-F])*)|(?:0[bB][01](?:_?[01])*)|(?:0[oO][0-7](?:_?[0-7])*)|(?:(?:[0-9](?:_?[0-9])*)(?:\.(?:[0-9](?:_?[0-9])*)?)?|\.(?:[0-9](?:_?[0-9])*))(?:[eE][+-]?(?:[0-9](?:_?[0-9])*))?)/;
 function tokenize(input) {
     const tokens = [];
     let i = 0;
@@ -47,15 +47,17 @@ function tokenize(input) {
             tokens.push({ type: "str", value: s });
             continue;
         }
-        if (/[0-9]/.test(input[i])) {
-            const match = input.slice(i).match(INTEGER_LITERAL);
+        if (/[0-9]/.test(input[i]) || (input[i] === "." && /[0-9]/.test(input[i + 1]))) {
+            const rest = input.slice(i);
+            const bigintMatch = rest.match(BIGINT_LITERAL);
+            const match = bigintMatch ?? rest.match(NUMBER_LITERAL);
             if (!match)
                 throw new Error(`Invalid numeric literal at ${i} in: ${input}`);
             const text = match[0];
             i += text.length;
             // The `n` suffix is meaningful, not noise: a BigInt keeps its exact value
             // as a decimal string instead of being rounded into a double.
-            if (match[1] === "n")
+            if (bigintMatch)
                 tokens.push({ type: "bigint", value: normalizeBigIntLiteral(text) });
             else
                 tokens.push({ type: "num", value: Number(text.replace(/_/g, "")) });

package/tools/dist/transform.js

@@ -2525,7 +2525,8 @@ export function transformModule(mod, specImport, moduleBaseOverride) {
         };
     });
     // Def file: Velvet methods
-    // Pure functions get a thin wrapper that calls Pure.fnName
+    // Pure functions get a thin wrapper. Lean keeps pure definitions in the
+    // `Pure` namespace; Dafny flattens that namespace, so its call is unqualified.
     // def-by-method functions also skip their method wrappers
     const pureDefNames = new Set([...pureDefs.map(d => d.name), ...defByMethods.map(d => d.name)]);
     const methods = mod.functions.map(fn => {
@@ -2539,7 +2540,7 @@ export function transformModule(mod, specImport, moduleBaseOverride) {
         }
         _forofCounters.clear();
         let body = pureDefNames.has(fn.name)
-            ? [{ kind: "return", value: { kind: "app", fn: `Pure.${fn.name}`, args: fn.params.map(p => ({ kind: "var", name: p.name })) } }]
+            ? [{ kind: "return", value: { kind: "app", fn: _opts.backend === "lean" ? `Pure.${fn.name}` : fn.name, args: fn.params.map(p => ({ kind: "var", name: p.name })) } }]
             : promoteAssignedLets(transformStmts(fn.body, mod.typeDecls));
         // Lean-only method-body rewrites (Velvet can't WP-synthesize monadic matches
         // and forbids `return` in loops):