lemmascript 0.5.21 → 0.5.22

package/package.json

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

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();
@@ -2206,11 +2219,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 +2254,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 +2291,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 +2807,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/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):