tla-ts 0.0.10-dev.c92e6a4ea → 0.0.10-dev.d166e0ae9

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (235) hide show
  1. package/dist/compile.cjs +3 -3
  2. package/dist/compile.js +1 -1
  3. package/dist/deciders.cjs +36 -36
  4. package/dist/deciders.js +54 -54
  5. package/dist/index.cjs +1 -1
  6. package/dist/index.d.cts +13 -3
  7. package/dist/index.d.ts +13 -3
  8. package/dist/index.js +1 -1
  9. package/dist/parallel-worker.cjs +1 -1
  10. package/dist/parallel-worker.js +1 -1
  11. package/dist/prove-worker.cjs +1 -1
  12. package/dist/prove-worker.js +1 -1
  13. package/dist/prove.cjs +68 -68
  14. package/dist/prove.js +78 -78
  15. package/dist/run.cjs +42 -42
  16. package/dist/run.js +44 -44
  17. package/dist/tlapm.cjs +1 -1
  18. package/dist/tlapm.js +2 -2
  19. package/dist/transfer.cjs +45 -43
  20. package/dist/transfer.js +45 -43
  21. package/dist/worker.cjs +7 -7
  22. package/dist/worker.js +7 -7
  23. package/package.json +1 -1
  24. package/src/ast.ts +11 -1
  25. package/src/bags.ts +50 -29
  26. package/src/builtins.ts +4 -3
  27. package/src/check-failure.ts +9 -6
  28. package/src/check-trace.ts +116 -64
  29. package/src/check.ts +356 -173
  30. package/src/cli/tlc-output.ts +1 -0
  31. package/src/cli/tlc.ts +4 -3
  32. package/src/cli/xml-exporter.ts +1 -1
  33. package/src/codegen.ts +34 -13
  34. package/src/coverage.ts +3 -0
  35. package/src/dependencies.ts +61 -13
  36. package/src/dfid.ts +22 -10
  37. package/src/environment.ts +71 -35
  38. package/src/errors.ts +7 -0
  39. package/src/evaluate.ts +149 -54
  40. package/src/exit-codes.ts +29 -15
  41. package/src/instances.ts +16 -6
  42. package/src/java-hash.ts +14 -0
  43. package/src/java-overrides.ts +2 -2
  44. package/src/levels.ts +186 -97
  45. package/src/liveness-checker.ts +131 -83
  46. package/src/liveness.ts +52 -11
  47. package/src/obligations/index.ts +1 -1
  48. package/src/obligations/normalize.ts +1 -4
  49. package/src/obligations/printer.ts +5 -5
  50. package/src/obligations/source.ts +2 -0
  51. package/src/parser.ts +115 -145
  52. package/src/prover/isabelle/isar/attrib.ts +4 -4
  53. package/src/prover/isabelle/isar/rule-cases.ts +8 -6
  54. package/src/prover/isabelle/provers/clasimp.ts +1 -1
  55. package/src/prover/isabelle/provers/hypsubst.ts +2 -2
  56. package/src/prover/isabelle/pure/rewriter.ts +3 -3
  57. package/src/prover/isabelle/pure/term.ts +3 -3
  58. package/src/prover/prep/md5.ts +26 -29
  59. package/src/prover/smt/rewrite.ts +2 -7
  60. package/src/prover/smt/simplify.ts +1 -1
  61. package/src/prover/smt/solver/arith-rewriter.ts +11 -3
  62. package/src/prover/smt/solver/array-rewriter.ts +12 -2
  63. package/src/prover/smt/solver/asserted-formulas.ts +169 -58
  64. package/src/prover/smt/solver/ast-lt.ts +1 -1
  65. package/src/prover/smt/solver/ast.ts +63 -14
  66. package/src/prover/smt/solver/auf-solver.ts +23 -12
  67. package/src/prover/smt/solver/bit-blast-tactic.ts +26 -0
  68. package/src/prover/smt/solver/blast-term-ite.ts +47 -0
  69. package/src/prover/smt/solver/bound-simplifier.ts +11 -13
  70. package/src/prover/smt/solver/bv-decl-plugin.ts +13 -10
  71. package/src/prover/smt/solver/bv-rewriter.ts +1 -1
  72. package/src/prover/smt/solver/card2bv.ts +35 -18
  73. package/src/prover/smt/solver/cofactor-elim-term-ite.ts +39 -24
  74. package/src/prover/smt/solver/context.ts +67 -13
  75. package/src/prover/smt/solver/ctx-simplify.ts +1 -2
  76. package/src/prover/smt/solver/datatype-decl-plugin.ts +15 -7
  77. package/src/prover/smt/solver/dependent-expr-state.ts +26 -15
  78. package/src/prover/smt/solver/diff-neq.ts +1 -2
  79. package/src/prover/smt/solver/dt2bv-tactic.ts +36 -20
  80. package/src/prover/smt/solver/elim-bounds.ts +89 -0
  81. package/src/prover/smt/solver/elim-term-ite-tactic.ts +48 -0
  82. package/src/prover/smt/solver/elim-uncnstr.ts +5 -8
  83. package/src/prover/smt/solver/euf/arith-internalize.ts +1 -1
  84. package/src/prover/smt/solver/euf/array-internalize.ts +1 -1
  85. package/src/prover/smt/solver/euf/bv-internalize.ts +1 -1
  86. package/src/prover/smt/solver/euf/egraph.ts +4 -11
  87. package/src/prover/smt/solver/euf/euf-solver.ts +1 -2
  88. package/src/prover/smt/solver/euf/mam.ts +1 -5
  89. package/src/prover/smt/solver/euf/q-ematch.ts +1 -2
  90. package/src/prover/smt/solver/euf/th-solver.ts +0 -7
  91. package/src/prover/smt/solver/expr2polynomial.ts +204 -79
  92. package/src/prover/smt/solver/factor.ts +36 -14
  93. package/src/prover/smt/solver/fd-solver.ts +148 -39
  94. package/src/prover/smt/solver/fix-dl-var.ts +1 -2
  95. package/src/prover/smt/solver/fpa-rewriter.ts +1 -2
  96. package/src/prover/smt/solver/fpa2bv-converter.ts +3 -1
  97. package/src/prover/smt/solver/fpa2bv-rewriter.ts +1 -0
  98. package/src/prover/smt/solver/goal.ts +6 -3
  99. package/src/prover/smt/solver/goal2nlsat.ts +57 -30
  100. package/src/prover/smt/solver/hashtable.ts +4 -0
  101. package/src/prover/smt/solver/internalizer.ts +1 -1
  102. package/src/prover/smt/solver/logic-tactics.ts +9 -2
  103. package/src/prover/smt/solver/lp/lp-settings.ts +5 -1
  104. package/src/prover/smt/solver/lp/nla-core.ts +1 -1
  105. package/src/prover/smt/solver/lp/nla-grobner.ts +2 -2
  106. package/src/prover/smt/solver/lp/nra-solver.ts +45 -39
  107. package/src/prover/smt/solver/lp/pdd.ts +2 -3
  108. package/src/prover/smt/solver/lp/union-find.ts +1 -1
  109. package/src/prover/smt/solver/mam-compiler.ts +1 -1
  110. package/src/prover/smt/solver/maxcore.ts +2 -1
  111. package/src/prover/smt/solver/maxsmt-base.ts +1 -0
  112. package/src/prover/smt/solver/model-based-opt.ts +1 -1
  113. package/src/prover/smt/solver/model-checker.ts +1 -1
  114. package/src/prover/smt/solver/model-evaluator.ts +2 -0
  115. package/src/prover/smt/solver/model-generator.ts +85 -43
  116. package/src/prover/smt/solver/mpf.ts +2 -4
  117. package/src/prover/smt/solver/mus.ts +2 -3
  118. package/src/prover/smt/solver/muz/dl-context.ts +22 -44
  119. package/src/prover/smt/solver/muz/dl-mk-coi-filter.ts +1 -1
  120. package/src/prover/smt/solver/muz/dl-mk-slice.ts +3 -3
  121. package/src/prover/smt/solver/muz/dl-rule.ts +8 -9
  122. package/src/prover/smt/solver/muz/hnf.ts +2 -2
  123. package/src/prover/smt/solver/muz/horn-subsume-model-converter.ts +1 -1
  124. package/src/prover/smt/solver/muz/horn-tactic.ts +15 -2
  125. package/src/prover/smt/solver/muz/rule-properties.ts +22 -0
  126. package/src/prover/smt/solver/muz/spacer-context.ts +2 -4
  127. package/src/prover/smt/solver/muz/spacer-pdr.ts +1 -0
  128. package/src/prover/smt/solver/muz/spacer-prop-solver.ts +1 -1
  129. package/src/prover/smt/solver/nlqsat.ts +1 -1
  130. package/src/prover/smt/solver/nlsat/algebraic.ts +196 -92
  131. package/src/prover/smt/solver/nlsat/atoms.ts +52 -33
  132. package/src/prover/smt/solver/nlsat/explain.ts +375 -217
  133. package/src/prover/smt/solver/nlsat/levelwise.ts +460 -240
  134. package/src/prover/smt/solver/nlsat/polynomial.ts +2366 -681
  135. package/src/prover/smt/solver/nlsat/solver.ts +74 -64
  136. package/src/prover/smt/solver/nlsat/transcendentals.ts +41 -17
  137. package/src/prover/smt/solver/nlsat/upolynomial-factorization.ts +8 -4
  138. package/src/prover/smt/solver/nlsat/upolynomial.ts +41 -18
  139. package/src/prover/smt/solver/nlsat-tactic.ts +1 -1
  140. package/src/prover/smt/solver/nnf.ts +6 -2
  141. package/src/prover/smt/solver/opt-context.ts +21 -7
  142. package/src/prover/smt/solver/opt-nlsat.ts +29 -18
  143. package/src/prover/smt/solver/opt-pareto.ts +19 -0
  144. package/src/prover/smt/solver/opt-preprocess.ts +1 -1
  145. package/src/prover/smt/solver/opt-solver.ts +10 -6
  146. package/src/prover/smt/solver/optsmt.ts +1 -1
  147. package/src/prover/smt/solver/parallel-tactic.ts +1 -1
  148. package/src/prover/smt/solver/pb-rewriter.ts +1 -4
  149. package/src/prover/smt/solver/poly-rewriter.ts +75 -18
  150. package/src/prover/smt/solver/probes.ts +88 -23
  151. package/src/prover/smt/solver/proto-model.ts +8 -8
  152. package/src/prover/smt/solver/push-app-ite.ts +37 -0
  153. package/src/prover/smt/solver/qe-arith-plugin.ts +2 -4
  154. package/src/prover/smt/solver/qe-lite.ts +2 -2
  155. package/src/prover/smt/solver/qe.ts +3 -2
  156. package/src/prover/smt/solver/qsat.ts +23 -8
  157. package/src/prover/smt/solver/quantifier-manager.ts +14 -9
  158. package/src/prover/smt/solver/recfun-decl-plugin.ts +2 -1
  159. package/src/prover/smt/solver/rewriter-tpl.ts +7 -6
  160. package/src/prover/smt/solver/rewriter.ts +31 -25
  161. package/src/prover/smt/solver/rlimit.ts +4 -0
  162. package/src/prover/smt/solver/sat/config.ts +1 -1
  163. package/src/prover/smt/solver/sat/goal2sat.ts +0 -1
  164. package/src/prover/smt/solver/sat/inc-sat-solver.ts +81 -28
  165. package/src/prover/smt/solver/sat/model-converter.ts +1 -1
  166. package/src/prover/smt/solver/sat/pb-solver.ts +1 -1
  167. package/src/prover/smt/solver/sat/sat-tactic.ts +17 -7
  168. package/src/prover/smt/solver/sat/sat2goal.ts +10 -7
  169. package/src/prover/smt/solver/sat/simplifier.ts +1 -1
  170. package/src/prover/smt/solver/sat/solver.ts +25 -47
  171. package/src/prover/smt/solver/seq-axioms.ts +20 -35
  172. package/src/prover/smt/solver/seq-decl-plugin.ts +1 -1
  173. package/src/prover/smt/solver/seq-derive.ts +2 -2
  174. package/src/prover/smt/solver/seq-eq-solver.ts +2 -2
  175. package/src/prover/smt/solver/seq-monadic.ts +7 -5
  176. package/src/prover/smt/solver/seq-re-rewriter.ts +2 -1
  177. package/src/prover/smt/solver/seq-re-util.ts +1 -1
  178. package/src/prover/smt/solver/seq-regex-bisim.ts +1 -1
  179. package/src/prover/smt/solver/seq-regex-live.ts +2 -2
  180. package/src/prover/smt/solver/seq-rewriter.ts +31 -29
  181. package/src/prover/smt/solver/seq-skolem.ts +0 -23
  182. package/src/prover/smt/solver/seq-view-witness.ts +4 -4
  183. package/src/prover/smt/solver/smt-consequences.ts +1 -1
  184. package/src/prover/smt/solver/smt-kernel.ts +48 -7
  185. package/src/prover/smt/solver/smt-setup.ts +96 -10
  186. package/src/prover/smt/solver/smtlib-parser.ts +589 -224
  187. package/src/prover/smt/solver/smtlib-script.ts +674 -195
  188. package/src/prover/smt/solver/solve-eqs.ts +36 -37
  189. package/src/prover/smt/solver/solver.ts +18 -3
  190. package/src/prover/smt/solver/tactic.ts +332 -189
  191. package/src/prover/smt/solver/theory-bv.ts +13 -3
  192. package/src/prover/smt/solver/theory-fpa.ts +1 -1
  193. package/src/prover/smt/solver/theory-lra-final-check.ts +1 -0
  194. package/src/prover/smt/solver/theory-lra-internalize.ts +2 -0
  195. package/src/prover/smt/solver/theory-lra-propagate.ts +11 -3
  196. package/src/prover/smt/solver/theory-lra.ts +1 -1
  197. package/src/prover/smt/solver/theory-pb.ts +24 -7
  198. package/src/prover/smt/solver/theory-seq-solve.ts +1 -1
  199. package/src/prover/smt/solver/theory-seq-state.ts +2 -21
  200. package/src/prover/smt/solver/tseitin-cnf.ts +1 -0
  201. package/src/prover/tlapm/cache.ts +8 -8
  202. package/src/prover/zenon/index-table.ts +5 -2
  203. package/src/prover/zenon/isar-case.ts +1 -1
  204. package/src/prover/zenon/isar.ts +2 -2
  205. package/src/prover/zenon/phrase.ts +1 -1
  206. package/src/resolve.ts +1071 -251
  207. package/src/runtime.ts +5 -1
  208. package/src/sany/builtins.ts +10 -10
  209. package/src/sany/generation.ts +2 -13
  210. package/src/sany/generator-definitions.ts +3 -1
  211. package/src/sany/generator-expressions.ts +38 -30
  212. package/src/sany/generator-proofs.ts +6 -3
  213. package/src/sany/generator.ts +2 -1
  214. package/src/sany/lexer.ts +3 -3
  215. package/src/sany/modules.ts +4 -2
  216. package/src/sany/nodes.ts +1 -1
  217. package/src/sany/selectors.ts +11 -6
  218. package/src/sany/xml.ts +2 -3
  219. package/src/search.ts +197 -117
  220. package/src/simulate.ts +165 -102
  221. package/src/spec-description.ts +8 -6
  222. package/src/standard-modules.ts +56 -22
  223. package/src/subexpressions.ts +518 -123
  224. package/src/successors.ts +10 -3
  225. package/src/symmetry.ts +2 -1
  226. package/src/tlc/jar-data.ts +10 -0
  227. package/src/tlc/messages.ts +3 -3
  228. package/src/tlc/random.ts +2 -1
  229. package/src/tlc/replay.ts +27 -14
  230. package/src/tlc/tlc-operators.ts +10 -8
  231. package/src/tlc/tlcext-operators.ts +26 -10
  232. package/src/tlc/trace-spec.ts +9 -22
  233. package/src/typed-tier.ts +44 -27
  234. package/src/typescript/types.ts +2 -2
  235. package/src/values.ts +135 -78
package/src/evaluate.ts CHANGED
@@ -26,7 +26,8 @@ import { countCoverage, getCoverageNode, runAtCoverageNode, type Coverage } from
26
26
  import { MESSAGE_CODE } from "./tlc/messages";
27
27
  import type { CheckerRuntime } from "./runtime";
28
28
  import {
29
- isConstantLevel,
29
+ isEvaluatedAtStartup,
30
+ isExpressionImpure,
30
31
  isImpureDefinition,
31
32
  isNonconstant,
32
33
  type DefinitionFacts,
@@ -152,6 +153,7 @@ export interface Environment {
152
153
  variableIndex: Map<string, number>;
153
154
  facts: DefinitionFacts;
154
155
  startupValues: (Value | undefined)[];
156
+ tlcEvalValues: WeakMap<Expression, Value>;
155
157
  substitutedDefinitions: Set<Definition>;
156
158
  instanceParams: Set<OperatorParam>;
157
159
  evaluators: WeakMap<Expression, Evaluator>;
@@ -320,15 +322,14 @@ export const getDomainOperator = (expression: Expression) => (value: Value) => {
320
322
  };
321
323
 
322
324
  export const getSubsetOperator =
323
- (expression: Expression, builtin: Builtin) => (left: Value, right: Value) => {
325
+ (expression: Expression, subset: (left: Value, right: Value) => Value) =>
326
+ (left: Value, right: Value) => {
324
327
  if (!isSetValue(left) || isOverriddenSet(left)) {
325
328
  throw new TlaEvaluationError(
326
329
  `Attempted to evaluate an expression of form S \\subseteq T, but S was not enumerable.\n${describeRange(expression)}`,
327
330
  );
328
331
  }
329
- return builtin.evaluateBinary
330
- ? builtin.evaluateBinary(left, right)
331
- : builtin.evaluate([left, right]);
332
+ return subset(left, right);
332
333
  };
333
334
 
334
335
  export const createRealNumberError = (expression: DecimalExpression) =>
@@ -523,10 +524,13 @@ const someElement = (
523
524
  return false;
524
525
  };
525
526
 
526
- export const mapBoundSets = <Result>(bounds: Bound[], map: (set: Expression) => Result) =>
527
+ export const mapBoundSets = <Result>(
528
+ bounds: Bound[],
529
+ map: (set: Expression, index: number) => Result,
530
+ ) =>
527
531
  bounds.reduce<Result[]>((results, bound, index) => {
528
532
  results.push(
529
- index > 0 && bounds[index - 1].set === bound.set ? results[index - 1] : map(bound.set),
533
+ index > 0 && bounds[index - 1].set === bound.set ? results[index - 1] : map(bound.set, index),
530
534
  );
531
535
  return results;
532
536
  }, []);
@@ -615,12 +619,16 @@ export const bindLazyArguments = (
615
619
  typeof value.domain === "object" && value.domain.kind === "ProductSet"
616
620
  ? value.domain.factors
617
621
  : [];
618
- // Deviation from TLC: FcnLambdaValue#apply indexes past an argument tuple shorter than the bounds and ignores a longer one.
622
+ if (elements === undefined) {
623
+ throw new TlaEvaluationError(
624
+ `Attempted to apply a function to an argument not in its domain.\n${describeRange(expression.function)}`,
625
+ );
626
+ }
627
+ // Deviation from TLC: Tool#getFcnContext indexes past an argument tuple shorter than the bounds and ignores a longer one.
619
628
  const createListError = () =>
620
629
  new TlaEvaluationError(
621
630
  `In applying the function\n${prettyPrint(formatValue(value))},\nthe argument list is:\n${prettyPrint(formatValue(argument))}\nwhich does not match its formal parameter.\n`,
622
631
  );
623
- if (elements === undefined) throw createListError();
624
632
  bounds.forEach((bound, index) => {
625
633
  if (index >= elements.length) throw createListError();
626
634
  const element = elements[index];
@@ -669,7 +677,7 @@ const getLazyFunctionTemplate = (bounds: Bound[], body: Expression) => {
669
677
  },
670
678
  ],
671
679
  ),
672
- body: formatRange(range),
680
+ body: describeNode(body),
673
681
  };
674
682
  };
675
683
 
@@ -817,7 +825,7 @@ export const evaluateStartupDefinitions = (definitions: Definition[], environmen
817
825
  if (definition.kind === "Operator" && definition.params.length > 0) return;
818
826
  const name = definition.name;
819
827
  if (environment.constants.has(name) || environment.substitutions.has(name)) return;
820
- if (!isConstantLevel(definition, environment)) return;
828
+ if (!isEvaluatedAtStartup(definition, environment)) return;
821
829
  const definitionId = environment.facts.ids.get(definition);
822
830
  if (definitionId === undefined || environment.startupValues[definitionId] !== undefined) return;
823
831
  const context = { environment, scope: undefined, state: undefined, next: undefined };
@@ -969,6 +977,7 @@ const isOperatorArgument = (expression: Expression, context: Context) => {
969
977
  return operator !== undefined && getArity(operator) > 0;
970
978
  };
971
979
 
980
+ // Deviation from TLC: SymbolNodeValueLookupProvider#lookup takes an operator whose body is a literal for that literal, so a Java override rejects it as an argument.
972
981
  const evaluateBuiltinArguments = (args: Expression[], context: Context) =>
973
982
  args.map((arg) =>
974
983
  isOperatorArgument(arg, context)
@@ -1318,7 +1327,6 @@ const headFingerprint = (callStack: CallStack, source: Expression, error: unknow
1318
1327
 
1319
1328
  export const createTracingEnvironment = (environment: Environment): Environment => ({
1320
1329
  ...environment,
1321
- coverage: undefined,
1322
1330
  evaluators: new WeakMap(),
1323
1331
  entryEvaluators: new WeakMap(),
1324
1332
  definitionEvaluators: new WeakMap(),
@@ -1331,6 +1339,41 @@ export const createTracingEnvironment = (environment: Environment): Environment
1331
1339
  },
1332
1340
  });
1333
1341
 
1342
+ // TLC evaluates `a /\ b /\ c` as `(a /\ b) /\ c`, so its call stack holds each prefix.
1343
+ const compileTracedJunction = (
1344
+ expression: Expression & { kind: "And" | "Or" },
1345
+ operands: Evaluator[],
1346
+ callStack: CallStack | undefined,
1347
+ ): Evaluator | undefined => {
1348
+ const range = expression.location.range;
1349
+ const prefixEnds = expression.prefixEnds;
1350
+ if (!callStack || expression.isBulleted || !range || !prefixEnds || operands.length < 3) {
1351
+ return undefined;
1352
+ }
1353
+ const prefixes = prefixEnds
1354
+ .slice(0, operands.length - 2)
1355
+ .map((end) => ({
1356
+ ...expression,
1357
+ location: { ...expression.location, range: { ...range, end } },
1358
+ }))
1359
+ .reverse();
1360
+ const isAnd = expression.kind === "And";
1361
+ return (context) => {
1362
+ callStack.expressions.push(...prefixes);
1363
+ for (let index = 0; index < operands.length; index++) {
1364
+ if (index >= 2 && !callStack.isFrozen) callStack.expressions.pop();
1365
+ const value = operands[index](context);
1366
+ if (typeof value !== "boolean") throw createJunctionError(expression, index, value);
1367
+ if (value !== isAnd) {
1368
+ if (!callStack.isFrozen)
1369
+ callStack.expressions.length -= prefixes.length - Math.max(index - 1, 0);
1370
+ return value;
1371
+ }
1372
+ }
1373
+ return isAnd;
1374
+ };
1375
+ };
1376
+
1334
1377
  const traceFrames =
1335
1378
  (
1336
1379
  expression: Expression,
@@ -1549,18 +1592,30 @@ const compileApply = (
1549
1592
  return (context) => domain(operand(context));
1550
1593
  }
1551
1594
  if (global?.kind === "Builtin" && global.name === "TLCEval" && args.length === 1) {
1595
+ // Deviation from TLC: TLCEval#tlcEval evaluates an argument SANY takes for constant, such as Print(v, TRUE), in an empty state.
1552
1596
  const isCached =
1553
1597
  !contextualApplications.has(expression) && !isNonconstant(args[0], environment);
1554
- return (context) =>
1555
- global.evaluate(
1556
- getLazyArguments(args, context),
1557
- isCached && context.scope === undefined ? undefined : context,
1558
- );
1598
+ const tlcEvalValues = environment.tlcEvalValues;
1599
+ return (context) => {
1600
+ if (!isCached || context.scope !== undefined) {
1601
+ return global.evaluate(getLazyArguments(args, context), context);
1602
+ }
1603
+ const cached = tlcEvalValues.get(expression);
1604
+ if (cached !== undefined) return cached;
1605
+ const value = global.evaluate(getLazyArguments(args, context), undefined);
1606
+ tlcEvalValues.set(expression, value);
1607
+ return value;
1608
+ };
1559
1609
  }
1560
- if (global?.kind === "Builtin" && global.name === "\\subseteq" && args.length === 2) {
1610
+ if (
1611
+ global?.kind === "Builtin" &&
1612
+ global.name === "\\subseteq" &&
1613
+ global.evaluateBinary &&
1614
+ args.length === 2
1615
+ ) {
1561
1616
  const left = getEvaluator(args[0], environment);
1562
1617
  const right = getEvaluator(args[1], environment);
1563
- const subset = getSubsetOperator(expression, global);
1618
+ const subset = getSubsetOperator(expression, global.evaluateBinary);
1564
1619
  return (context) => subset(left(context), right(context));
1565
1620
  }
1566
1621
  if (global?.kind === "Builtin") return compileBuiltinCall(global, args, environment);
@@ -1719,8 +1774,14 @@ export const getFunctionBuilder = (
1719
1774
  return markLambdaFunction(functionValue);
1720
1775
  }
1721
1776
  const pairs: [Value, Value][] = [];
1722
- const sets = mapBoundSets(bounds, (set) =>
1723
- getNormalizedElements(evaluate(set, context), set, context.environment.runtime.version),
1777
+ const sets = mapBoundSets(bounds, (set, index) =>
1778
+ getNormalizedElements(
1779
+ bounds.length > 1 && typeof domain === "object" && domain.kind === "ProductSet"
1780
+ ? domain.factors[index]
1781
+ : domain,
1782
+ set,
1783
+ context.environment.runtime.version,
1784
+ ),
1724
1785
  );
1725
1786
  forEachBoundElement(bounds, sets, context.scope, (scope) => {
1726
1787
  const key =
@@ -1866,12 +1927,11 @@ export const getLazyFilter = (
1866
1927
  ) => {
1867
1928
  const predicate = getEvaluator(expression.predicate, environment);
1868
1929
  const pattern = expression.bound.pattern;
1869
- const range = expression.predicate.location.range;
1870
- const source = range && {
1930
+ const predicateNode = describeNode(expression.predicate);
1931
+ const source = expression.predicate.location.range && {
1871
1932
  names: pattern.kind === "Name" ? pattern.name : pattern.names.join(", "),
1872
- predicate: formatRange(range),
1933
+ predicate: predicateNode,
1873
1934
  };
1874
- const predicateNode = describeNode(expression.predicate);
1875
1935
  const coverage = environment.coverage;
1876
1936
  const testCovered = (node: number, isMember: boolean, test: () => Value) => {
1877
1937
  if (!coverage || node === -1) return test();
@@ -1920,6 +1980,20 @@ export const getLazyFilter = (
1920
1980
  createFiltered(base, context, predicate, node);
1921
1981
  };
1922
1982
 
1983
+ const hasLocalName = (expression: Expression): boolean =>
1984
+ isLocallyResolved(expression) ||
1985
+ expression.kind === "OperatorReference" ||
1986
+ getChildren(expression).some(hasLocalName);
1987
+
1988
+ export const isUniformPredicate = (
1989
+ expression: Expression & { kind: "SetFilter" },
1990
+ environment: Environment,
1991
+ ) =>
1992
+ expression.bound.pattern.kind === "Name" &&
1993
+ !environment.coverage &&
1994
+ !hasLocalName(expression.predicate) &&
1995
+ !isExpressionImpure([expression.predicate], environment, "varying");
1996
+
1923
1997
  export const expectFilterPredicate = (
1924
1998
  value: Value,
1925
1999
  expression: Expression & { kind: "SetFilter" },
@@ -1962,20 +2036,21 @@ const compileSetComprehension = (
1962
2036
  const filterLazily = getLazyFilter(expression, environment);
1963
2037
  const pattern = expression.bound.pattern;
1964
2038
  const coverage = environment.coverage;
2039
+ const isUniform = isUniformPredicate(expression, environment);
1965
2040
  return (context) => {
1966
2041
  const base = set(context);
1967
2042
  if (!isReducibleSet(base)) return filterLazily(base, context, coverage?.current);
1968
2043
  const kept: Value[] = [];
1969
- const visit = (element: Value) => {
2044
+ const elements = base.kind === "Interval" ? base : toFiniteSet(base).elements;
2045
+ const size = Array.isArray(elements) ? elements.length : elements.high - elements.low + 1;
2046
+ for (let position = 0; position < size; position++) {
2047
+ const element = Array.isArray(elements) ? elements[position] : elements.low + position;
1970
2048
  const value = predicate(withScope(context, bindPattern(context.scope, pattern, element)));
1971
2049
  if (expectFilterPredicate(value, expression)) addBoundedElement(kept, element);
1972
- };
1973
- const elements = base.kind === "Interval" ? base : toFiniteSet(base).elements;
1974
- forEachElement(elements, visit);
2050
+ else if (isUniform) break;
2051
+ }
1975
2052
  if (coverage && coverage.current !== -1) {
1976
- coverage.secondary[coverage.current] +=
1977
- (Array.isArray(elements) ? elements.length : elements.high - elements.low + 1) +
1978
- kept.length;
2053
+ coverage.secondary[coverage.current] += size + kept.length;
1979
2054
  }
1980
2055
  return createNormalizedSet(kept);
1981
2056
  };
@@ -2037,20 +2112,21 @@ export const hasDuplicateFields = (sortedFields: RecordField[]) =>
2037
2112
 
2038
2113
  const compileRecord = (recordFields: RecordField[], environment: Environment): Evaluator => {
2039
2114
  const fields = getSortedFields(recordFields);
2040
- const hasDuplicates = hasDuplicateFields(fields);
2041
- const values = fields.map((field) => getEvaluator(field.value, environment));
2042
- if (hasDuplicates) {
2115
+ const values = recordFields.map((field) => getEvaluator(field.value, environment));
2116
+ if (hasDuplicateFields(fields)) {
2043
2117
  return (context) =>
2044
2118
  createRecord(
2045
- fields.map((field, index): [string, Value] => [field.name, values[index](context)]),
2119
+ recordFields.map((field, index): [string, Value] => [field.name, values[index](context)]),
2046
2120
  );
2047
2121
  }
2048
2122
  const names = fields.map((field) => field.name);
2049
2123
  const writtenNames = recordFields.map((field) => field.name);
2050
2124
  if (writtenNames.some((name, index) => name !== names[index])) {
2125
+ const writtenIndexes = fields.map((field) => recordFields.indexOf(field));
2051
2126
  return (context) =>
2052
2127
  createWrittenRecord(
2053
2128
  names,
2129
+ writtenIndexes,
2054
2130
  values.map((value) => value(context)),
2055
2131
  writtenNames,
2056
2132
  );
@@ -2100,25 +2176,31 @@ const compile = (expression: Expression, environment: Environment): Evaluator =>
2100
2176
  };
2101
2177
  case "And": {
2102
2178
  const operands = expression.operands.map(getChildEvaluator);
2103
- return (context) => {
2104
- for (let index = 0; index < operands.length; index++) {
2105
- const value = operands[index](context);
2106
- if (typeof value !== "boolean") throw createJunctionError(expression, index, value);
2107
- if (!value) return false;
2108
- }
2109
- return true;
2110
- };
2179
+ return (
2180
+ compileTracedJunction(expression, operands, environment.callStack) ??
2181
+ ((context) => {
2182
+ for (let index = 0; index < operands.length; index++) {
2183
+ const value = operands[index](context);
2184
+ if (typeof value !== "boolean") throw createJunctionError(expression, index, value);
2185
+ if (!value) return false;
2186
+ }
2187
+ return true;
2188
+ })
2189
+ );
2111
2190
  }
2112
2191
  case "Or": {
2113
2192
  const operands = expression.operands.map(getChildEvaluator);
2114
- return (context) => {
2115
- for (let index = 0; index < operands.length; index++) {
2116
- const value = operands[index](context);
2117
- if (typeof value !== "boolean") throw createJunctionError(expression, index, value);
2118
- if (value) return true;
2119
- }
2120
- return false;
2121
- };
2193
+ return (
2194
+ compileTracedJunction(expression, operands, environment.callStack) ??
2195
+ ((context) => {
2196
+ for (let index = 0; index < operands.length; index++) {
2197
+ const value = operands[index](context);
2198
+ if (typeof value !== "boolean") throw createJunctionError(expression, index, value);
2199
+ if (value) return true;
2200
+ }
2201
+ return false;
2202
+ })
2203
+ );
2122
2204
  }
2123
2205
  case "Prime": {
2124
2206
  const inner = getChildEvaluator(expression.expression);
@@ -2204,8 +2286,19 @@ const compile = (expression: Expression, environment: Environment): Evaluator =>
2204
2286
  case "RecordSet": {
2205
2287
  const fields = getSortedFields(expression.fields);
2206
2288
  const names = fields.map((field) => field.name);
2207
- const sets = fields.map((field) => getChildEvaluator(field.value));
2208
- return (context) => ({ kind: "RecordSet", names, sets: sets.map((set) => set(context)) });
2289
+ const writtenIndexes = fields.map((field) => expression.fields.indexOf(field));
2290
+ const sets = expression.fields.map((field) => getChildEvaluator(field.value));
2291
+ if (writtenIndexes.every((writtenIndex, index) => writtenIndex === index)) {
2292
+ return (context) => ({ kind: "RecordSet", names, sets: sets.map((set) => set(context)) });
2293
+ }
2294
+ return (context) => {
2295
+ const writtenSets = sets.map((set) => set(context));
2296
+ return {
2297
+ kind: "RecordSet",
2298
+ names,
2299
+ sets: writtenIndexes.map((index) => writtenSets[index]),
2300
+ };
2301
+ };
2209
2302
  }
2210
2303
  case "Except":
2211
2304
  return compileExcept(expression, environment);
@@ -2272,6 +2365,8 @@ const compile = (expression: Expression, environment: Environment): Evaluator =>
2272
2365
  }
2273
2366
  case "Label":
2274
2367
  return getChildEvaluator(expression.body);
2368
+ case "Selection":
2369
+ return getChildEvaluator(expression.expression);
2275
2370
  case "Subexpression":
2276
2371
  return () => {
2277
2372
  throw new TlaEvaluationError(
package/src/exit-codes.ts CHANGED
@@ -1,7 +1,8 @@
1
- import type { LivenessChecker } from "./liveness-checker";
1
+ import type { LivenessChecker, LivenessChecks } from "./liveness-checker";
2
2
 
3
3
  export const EXIT_STATUS = {
4
4
  success: 0,
5
+ abort: 1,
5
6
  assumptionViolation: 10,
6
7
  deadlock: 11,
7
8
  safetyViolation: 12,
@@ -17,13 +18,13 @@ export const EXIT_STATUS = {
17
18
 
18
19
  const MESSAGE_EXIT_STATUSES = new Map<number, number>([
19
20
  ...[
20
- ...Array.from({ length: 24 }, (_, index) => 2222 + index),
21
+ ...Array.from({ length: 24 }, (_value, index) => 2222 + index),
21
22
  2272,
22
23
  2273,
23
24
  2274,
24
25
  2280,
25
26
  2281,
26
- ...Array.from({ length: 7 }, (_, index) => 5001 + index),
27
+ ...Array.from({ length: 7 }, (_value, index) => 5001 + index),
27
28
  ].map((code): [number, number] => [code, EXIT_STATUS.configParseError]),
28
29
  [2253, EXIT_STATUS.livenessEvaluationFailure],
29
30
  [2109, EXIT_STATUS.specEvaluationFailure],
@@ -69,23 +70,36 @@ const withErrorExitCode = <Result>(run: () => Result) => {
69
70
  }
70
71
  };
71
72
 
73
+ const withCheckerExitCode = (checker: LivenessChecker): LivenessChecker => ({
74
+ branches: checker.branches,
75
+ solutions: checker.solutions,
76
+ addInitialState: (index, state, tracing) =>
77
+ withErrorExitCode(() => checker.addInitialState(index, state, tracing)),
78
+ addState: (index, state, successors, tracing) =>
79
+ withErrorExitCode(() => checker.addState(index, state, successors, tracing)),
80
+ storeState: checker.storeState,
81
+ getStateCounts: checker.getStateCounts,
82
+ findViolation: () => withErrorExitCode(() => checker.findViolation()),
83
+ getViolatedProperties: (path, cycleStart) =>
84
+ withErrorExitCode(() => checker.getViolatedProperties(path, cycleStart)),
85
+ });
86
+
72
87
  export const withLivenessExitCode = (
73
88
  create: () => LivenessChecker | undefined,
74
89
  ): LivenessChecker | undefined => {
75
90
  const checker = withErrorExitCode(create);
91
+ return checker && withCheckerExitCode(checker);
92
+ };
93
+
94
+ export const withLivenessChecksExitCode = (
95
+ create: () => LivenessChecks | undefined,
96
+ ): LivenessChecks | undefined => {
97
+ const checks = withErrorExitCode(create);
76
98
  return (
77
- checker && {
78
- branches: checker.branches,
79
- solutions: checker.solutions,
80
- addInitialState: (index, state, tracing) =>
81
- withErrorExitCode(() => checker.addInitialState(index, state, tracing)),
82
- addState: (index, state, successors, tracing) =>
83
- withErrorExitCode(() => checker.addState(index, state, successors, tracing)),
84
- storeState: checker.storeState,
85
- getStateCounts: checker.getStateCounts,
86
- findViolation: () => withErrorExitCode(() => checker.findViolation()),
87
- getViolatedProperties: (path, cycleStart) =>
88
- withErrorExitCode(() => checker.getViolatedProperties(path, cycleStart)),
99
+ checks && {
100
+ solutions: checks.solutions,
101
+ createChecker: (search, solutions) =>
102
+ withCheckerExitCode(checks.createChecker(search, solutions)),
89
103
  }
90
104
  );
91
105
  };
package/src/instances.ts CHANGED
@@ -219,6 +219,8 @@ export const mapChildren = (
219
219
  };
220
220
  case "Label":
221
221
  return { ...expression, body: mapUnbound(expression.body) };
222
+ case "Selection":
223
+ return { ...expression, expression: mapUnbound(expression.expression) };
222
224
  case "Subexpression":
223
225
  return {
224
226
  ...expression,
@@ -262,6 +264,7 @@ interface Rewrite {
262
264
  mode: RewriteMode;
263
265
  modes: Map<RewriteMode, Rewrite>;
264
266
  bindings?: Map<string, Expression>;
267
+ selections: Map<Expression, Expression>;
265
268
  }
266
269
 
267
270
  const getSubstitutionName = (name: string) => `${name}@SUBSTITUTION`;
@@ -522,7 +525,7 @@ const getInstanceOperator = (
522
525
  arity: number,
523
526
  location: SourceLocation,
524
527
  ): Expression => {
525
- const names = Array.from({ length: arity }, (_, index) => `argument${index}`);
528
+ const names = Array.from({ length: arity }, (_value, index) => `argument${index}`);
526
529
  return {
527
530
  kind: "Lambda",
528
531
  params: names,
@@ -548,6 +551,12 @@ const substitute = (
548
551
  bound: Map<string, string>,
549
552
  ): Expression => {
550
553
  const recurse = (node: Expression) => substitute(node, rewrite, bound);
554
+ if (expression.kind === "Selection" && [...bound].every((entry) => entry[0] === entry[1])) {
555
+ const selected = expression.expression;
556
+ const substituted = rewrite.selections.get(selected) ?? recurse(selected);
557
+ rewrite.selections.set(selected, substituted);
558
+ return { ...expression, expression: substituted };
559
+ }
551
560
  const instantiation = rewrite.instantiation;
552
561
  const params = instantiation.params;
553
562
  const isFree = (name: string) => !bound.has(name) && !isLocallyResolved(expression);
@@ -731,7 +740,7 @@ const copyDefinition = (rewrite: Rewrite, key: string): string => {
731
740
  const bindings = new Map<string, Expression>();
732
741
  const bodyRewrite =
733
742
  definition.kind === "Operator" && rewrite.mode === "Normal"
734
- ? { ...rewrite, bindings }
743
+ ? { ...rewrite, bindings, selections: new Map<Expression, Expression>() }
735
744
  : rewrite;
736
745
  const mapped = renameParams(
737
746
  mapDefinition(definition, (child, bound) =>
@@ -744,14 +753,14 @@ const copyDefinition = (rewrite: Rewrite, key: string): string => {
744
753
  ? mapped.body
745
754
  : {
746
755
  kind: "Let",
747
- definitions: [...bindings].map(([name, replacement]): Definition => ({
756
+ definitions: [...bindings].map((entry): Definition => ({
748
757
  kind: "Operator",
749
- name,
758
+ name: entry[0],
750
759
  params: [],
751
- body: replacement,
760
+ body: entry[1],
752
761
  isLocal: true,
753
762
  isRecursive: false,
754
- location: replacement.location,
763
+ location: entry[1].location,
755
764
  })),
756
765
  body: mapped.body,
757
766
  // TLC has no such LET, so the call stack it prints has no position for it.
@@ -777,6 +786,7 @@ export const createInstantiation = (instantiation: Instantiation) => {
777
786
  copies: new Map<string, string>(),
778
787
  mode,
779
788
  modes,
789
+ selections: new Map<Expression, Expression>(),
780
790
  };
781
791
  modes.set(mode, created);
782
792
  return created;
package/src/java-hash.ts CHANGED
@@ -5,3 +5,17 @@ export const getJavaHashCode = (text: string): number => {
5
5
  }
6
6
  return hash;
7
7
  };
8
+
9
+ const getHashMapHash = (text: string) => {
10
+ const hash = getJavaHashCode(text);
11
+ return hash ^ (hash >>> 16);
12
+ };
13
+
14
+ export const getHashMapOrder = (names: string[]) => {
15
+ const unique = [...new Set(names)];
16
+ const capacity = 2 ** Math.max(4, Math.ceil(Math.log2(unique.length / 0.75)));
17
+ return unique
18
+ .map((name, index) => ({ name, index, bucket: getHashMapHash(name) & (capacity - 1) }))
19
+ .sort((left, right) => left.bucket - right.bucket || left.index - right.index)
20
+ .map((entry) => entry.name);
21
+ };
@@ -184,8 +184,8 @@ const readClassFile = (bytes: Uint8Array) => {
184
184
  getJavaClassName(pool, thrown.readUint16()),
185
185
  )
186
186
  : [];
187
- const modifiers = METHOD_MODIFIERS.filter(([flag]) => (access & flag) !== 0).map(
188
- ([, modifier]) => modifier,
187
+ const modifiers = METHOD_MODIFIERS.filter((entry) => (access & entry[0]) !== 0).map(
188
+ (entry) => entry[1],
189
189
  );
190
190
  const returnType = getTypeNames(descriptor.slice(parametersEnd + 1))[0];
191
191
  const throwsClause = exceptions.length === 0 ? "" : ` throws ${exceptions.join(",")}`;