tla-ts 0.0.1 → 0.0.3-dev.a50fc89

package/src/tlc-module.ts

@@ -1,34 +1,40 @@
-import { TlaEvaluationError } from "./errors";
+import { TlaModuleError } from "./errors";
+import { EXIT_STATUS } from "./exit-codes";
 import type { Builtin } from "./evaluate";
+import { prettyPrint } from "./pretty-print";
 import {
   defineConstant,
   defineHigherOrderOperator,
   defineOperator,
   defineStateOperator,
   getElements,
+  getEnumerableSet,
+  getFunction,
   getOperator,
   getSequence,
   getValue,
 } from "./builtins";
 import { getNamedRegisters, NAMED_REGISTER_PREFIX, type CheckerRuntime } from "./runtime";
+import { createActionRecord } from "./tlc-ext";
+import { getRandomElement } from "./tlc-random";
 import {
+  ANY_SET,
   createFunction,
   createRecord,
   createSet,
   createTuple,
+  createWrittenFunction,
   formatValue,
-  toFiniteFunction,
+  getWrittenPairs,
+  toFiniteSet,
   type Value,
+  rankString,
 } from "./values";
 
-const createLocationRecord = () =>
-  createRecord([
-    ["beginLine", 0],
-    ["beginColumn", 0],
-    ["endLine", 0],
-    ["endColumn", 0],
-    ["module", "--unknown--"],
-  ]);
+const padTime = (value: number) => String(value).padStart(2, "0");
+
+const formatCalendarVersion = (date: Date) =>
+  `${date.getUTCFullYear()}.${padTime(date.getUTCMonth() + 1)}.${padTime(date.getUTCDate())}.${padTime(date.getUTCHours())}${padTime(date.getUTCMinutes())}${padTime(date.getUTCSeconds())}`;
 
 const getRegisterFunction = <Key extends Value>(registers: Map<Key, Value>) =>
   createFunction([...registers].map(([key, value]): [Value, Value] => [key, createTuple([value])]));
@@ -37,7 +43,7 @@ const getRuntimeValue = (
   runtime: CheckerRuntime,
   key: string,
   state: (Value | undefined)[] | undefined,
-): Value => {
+) => {
   const duration = Math.floor((Date.now() - runtime.startedAt) / 1000);
   switch (key) {
     case "level":
@@ -67,23 +73,24 @@ const getRuntimeValue = (
         ["mode", "bfs"],
         ["deadlock", runtime.checkDeadlock],
         ["worker", 1],
-        ["seed", "0"],
+        ["seed", String(runtime.seed)],
         ["fingerprint", "0"],
-        ["install", ""],
+        ["install", "unknown"],
       ]);
-    case "revision":
+    case "revision": {
+      const now = new Date();
       return createRecord([
         ["count", 0],
-        ["timestamp", 0],
-        ["date", "1970-01-01T00:00:00.0Z"],
-        ["tag", "tla-ts"],
-        ["calver", "0"],
+        ["timestamp", Math.floor(now.getTime() / 1000)],
+        ["date", rankString(`${now.toISOString().slice(0, 19)}.${now.getUTCMilliseconds()}Z`)],
+        ["tag", "development"],
+        ["calver", rankString(formatCalendarVersion(new Date(runtime.startedAt)))],
       ]);
+    }
+    case "spec":
+      return runtime.getSpecification();
     case "action":
-      return createRecord([
-        ["name", "UnnamedAction"],
-        ["location", createLocationRecord()],
-      ]);
+      return createActionRecord(undefined);
     case "all":
       return getRegisterFunction(runtime.registers);
     case "all:named":
@@ -91,11 +98,11 @@ const getRuntimeValue = (
   }
   if (key.startsWith(NAMED_REGISTER_PREFIX)) {
     const value = getNamedRegisters(runtime).get(key);
-    if (value === undefined) throw new TlaEvaluationError(`TLCGet(${key}) was undefined.`);
+    if (value === undefined) throw new TlaModuleError(`TLCGet(${key}) was undefined.`);
     return value;
   }
-  if (key.startsWith("-D")) return runtime.properties.get(key.slice(2)) ?? key;
-  throw new TlaEvaluationError(`TLCGet(${key}) was undefined.`);
+  if (key.startsWith("-D")) return rankString(runtime.properties.get(key.slice(2)) ?? key);
+  throw new TlaModuleError(`TLCGet(${key}) was undefined.`);
 };
 
 const getPermutations = (elements: Value[]): Value[][] =>
@@ -108,24 +115,34 @@ const getPermutations = (elements: Value[]): Value[][] =>
         ]),
       );
 
+// TLC sorts the value of a TLCEval argument that it caches, with every value inside it.
+const normalizeDeeply = (value: Value): void => {
+  if (typeof value !== "object") return;
+  if (value.kind === "Set" || value.kind === "MixedSet") {
+    toFiniteSet(value).elements.forEach(normalizeDeeply);
+  }
+  if (value.kind === "Function") value.range.forEach(normalizeDeeply);
+};
+
 export const createTlcOperators = (
   print: (text: string) => void,
   runtime: CheckerRuntime,
 ): Builtin[] => [
   defineOperator("Print", 2, (args) => {
     print(
-      `${formatValue(getValue(args, 0, "Print"), true)}  ${formatValue(getValue(args, 1, "Print"), true)}`,
+      `${prettyPrint(formatValue(getValue(args, 0, "Print"), true, true))}  ${prettyPrint(formatValue(getValue(args, 1, "Print"), true, true))}`,
     );
     return getValue(args, 1, "Print");
   }),
   defineOperator("PrintT", 1, (args) => {
-    print(formatValue(getValue(args, 0, "PrintT"), true));
+    print(prettyPrint(formatValue(getValue(args, 0, "PrintT"), true, true)));
     return true;
   }),
   defineOperator("Assert", 2, (args) => {
     if (getValue(args, 0, "Assert") !== true) {
-      throw new TlaEvaluationError(
-        `The first argument of Assert evaluated to FALSE; the second argument was:\n${formatValue(getValue(args, 1, "Assert"))}`,
+      throw new TlaModuleError(
+        `The first argument of Assert evaluated to FALSE; the second argument was:\n${prettyPrint(formatValue(getValue(args, 1, "Assert")))}`,
+        EXIT_STATUS.assertViolation,
       );
     }
     return true;
@@ -135,15 +152,18 @@ export const createTlcOperators = (
     createFunction([[getValue(args, 0, ":>"), getValue(args, 1, ":>")]]),
   ),
   defineOperator("@@", 2, (args) => {
-    const left = toFiniteFunction(getValue(args, 0, "@@"));
-    const right = toFiniteFunction(getValue(args, 1, "@@"));
-    return createFunction([
-      ...left.domain.map((key, index): [Value, Value] => [key, left.range[index]]),
-      ...right.domain.map((key, index): [Value, Value] => [key, right.range[index]]),
-    ]);
+    const left = getFunction(args, 0, "@@");
+    const right = getFunction(args, 1, "@@");
+    return createWrittenFunction([...getWrittenPairs(left), ...getWrittenPairs(right)]);
+  }),
+  defineOperator("ToString", 1, (args) =>
+    rankString(formatValue(getValue(args, 0, "ToString"), true)),
+  ),
+  defineOperator("TLCEval", 1, (args) => {
+    const value = getValue(args, 0, "TLCEval");
+    normalizeDeeply(value);
+    return value;
   }),
-  defineOperator("ToString", 1, (args) => formatValue(getValue(args, 0, "ToString"))),
-  defineOperator("TLCEval", 1, (args) => getValue(args, 0, "TLCEval")),
   defineOperator("Permutations", 1, (args) => {
     const elements = getElements(args, 0, "Permutations");
     return createSet(
@@ -171,11 +191,11 @@ export const createTlcOperators = (
     const key = getValue(args, 0, "TLCGet");
     if (typeof key === "number" && key >= 0) {
       const value = runtime.registers.get(key);
-      if (value === undefined) throw new TlaEvaluationError(`TLCGet(${key}) was undefined.`);
+      if (value === undefined) throw new TlaModuleError(`TLCGet(${key}) was undefined.`);
       return value;
     }
     if (typeof key !== "string") {
-      throw new TlaEvaluationError(
+      throw new TlaModuleError(
         `The argument of TLCGet should be a nonnegative integer, but instead it is:\n${formatValue(key)}`,
       );
     }
@@ -192,7 +212,13 @@ export const createTlcOperators = (
       if (value === true) runtime.isStopped = true;
       return true;
     }
-    if (key === "pause") return true;
+    if (key === "pause") {
+      if (value === true) {
+        print("Press enter to resume model checking.");
+        runtime.pause();
+      }
+      return true;
+    }
     if (typeof key === "string" && key.startsWith(NAMED_REGISTER_PREFIX)) {
       runtime.namedRegisters.set(key, value);
       return true;
@@ -201,14 +227,12 @@ export const createTlcOperators = (
       runtime.properties.set(key.slice(2), formatValue(value));
       return true;
     }
-    throw new TlaEvaluationError(
+    throw new TlaModuleError(
       `The first argument of TLCSet should be a nonnegative integer, but instead it is:\n${formatValue(key)}`,
     );
   }),
-  defineConstant("Any", { kind: "InfiniteSet", name: "Any" }),
-  defineOperator("RandomElement", 1, (args) => {
-    const elements = getElements(args, 0, "RandomElement");
-    if (elements.length === 0) throw new TlaEvaluationError("RandomElement of the empty set");
-    return elements[Math.floor(runtime.random() * elements.length)];
-  }),
+  defineConstant("Any", ANY_SET),
+  defineOperator("RandomElement", 1, (args) =>
+    getRandomElement(getEnumerableSet(args, 0, "RandomElement"), runtime.getRandom()),
+  ),
 ];