lemmascript 0.5.14 → 0.5.15

package/package.json

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

package/tools/dist/dafny-emit.js

@@ -1083,22 +1083,39 @@ const SEQ_SORT_BY = `function {:axiom} SeqSortBy<T(==,!new)>(s: seq<T>, cmp: (T,
   ensures multiset(SeqSortBy(s, cmp)) == multiset(s)
   ensures |SeqSortBy(s, cmp)| == |s|
   ensures forall i: int, j: int :: 0 <= i <= j < |SeqSortBy(s, cmp)| ==> cmp(SeqSortBy(s, cmp)[i], SeqSortBy(s, cmp)[j]) <= 0`;
-const STRING_TRIM = `function StringTrimLeft(s: string): string
+// TS/JS String.prototype.trim() strips ECMAScript WhiteSpace ∪ LineTerminator:
+// Unicode general-category Zs plus TAB/VT/FF/CR/LF, LS/PS, and the BOM — NOT just
+// U+0020, and NOT U+0085 (NEL, which is Cc). See
+// https://tc39.es/ecma262/#sec-white-space and
+// https://tc39.es/ecma262/#sec-line-terminators.
+// `\\U{..}` are Dafny char escapes (not JS: the string
+// is emitted verbatim), so the enumeration below is Dafny source, not decoded.
+const STRING_TRIM = `predicate IsJSWhitespace(c: char)
+{
+  c == '\\U{0009}' || c == '\\U{000A}' || c == '\\U{000B}' || c == '\\U{000C}' || c == '\\U{000D}' ||
+  c == '\\U{0020}' || c == '\\U{00A0}' || c == '\\U{1680}' ||
+  ('\\U{2000}' <= c <= '\\U{200A}') ||
+  c == '\\U{2028}' || c == '\\U{2029}' || c == '\\U{202F}' || c == '\\U{205F}' ||
+  c == '\\U{3000}' || c == '\\U{FEFF}'
+}
+
+function StringTrimLeft(s: string): string
   ensures |StringTrimLeft(s)| <= |s|
-  ensures StringTrimLeft(s) == "" || (|StringTrimLeft(s)| > 0 && StringTrimLeft(s)[0] != ' ')
+  ensures StringTrimLeft(s) == "" || (|StringTrimLeft(s)| > 0 && !IsJSWhitespace(StringTrimLeft(s)[0]))
   decreases |s|
 {
   if |s| == 0 then ""
-  else if s[0] == ' ' then StringTrimLeft(s[1..])
+  else if IsJSWhitespace(s[0]) then StringTrimLeft(s[1..])
   else s
 }
 
 function StringTrimRight(s: string): string
   ensures |StringTrimRight(s)| <= |s|
+  ensures StringTrimRight(s) == "" || (|StringTrimRight(s)| > 0 && !IsJSWhitespace(StringTrimRight(s)[|StringTrimRight(s)|-1]))
   decreases |s|
 {
   if |s| == 0 then ""
-  else if s[|s|-1] == ' ' then StringTrimRight(s[..|s|-1])
+  else if IsJSWhitespace(s[|s|-1]) then StringTrimRight(s[..|s|-1])
   else s
 }
 

package/tools/dist/lean-emit.js

@@ -1,6 +1,8 @@
 /**
- * Lean emitter — IR → Lean text.
- * No logic, no type decisions — just serialization.
+ * Lean emitter — IR → Lean text. Beyond serialization it makes type-driven
+ * decisions: Bool-vs-Prop connectives, dropping Repr/DecidableEq for
+ * opaque-tainted types, discriminator/destructor lowering, method dispatch,
+ * and support-import selection.
  */
 import { anyExpr, usesNameInDecl, patternBinders } from "./ir.js";
 import { freshName } from "./names.js";
@@ -760,6 +762,20 @@ function emitPureExpr(e, indent) {
     }
 }
 // ── File emission ────────────────────────────────────────────
+/** Reset per-module emitter state. Call once per module before the types file
+ *  (not between types and def — the def file reads the types file's registries). */
+export function resetLeanModule() {
+    _resultName = "res";
+    _unionCtors.clear();
+    _opaqueNames.clear();
+    _opaqueNames.add("Unknown");
+    _typeRefs.clear();
+    _taintedTypes.clear();
+    _needsJSString = false;
+    _needsUnknown = false;
+    _unknownEmitted = false;
+    _boolCtx = false;
+}
 export function emitLeanFile(file) {
     _needsJSString = false;
     _needsUnknown = false;

package/tools/dist/lsc.js

@@ -15,7 +15,7 @@ import { narrowModule } from "./narrow.js";
 import { autoHavocModule } from "./autohavoc.js";
 import { transformModuleLean, transformModuleDafny } from "./transform.js";
 import { peepholeModule } from "./peephole.js";
-import { emitLeanFile } from "./lean-emit.js";
+import { emitLeanFile, resetLeanModule } from "./lean-emit.js";
 import { emitDafnyFile } from "./dafny-emit.js";
 import { dafnyGen, dafnyCheckDiff, dafnyVerify, dafnyRegen } from "./dafny-commands.js";
 import { leanGen, leanCheck } from "./lean-commands.js";
@@ -261,6 +261,7 @@ function runFile(cmd, filePath, backend, timeLimit, extraFlags) {
     if (typesFile)
         typesFile = peepholeModule(typesFile, "lean");
     defFile = peepholeModule(defFile, "lean");
+    resetLeanModule(); // clear per-module emitter state so batch mode doesn't leak into this module
     const typesPath = typesFile ? path.join(dir, `${leanBase}.types.lean`) : null;
     const typesText = typesFile ? emitLeanFile(typesFile) : null;
     const defPath = path.join(dir, `${leanBase}.def.lean`);