tla-ts 0.0.10-dev.37a75eb5b → 0.0.10-dev.45c0eaef5

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 (229) hide show
  1. package/dist/compile.cjs +3 -3
  2. package/dist/compile.js +1 -1
  3. package/dist/deciders.cjs +33 -33
  4. package/dist/deciders.js +53 -53
  5. package/dist/index.cjs +1 -1
  6. package/dist/index.d.cts +17 -3
  7. package/dist/index.d.ts +17 -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 +55 -55
  14. package/dist/prove.js +78 -78
  15. package/dist/run.cjs +40 -42
  16. package/dist/run.js +42 -44
  17. package/dist/tlapm.cjs +1 -1
  18. package/dist/tlapm.js +2 -2
  19. package/dist/transfer.cjs +96 -91
  20. package/dist/transfer.js +95 -90
  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 +31 -3
  25. package/src/bags.ts +12 -10
  26. package/src/builtins.ts +4 -3
  27. package/src/check-failure.ts +13 -11
  28. package/src/check-trace.ts +146 -93
  29. package/src/check.ts +418 -246
  30. package/src/cli/tlc-output.ts +17 -2
  31. package/src/cli/tlc.ts +5 -4
  32. package/src/cli/xml-exporter.ts +1 -1
  33. package/src/codegen.ts +23 -10
  34. package/src/coverage.ts +255 -18
  35. package/src/dependencies.ts +68 -15
  36. package/src/dfid.ts +93 -35
  37. package/src/environment.ts +106 -39
  38. package/src/errors.ts +7 -0
  39. package/src/evaluate.ts +415 -132
  40. package/src/exit-codes.ts +28 -15
  41. package/src/instances.ts +135 -11
  42. package/src/java-hash.ts +14 -0
  43. package/src/java-overrides.ts +2 -2
  44. package/src/levels.ts +674 -236
  45. package/src/lexer.ts +12 -2
  46. package/src/liveness-checker.ts +161 -60
  47. package/src/liveness.ts +55 -10
  48. package/src/obligations/index.ts +1 -1
  49. package/src/obligations/normalize.ts +1 -4
  50. package/src/obligations/printer.ts +5 -5
  51. package/src/obligations/source.ts +2 -0
  52. package/src/parser.ts +110 -111
  53. package/src/prover/isabelle/isar/attrib.ts +4 -4
  54. package/src/prover/isabelle/isar/rule-cases.ts +8 -6
  55. package/src/prover/isabelle/provers/clasimp.ts +1 -1
  56. package/src/prover/isabelle/provers/hypsubst.ts +2 -2
  57. package/src/prover/isabelle/pure/rewriter.ts +3 -3
  58. package/src/prover/isabelle/pure/term.ts +3 -3
  59. package/src/prover/prep/md5.ts +26 -29
  60. package/src/prover/smt/rewrite.ts +2 -7
  61. package/src/prover/smt/simplify.ts +1 -1
  62. package/src/prover/smt/solver/arith-rewriter.ts +11 -3
  63. package/src/prover/smt/solver/array-rewriter.ts +12 -2
  64. package/src/prover/smt/solver/asserted-formulas.ts +164 -58
  65. package/src/prover/smt/solver/ast-lt.ts +1 -1
  66. package/src/prover/smt/solver/ast.ts +65 -13
  67. package/src/prover/smt/solver/auf-solver.ts +23 -12
  68. package/src/prover/smt/solver/bit-blast-tactic.ts +27 -1
  69. package/src/prover/smt/solver/blast-term-ite.ts +47 -0
  70. package/src/prover/smt/solver/bound-simplifier.ts +11 -13
  71. package/src/prover/smt/solver/bv-decl-plugin.ts +13 -10
  72. package/src/prover/smt/solver/bv-rewriter.ts +1 -1
  73. package/src/prover/smt/solver/card2bv.ts +35 -18
  74. package/src/prover/smt/solver/cofactor-elim-term-ite.ts +39 -24
  75. package/src/prover/smt/solver/context.ts +65 -14
  76. package/src/prover/smt/solver/ctx-simplify.ts +1 -2
  77. package/src/prover/smt/solver/datatype-decl-plugin.ts +15 -7
  78. package/src/prover/smt/solver/dependent-expr-state.ts +28 -16
  79. package/src/prover/smt/solver/diff-neq.ts +1 -2
  80. package/src/prover/smt/solver/dt2bv-tactic.ts +57 -21
  81. package/src/prover/smt/solver/elim-bounds.ts +89 -0
  82. package/src/prover/smt/solver/elim-term-ite-tactic.ts +48 -0
  83. package/src/prover/smt/solver/elim-uncnstr.ts +5 -8
  84. package/src/prover/smt/solver/euf/arith-internalize.ts +1 -1
  85. package/src/prover/smt/solver/euf/array-internalize.ts +1 -1
  86. package/src/prover/smt/solver/euf/bv-internalize.ts +1 -1
  87. package/src/prover/smt/solver/euf/egraph.ts +3 -9
  88. package/src/prover/smt/solver/euf/euf-solver.ts +1 -2
  89. package/src/prover/smt/solver/euf/mam.ts +1 -5
  90. package/src/prover/smt/solver/euf/q-ematch.ts +1 -2
  91. package/src/prover/smt/solver/euf/th-solver.ts +0 -7
  92. package/src/prover/smt/solver/fd-solver.ts +608 -141
  93. package/src/prover/smt/solver/fix-dl-var.ts +1 -2
  94. package/src/prover/smt/solver/fpa2bv-rewriter.ts +1 -0
  95. package/src/prover/smt/solver/goal.ts +4 -3
  96. package/src/prover/smt/solver/hashtable.ts +4 -0
  97. package/src/prover/smt/solver/internalizer.ts +1 -1
  98. package/src/prover/smt/solver/logic-tactics.ts +15 -5
  99. package/src/prover/smt/solver/lp/core-solver.ts +12 -8
  100. package/src/prover/smt/solver/lp/lar-solver.ts +1 -1
  101. package/src/prover/smt/solver/lp/lp-settings.ts +6 -2
  102. package/src/prover/smt/solver/lp/nla-grobner.ts +2 -2
  103. package/src/prover/smt/solver/lp/pdd.ts +2 -3
  104. package/src/prover/smt/solver/lp/union-find.ts +1 -1
  105. package/src/prover/smt/solver/mam-compiler.ts +1 -1
  106. package/src/prover/smt/solver/maxcore.ts +2 -1
  107. package/src/prover/smt/solver/maxsmt-base.ts +1 -0
  108. package/src/prover/smt/solver/model-based-opt.ts +1 -1
  109. package/src/prover/smt/solver/model-checker.ts +1 -1
  110. package/src/prover/smt/solver/model-evaluator.ts +2 -0
  111. package/src/prover/smt/solver/model-generator.ts +85 -43
  112. package/src/prover/smt/solver/mpf.ts +2 -4
  113. package/src/prover/smt/solver/mus.ts +2 -3
  114. package/src/prover/smt/solver/muz/dl-context.ts +14 -42
  115. package/src/prover/smt/solver/muz/dl-mk-coi-filter.ts +1 -1
  116. package/src/prover/smt/solver/muz/dl-mk-slice.ts +3 -3
  117. package/src/prover/smt/solver/muz/dl-rule.ts +8 -9
  118. package/src/prover/smt/solver/muz/hnf.ts +2 -2
  119. package/src/prover/smt/solver/muz/horn-subsume-model-converter.ts +1 -1
  120. package/src/prover/smt/solver/muz/horn-tactic.ts +15 -2
  121. package/src/prover/smt/solver/muz/rule-properties.ts +22 -0
  122. package/src/prover/smt/solver/muz/spacer-context.ts +1 -4
  123. package/src/prover/smt/solver/muz/spacer-prop-solver.ts +1 -1
  124. package/src/prover/smt/solver/nlqsat.ts +1 -1
  125. package/src/prover/smt/solver/nlsat/algebraic.ts +4 -5
  126. package/src/prover/smt/solver/nlsat/levelwise.ts +0 -4
  127. package/src/prover/smt/solver/nlsat/polynomial.ts +1 -36
  128. package/src/prover/smt/solver/nlsat/upolynomial.ts +1 -1
  129. package/src/prover/smt/solver/nlsat-tactic.ts +1 -1
  130. package/src/prover/smt/solver/nnf.ts +6 -2
  131. package/src/prover/smt/solver/opt-context.ts +16 -7
  132. package/src/prover/smt/solver/opt-pareto.ts +19 -0
  133. package/src/prover/smt/solver/opt-preprocess.ts +1 -1
  134. package/src/prover/smt/solver/opt-solver.ts +4 -3
  135. package/src/prover/smt/solver/optsmt.ts +1 -1
  136. package/src/prover/smt/solver/parallel-tactic.ts +1 -1
  137. package/src/prover/smt/solver/pb-rewriter.ts +1 -4
  138. package/src/prover/smt/solver/poly-rewriter.ts +75 -18
  139. package/src/prover/smt/solver/probes.ts +88 -23
  140. package/src/prover/smt/solver/proto-model.ts +8 -8
  141. package/src/prover/smt/solver/push-app-ite.ts +37 -0
  142. package/src/prover/smt/solver/qe-arith-plugin.ts +2 -4
  143. package/src/prover/smt/solver/qe-lite.ts +2 -2
  144. package/src/prover/smt/solver/qe.ts +3 -2
  145. package/src/prover/smt/solver/qsat.ts +23 -8
  146. package/src/prover/smt/solver/recfun-decl-plugin.ts +2 -1
  147. package/src/prover/smt/solver/rewriter-tpl.ts +7 -6
  148. package/src/prover/smt/solver/rewriter.ts +31 -25
  149. package/src/prover/smt/solver/rlimit.ts +7 -3
  150. package/src/prover/smt/solver/sat/config.ts +1 -1
  151. package/src/prover/smt/solver/sat/goal2sat.ts +65 -12
  152. package/src/prover/smt/solver/sat/inc-sat-solver.ts +129 -43
  153. package/src/prover/smt/solver/sat/model-converter.ts +1 -1
  154. package/src/prover/smt/solver/sat/pb-constraint.ts +7 -0
  155. package/src/prover/smt/solver/sat/pb-solver.ts +26 -7
  156. package/src/prover/smt/solver/sat/sat-tactic.ts +15 -6
  157. package/src/prover/smt/solver/sat/sat2goal.ts +72 -48
  158. package/src/prover/smt/solver/sat/simplifier.ts +1 -1
  159. package/src/prover/smt/solver/sat/solver.ts +27 -47
  160. package/src/prover/smt/solver/seq-axioms.ts +20 -35
  161. package/src/prover/smt/solver/seq-decl-plugin.ts +1 -1
  162. package/src/prover/smt/solver/seq-derive.ts +1 -1
  163. package/src/prover/smt/solver/seq-eq-solver.ts +2 -2
  164. package/src/prover/smt/solver/seq-monadic.ts +7 -5
  165. package/src/prover/smt/solver/seq-re-rewriter.ts +2 -1
  166. package/src/prover/smt/solver/seq-re-util.ts +1 -1
  167. package/src/prover/smt/solver/seq-regex-bisim.ts +1 -1
  168. package/src/prover/smt/solver/seq-regex-live.ts +2 -2
  169. package/src/prover/smt/solver/seq-rewriter.ts +31 -29
  170. package/src/prover/smt/solver/seq-skolem.ts +0 -23
  171. package/src/prover/smt/solver/seq-view-witness.ts +4 -4
  172. package/src/prover/smt/solver/smt-consequences.ts +1 -1
  173. package/src/prover/smt/solver/smt-kernel.ts +40 -6
  174. package/src/prover/smt/solver/smt-setup.ts +106 -13
  175. package/src/prover/smt/solver/smtlib-parser.ts +579 -214
  176. package/src/prover/smt/solver/smtlib-script.ts +600 -170
  177. package/src/prover/smt/solver/solve-eqs.ts +36 -37
  178. package/src/prover/smt/solver/solver.ts +18 -3
  179. package/src/prover/smt/solver/tactic.ts +342 -196
  180. package/src/prover/smt/solver/theory-bv.ts +13 -3
  181. package/src/prover/smt/solver/theory-fpa.ts +1 -1
  182. package/src/prover/smt/solver/theory-lra-final-check.ts +1 -0
  183. package/src/prover/smt/solver/theory-lra-internalize.ts +2 -0
  184. package/src/prover/smt/solver/theory-lra-propagate.ts +11 -3
  185. package/src/prover/smt/solver/theory-lra-state.ts +1 -1
  186. package/src/prover/smt/solver/theory-lra.ts +1 -1
  187. package/src/prover/smt/solver/theory-pb.ts +24 -7
  188. package/src/prover/smt/solver/theory-seq-solve.ts +1 -1
  189. package/src/prover/smt/solver/theory-seq-state.ts +2 -21
  190. package/src/prover/smt/solver/theory-without-terms.ts +24 -0
  191. package/src/prover/smt/solver/tseitin-cnf.ts +1 -0
  192. package/src/prover/tlapm/cache.ts +8 -8
  193. package/src/prover/zenon/index-table.ts +5 -2
  194. package/src/prover/zenon/isar-case.ts +1 -1
  195. package/src/prover/zenon/isar.ts +2 -2
  196. package/src/prover/zenon/phrase.ts +1 -1
  197. package/src/resolve.ts +1226 -246
  198. package/src/runtime.ts +19 -2
  199. package/src/sany/builtins.ts +10 -10
  200. package/src/sany/generation.ts +4 -2
  201. package/src/sany/generator-def-entries.ts +123 -36
  202. package/src/sany/generator-definitions.ts +4 -2
  203. package/src/sany/generator-expressions.ts +51 -20
  204. package/src/sany/generator-proofs.ts +17 -11
  205. package/src/sany/generator.ts +11 -5
  206. package/src/sany/lexer.ts +15 -7
  207. package/src/sany/modules.ts +4 -2
  208. package/src/sany/nodes.ts +1 -1
  209. package/src/sany/selectors.ts +11 -6
  210. package/src/sany/xml.ts +2 -3
  211. package/src/search.ts +283 -126
  212. package/src/simulate.ts +247 -185
  213. package/src/spec-description.ts +15 -7
  214. package/src/standard-definitions.ts +1 -0
  215. package/src/standard-modules.ts +56 -22
  216. package/src/subexpressions.ts +563 -139
  217. package/src/successors.ts +50 -20
  218. package/src/symmetry.ts +2 -1
  219. package/src/tlc/jar-data.ts +1 -3
  220. package/src/tlc/messages.ts +3 -3
  221. package/src/tlc/random.ts +2 -1
  222. package/src/tlc/replay.ts +147 -46
  223. package/src/tlc/tlc-operators.ts +10 -8
  224. package/src/tlc/tlcext-operators.ts +26 -10
  225. package/src/tlc/trace-spec.ts +9 -22
  226. package/src/trace-liveness.ts +529 -0
  227. package/src/typed-tier.ts +52 -31
  228. package/src/typescript/types.ts +2 -2
  229. package/src/values.ts +150 -79
package/src/search.ts CHANGED
@@ -17,7 +17,11 @@ import type {
17
17
  import { parseConfig, type ConfigValue, type ModelConfig } from "./config";
18
18
  import {
19
19
  addCoverageRelation,
20
+ buildCoverage,
21
+ createCoverage,
22
+ createCoverageEnvironment,
20
23
  getCoverageLabel,
24
+ getCoverageReport,
21
25
  runAtCoverageNode,
22
26
  type Coverage,
23
27
  type CoverageKind,
@@ -34,7 +38,6 @@ import {
34
38
  type RuntimeInvariant,
35
39
  } from "./environment";
36
40
  import {
37
- isStackOverflow,
38
41
  TlaConfigError,
39
42
  TlaEvaluationError,
40
43
  TlaModuleError,
@@ -53,6 +56,7 @@ import {
53
56
  type Context,
54
57
  type Environment,
55
58
  type Scope,
59
+ type State,
56
60
  } from "./evaluate";
57
61
  import { EXIT_STATUS, setExitCode } from "./exit-codes";
58
62
  import type { JavaOverride } from "./java-overrides";
@@ -67,10 +71,12 @@ import { expandTemporal, getLevel, type ScopedExpression, type TemporalProperty
67
71
  import { getLiveExpressions } from "./liveness-checker";
68
72
  import { prettyPrint } from "./pretty-print";
69
73
  import { getPossibleCounts, type CheckerRuntime } from "./runtime";
74
+ import { createIncompleteSuccessorError, type SuccessorGenerator } from "./successors";
70
75
  import {
71
76
  getSpecDescription,
72
77
  getSpecificationValue,
73
78
  getSubscriptVariables,
79
+ type SpecAction,
74
80
  type SpecDescription,
75
81
  } from "./spec-description";
76
82
  import { getRepresentative, getSymmetryGroup, type Images } from "./symmetry";
@@ -83,14 +89,17 @@ import {
83
89
  withHeadline,
84
90
  } from "./tlc/messages";
85
91
  import { createTlcOrder } from "./tlc/order";
92
+ import { getPrimedRanges, walkSuccessors } from "./tlc/replay";
86
93
  import { getTlcFingerprint, getTlcFingerprints, setFingerprintPolynomial } from "./tlc/fingerprint";
87
94
  import type { TlcVersion } from "./tlc/version";
88
95
  import {
96
+ createModelValue,
89
97
  formatValue,
90
98
  freezeStringOrder,
91
99
  getWrittenPairs,
92
100
  isFunctionValue,
93
101
  isUpdatedElementOf,
102
+ markNormalized,
94
103
  setAliasName,
95
104
  setStringOrder,
96
105
  setValueOptions,
@@ -212,14 +221,7 @@ const isLiteralDefinition = (definition: Definition) =>
212
221
 
213
222
  const getConstantValue = (name: string, definition: Definition, environment: Environment) => {
214
223
  if (environment.constants.has(name)) return environment.constants.get(name);
215
- if (!isConstantLevel(definition, environment) || isLiteralDefinition(definition))
216
- return undefined;
217
- try {
218
- return evaluate(createIdentifier(name), getContext(environment, undefined, undefined));
219
- } catch (error) {
220
- if (error instanceof TlaEvaluationError || isStackOverflow(error)) return undefined;
221
- throw error;
222
- }
224
+ return isLiteralDefinition(definition) ? undefined : getStartupValue(definition, environment);
223
225
  };
224
226
 
225
227
  const getConfigDefinition = (kind: string, name: string, environment: Environment) => {
@@ -386,12 +388,20 @@ const getSpecification = (
386
388
  let isUntaggedFound = false;
387
389
  expandTemporal(definition.body, undefined, environment, false).forEach((item) => {
388
390
  const conjunct = item.expression;
389
- if (isConstantTrue(item, environment, "spec")) return;
391
+ // TLC takes a state-level definition of the spec whole as an initial predicate.
392
+ const isInitial = item.path.some((name) => {
393
+ const expanded = getDefinition(name, environment);
394
+ return (
395
+ expanded?.kind === "Operator" &&
396
+ getLevel(expanded.body, undefined, environment) === VARIABLE_LEVEL
397
+ );
398
+ });
399
+ if (!isInitial && isConstantTrue(item, environment, "spec")) return;
390
400
  const variableIndex =
391
401
  conjunct.kind === "Identifier" && !isLocallyResolved(conjunct)
392
402
  ? environment.variableIndex.get(conjunct.name)
393
403
  : undefined;
394
- if (conjunct.kind === "Identifier" && variableIndex !== undefined) {
404
+ if (!isInitial && conjunct.kind === "Identifier" && variableIndex !== undefined) {
395
405
  const range = variableLocations[variableIndex].range;
396
406
  throw new TlaConfigError(
397
407
  `The operator ${conjunct.name}, which equals ${range ? formatRange(range) : conjunct.name},\ncannot be used as a spec`,
@@ -656,22 +666,28 @@ const getPredicate = (expression: Expression, environment: Environment) => {
656
666
  };
657
667
 
658
668
  const getStateChecks = (named: NamedExpression[], environment: Environment): StateCheck[] =>
659
- named.flatMap((item) =>
660
- getConjuncts(item.expression, environment).map((expression) => {
661
- const variables =
662
- item.scope === undefined ? getReadVariables(expression, environment) : undefined;
663
- return {
664
- name: item.name,
665
- expression,
666
- scope: item.scope,
667
- variables,
668
- membership: getMembership(expression, variables, environment),
669
- predicate: getPredicate(item.expression, environment),
670
- };
671
- }),
672
- );
669
+ named.flatMap((item) => {
670
+ const predicate = getPredicate(item.expression, environment);
671
+ const isImpure =
672
+ item.scope === undefined && getReadVariables(predicate, environment) === undefined;
673
+ // TLC evaluates an invariant whole, so one that prints isn't split into conjuncts.
674
+ return (isImpure ? [predicate] : getConjuncts(item.expression, environment)).map(
675
+ (expression) => {
676
+ const variables =
677
+ item.scope === undefined ? getReadVariables(expression, environment) : undefined;
678
+ return {
679
+ name: item.name,
680
+ expression,
681
+ scope: item.scope,
682
+ variables,
683
+ membership: getMembership(expression, variables, environment),
684
+ predicate,
685
+ };
686
+ },
687
+ );
688
+ });
673
689
 
674
- const isUnchangedFor = (stateCheck: StateCheck, state: Value[], parent: Value[] | undefined) => {
690
+ const isUnchangedFor = (stateCheck: StateCheck, state: State, parent: Value[] | undefined) => {
675
691
  const variables = stateCheck.variables;
676
692
  if (!parent || !variables) return false;
677
693
  for (let index = 0; index < variables.length; index++) {
@@ -689,31 +705,42 @@ const isWideConfigValue = (value: ConfigValue): boolean =>
689
705
  ? WIDE_CHARACTER.test(value.value)
690
706
  : value.kind === "Set" && value.elements.some(isWideConfigValue);
691
707
 
692
- const isWideExpression = (expression: Expression): boolean =>
693
- (expression.kind === "String" && WIDE_CHARACTER.test(expression.value)) ||
694
- (expression.kind === "Apply" && DESERIALIZERS.has(expression.operator)) ||
695
- getChildren(expression).some(isWideExpression);
708
+ const isWideExpression = (expression: Expression, checked: Set<Expression>): boolean => {
709
+ if (expression.kind === "Selection") {
710
+ if (checked.has(expression.expression)) return false;
711
+ checked.add(expression.expression);
712
+ }
713
+ return (
714
+ (expression.kind === "String" && WIDE_CHARACTER.test(expression.value)) ||
715
+ (expression.kind === "Apply" && DESERIALIZERS.has(expression.operator)) ||
716
+ getChildren(expression).some((child) => isWideExpression(child, checked))
717
+ );
718
+ };
696
719
 
697
720
  // TLC fingerprints a string by the low byte of each character, so it merges states whose strings differ only above U+00FF.
698
- const hasWideString = (config: ModelConfig, environment: Environment) =>
699
- config.constants.some(
700
- (constant) =>
701
- isWideConfigValue(constant.value) || (constant.args ?? []).some(isWideConfigValue),
702
- ) ||
703
- [...environment.definitions.values()].some(
704
- (definition) =>
705
- isWideExpression(definition.body) ||
706
- (definition.kind === "Function" &&
707
- definition.bounds.some((bound) => isWideExpression(bound.set))),
721
+ const hasWideString = (config: ModelConfig, environment: Environment) => {
722
+ const checked = new Set<Expression>();
723
+ return (
724
+ config.constants.some(
725
+ (constant) =>
726
+ isWideConfigValue(constant.value) || (constant.args ?? []).some(isWideConfigValue),
727
+ ) ||
728
+ [...environment.definitions.values()].some(
729
+ (definition) =>
730
+ isWideExpression(definition.body, checked) ||
731
+ (definition.kind === "Function" &&
732
+ definition.bounds.some((bound) => isWideExpression(bound.set, checked))),
733
+ )
708
734
  );
735
+ };
709
736
 
710
737
  export interface Search {
711
738
  properties: Properties;
712
739
  toRecord: (state: Value[]) => Record<string, Value>;
713
740
  evaluateAlias: (
714
741
  alias: string,
715
- state: Value[],
716
- next: Value[] | undefined,
742
+ state: State,
743
+ next: State | undefined,
717
744
  isTool: boolean,
718
745
  ) => Record<string, Value>;
719
746
  spec: Specification;
@@ -738,22 +765,23 @@ export interface Search {
738
765
  }
739
766
  | undefined;
740
767
  findViolatedInvariant: (state: Value[], parent?: Value[]) => StateCheck | undefined;
741
- getViolatedInvariants: (state: Value[]) => StateCheck[];
768
+ forEachViolatedInvariant: (state: Value[], onViolated: (invariant: StateCheck) => void) => void;
742
769
  checkReplayedInitialState: (
743
770
  state: Value[],
744
771
  tracing: Environment,
745
772
  addFingerprint: () => void,
746
- ) => Pick<InitialStateViolation, "status" | "name"> | undefined;
773
+ onViolated: (violation: Pick<InitialStateViolation, "status" | "name">) => void,
774
+ ) => void;
747
775
  checkReplayedSuccessor: (
748
776
  state: Value[],
749
777
  next: Value[],
750
778
  tracing: Environment,
751
779
  addFingerprint: () => boolean,
752
780
  ) => boolean;
753
- satisfiesConstraints: (state: Value[], parent?: Value[]) => boolean;
781
+ satisfiesConstraints: (state: State, parent?: Value[]) => boolean;
754
782
  findFailedInitialPredicate: (state: Value[]) => NamedExpression | undefined;
755
783
  findViolatedActionProperty: (state: Value[], next: Value[]) => ActionProperty | undefined;
756
- satisfiesActionConstraints: (state: Value[], next: Value[]) => boolean;
784
+ satisfiesActionConstraints: (state: Value[], next: State) => boolean;
757
785
  getExcludingConstraints: (state: Value[], next: Value[]) => string[];
758
786
  trackStatePossible: (state: Value[]) => void;
759
787
  trackActionPossible: (state: Value[], next: Value[]) => void;
@@ -783,8 +811,8 @@ export const getIncompleteSuccessorMessage = (
783
811
 
784
812
  export const getContext = (
785
813
  environment: Environment,
786
- state: Value[] | undefined,
787
- next: Value[] | undefined,
814
+ state: State | undefined,
815
+ next: State | undefined,
788
816
  scope?: Scope,
789
817
  ) => ({ environment, scope, state, next });
790
818
 
@@ -817,7 +845,7 @@ const getExpectedBoolean = (expression: Expression, environment: Environment) =>
817
845
 
818
846
  const holdsAsConjunct = (check: StateCheck, context: Context) =>
819
847
  holdsLikeTlc(check.expression, context, (expression, environment) => {
820
- holdsLikeTlc(check.predicate, context);
848
+ if (check.predicate !== check.expression) holdsLikeTlc(check.predicate, context);
821
849
  return getExpectedBoolean(expression, environment);
822
850
  });
823
851
 
@@ -906,7 +934,13 @@ export const prepareSearch = (options: CheckOptions) => {
906
934
  const created = createCheckEnvironment(config, options, options.onPrint ?? console.log);
907
935
  const specification = created.specification;
908
936
  reportStartup(specification, config, options.onProgress);
909
- const environment = specification.environment;
937
+ const coverage =
938
+ options.coverage === undefined
939
+ ? undefined
940
+ : createCoverage(specification.environment.variables.length);
941
+ const environment = coverage
942
+ ? createCoverageEnvironment(specification.environment, coverage)
943
+ : specification.environment;
910
944
  let description: SpecDescription | undefined;
911
945
  const getDescription = () =>
912
946
  (description ??= getSpecDescription(config, environment, specification.instanceActions));
@@ -921,9 +955,73 @@ export const prepareSearch = (options: CheckOptions) => {
921
955
  specification.moduleOperators,
922
956
  specification.runtimeInvariants,
923
957
  );
924
- return { config, specification, environment, search, getDescription };
958
+ const getCoverage = () =>
959
+ coverage &&
960
+ getCoverageReport(
961
+ coverage,
962
+ environment,
963
+ specification.variableLocations,
964
+ search?.getTlcOrder() ?? [],
965
+ );
966
+ return { config, specification, environment, search, getDescription, coverage, getCoverage };
967
+ };
968
+
969
+ export interface CoveredAction extends SpecAction {
970
+ node: number;
971
+ }
972
+
973
+ export const STOP_WALK = new Error("The walk stopped");
974
+
975
+ export const addActionCoverage = (
976
+ coverage: Coverage,
977
+ environment: Environment,
978
+ description: SpecDescription,
979
+ ) => {
980
+ const addRelations = (kind: "init" | "next", actions: SpecAction[]) =>
981
+ actions.map((action): CoveredAction => ({
982
+ ...action,
983
+ node: addCoverageRelation(
984
+ coverage,
985
+ kind,
986
+ getCoverageLabel(action.name, action.expression, environment),
987
+ action.expression,
988
+ action.scope,
989
+ ),
990
+ }));
991
+ const inits = addRelations("init", description.inits);
992
+ const actions = addRelations("next", description.actions);
993
+ buildCoverage(coverage, environment, getPrimedRanges(actions, environment));
994
+ return { inits, actions };
925
995
  };
926
996
 
997
+ export const walkCoveredSuccessors = (
998
+ coverage: Coverage,
999
+ action: CoveredAction,
1000
+ state: Value[],
1001
+ environment: Environment,
1002
+ onState: (successor: Value[]) => void,
1003
+ onIncomplete = (partial: State, name: string | undefined): void => {
1004
+ throw createIncompleteSuccessorError(partial, name, environment);
1005
+ },
1006
+ generator?: SuccessorGenerator,
1007
+ ) =>
1008
+ walkSuccessors(
1009
+ action,
1010
+ action.node,
1011
+ state,
1012
+ environment,
1013
+ (successor) => {
1014
+ coverage.primary[action.node]++;
1015
+ onState(successor);
1016
+ },
1017
+ (partial) => {
1018
+ coverage.primary[action.node]++;
1019
+ onIncomplete(partial, action.name);
1020
+ return true;
1021
+ },
1022
+ generator,
1023
+ );
1024
+
927
1025
  export const reportAssumptionViolation = (
928
1026
  assumptions: Assumption[],
929
1027
  environment: Environment,
@@ -1052,8 +1150,20 @@ export const createSearch = (
1052
1150
  ...getCoveredChecks("invariant", configInvariants),
1053
1151
  ...getCoveredChecks("invariant", properties.invariants, false),
1054
1152
  ];
1153
+ const coveredInvariantChecks = new Map(
1154
+ [...configInvariants, ...properties.invariants].map((item, index) => [
1155
+ getPredicate(item.expression, environment),
1156
+ coveredInvariants[index],
1157
+ ]),
1158
+ );
1055
1159
  const coveredActionConstraints = getCoveredChecks("constraint", actionConstraints);
1056
1160
  const coveredConstraints = getCoveredChecks("constraint", namedConstraints);
1161
+ const coveredConstraintChecks = new Map(
1162
+ coveredConstraints.map((check) => [check.expression, check]),
1163
+ );
1164
+ const constraintPredicates = [
1165
+ ...new Map(constraints.map((constraint) => [constraint.predicate, constraint])).values(),
1166
+ ];
1057
1167
  const coveredInitialPredicates = getCoveredChecks("implied", properties.initialPredicates, false);
1058
1168
  const coveredActionProperties = getCoveredChecks(
1059
1169
  "implied",
@@ -1063,8 +1173,8 @@ export const createSearch = (
1063
1173
  const evaluateCovered = (
1064
1174
  covered: Coverage,
1065
1175
  check: CoveredCheck,
1066
- state: Value[],
1067
- next: Value[] | undefined,
1176
+ state: State,
1177
+ next: State | undefined,
1068
1178
  ) => {
1069
1179
  try {
1070
1180
  return runAtCoverageNode(covered, check.node, () =>
@@ -1074,10 +1184,15 @@ export const createSearch = (
1074
1184
  return undefined;
1075
1185
  }
1076
1186
  };
1077
- const isCoveredHeld = (checks: CoveredCheck[], state: Value[], next?: Value[]) =>
1078
- coverage !== undefined &&
1079
- checks.every((check) => evaluateCovered(coverage, check, state, next) === true);
1080
- const satisfiesCovered = (checks: CoveredCheck[], state: Value[], next?: Value[]) => {
1187
+ const holdsReplayed = (
1188
+ covered: CoveredCheck | undefined,
1189
+ expression: Expression,
1190
+ context: Context,
1191
+ ) =>
1192
+ coverage && covered
1193
+ ? runAtCoverageNode(coverage, covered.node, () => holdsLikeTlc(covered.expression, context))
1194
+ : holdsLikeTlc(expression, context);
1195
+ const satisfiesCovered = (checks: CoveredCheck[], state: State, next?: State) => {
1081
1196
  if (!coverage) return undefined;
1082
1197
  for (const check of checks) {
1083
1198
  const value = evaluateCovered(coverage, check, state, next);
@@ -1132,9 +1247,15 @@ export const createSearch = (
1132
1247
  };
1133
1248
  const getViewValue = (expression: Expression, state: Value[]) =>
1134
1249
  evaluate(expression, getContext(environment, state, undefined));
1250
+ const getRepresentativeState = (state: Value[]) => {
1251
+ // TLC's TLCStateMut#fingerPrint deep-normalizes a state before it evaluates the view.
1252
+ if (view !== undefined) state.forEach(markNormalized);
1253
+ return symmetryGroup === undefined
1254
+ ? state
1255
+ : getRepresentative(state, symmetryGroup, getTlcOrder());
1256
+ };
1135
1257
  const getTlcStateFingerprint = (state: Value[]) => {
1136
- const representative =
1137
- symmetryGroup === undefined ? state : getRepresentative(state, symmetryGroup, getTlcOrder());
1258
+ const representative = getRepresentativeState(state);
1138
1259
  return getTlcFingerprint(
1139
1260
  view === undefined
1140
1261
  ? getTlcOrder().map((index) => representative[index])
@@ -1142,15 +1263,16 @@ export const createSearch = (
1142
1263
  );
1143
1264
  };
1144
1265
  const findFailedInitialPredicate = (state: Value[]) =>
1145
- isCoveredHeld(coveredInitialPredicates, state)
1146
- ? undefined
1147
- : properties.initialPredicates.find(
1148
- (predicate) =>
1149
- !holdsLikeTlc(
1150
- predicate.expression,
1151
- getContext(environment, state, undefined, predicate.scope),
1152
- ),
1153
- );
1266
+ properties.initialPredicates.find((predicate, index) => {
1267
+ const value =
1268
+ coverage && evaluateCovered(coverage, coveredInitialPredicates[index], state, undefined);
1269
+ return typeof value === "boolean"
1270
+ ? !value
1271
+ : !holdsLikeTlc(
1272
+ predicate.expression,
1273
+ getContext(environment, state, undefined, predicate.scope),
1274
+ );
1275
+ });
1154
1276
  const violatingStates = new WeakSet<Value[]>();
1155
1277
  const isViolated = (invariant: StateCheck, state: Value[], parent: Value[] | undefined) => {
1156
1278
  const checkedParent = parent && !violatingStates.has(parent) ? parent : undefined;
@@ -1174,6 +1296,21 @@ export const createSearch = (
1174
1296
  );
1175
1297
  }
1176
1298
  };
1299
+ const isPredicateViolated = (
1300
+ predicate: StateCheck,
1301
+ state: Value[],
1302
+ parent: Value[] | undefined,
1303
+ ) => {
1304
+ const covered = coveredInvariantChecks.get(predicate.predicate);
1305
+ const value =
1306
+ coverage && covered ? evaluateCovered(coverage, covered, state, undefined) : undefined;
1307
+ return typeof value === "boolean"
1308
+ ? !value
1309
+ : invariants.some(
1310
+ (invariant) =>
1311
+ invariant.predicate === predicate.predicate && isViolated(invariant, state, parent),
1312
+ );
1313
+ };
1177
1314
  const isFingerprintedLikeTlc = hasWideString(config, environment);
1178
1315
  runtime.getFingerprint = getTlcStateFingerprint;
1179
1316
  const findUnwitnessedPossible = () => {
@@ -1209,7 +1346,7 @@ export const createSearch = (
1209
1346
  )
1210
1347
  .join("")
1211
1348
  : prettyPrint(formatValue(getViewValue(expression, state)));
1212
- const holdsActionConstraint = (constraint: NamedExpression, state: Value[], next: Value[]) =>
1349
+ const holdsActionConstraint = (constraint: NamedExpression, state: Value[], next: State) =>
1213
1350
  holdsLikeTlc(
1214
1351
  constraint.expression,
1215
1352
  getContext(environment, state, next),
@@ -1229,14 +1366,16 @@ export const createSearch = (
1229
1366
  spec,
1230
1367
  toRecord,
1231
1368
  evaluateAlias: (alias, state, next, isTool) => {
1369
+ const getStateRecord = () =>
1370
+ toRecord(state.map((value) => value ?? createModelValue("null")));
1232
1371
  try {
1233
1372
  getConfigDefinition("alias", alias, environment);
1234
1373
  const value = evaluate(createIdentifier(alias), getContext(environment, state, next));
1235
1374
  const record = toAliasRecord(value);
1236
- return record === undefined ? toRecord(state) : setAliasName(record, alias);
1375
+ return record === undefined ? getStateRecord() : setAliasName(record, alias);
1237
1376
  } catch (error) {
1238
1377
  if (!(error instanceof TlaConfigError || error instanceof TlaEvaluationError)) throw error;
1239
- return { ...toRecord(state), _ALIASEvalError: formatNestedMessage(error.message, isTool) };
1378
+ return { ...getStateRecord(), _ALIASEvalError: formatNestedMessage(error.message, isTool) };
1240
1379
  }
1241
1380
  },
1242
1381
  isSymmetric: symmetryGroup !== undefined,
@@ -1320,64 +1459,81 @@ export const createSearch = (
1320
1459
  },
1321
1460
  getFingerprintState: (state) => {
1322
1461
  if (isFingerprintedLikeTlc) return [String(getTlcStateFingerprint(state))];
1323
- const representative =
1324
- symmetryGroup === undefined
1325
- ? state
1326
- : getRepresentative(state, symmetryGroup, getTlcOrder());
1462
+ const representative = getRepresentativeState(state);
1327
1463
  return view === undefined ? representative : [getViewValue(view.expression, representative)];
1328
1464
  },
1329
1465
  findViolatedInvariant: (state, parent) => {
1330
- const checked = isCoveredHeld(coveredInvariants, state) ? runtimeChecks : invariants;
1331
- const violated = checked.find((invariant) => isViolated(invariant, state, parent));
1466
+ const violated =
1467
+ coverage === undefined
1468
+ ? invariants.find((invariant) => isViolated(invariant, state, parent))
1469
+ : invariantPredicates.find((predicate) => isPredicateViolated(predicate, state, parent));
1332
1470
  if (violated) violatingStates.add(state);
1333
1471
  return violated;
1334
1472
  },
1335
- getViolatedInvariants: (state) => {
1336
- const violated = invariantPredicates.filter((predicate) =>
1337
- invariants.some(
1338
- (invariant) =>
1339
- invariant.predicate === predicate.predicate && isViolated(invariant, state, undefined),
1473
+ forEachViolatedInvariant: (state, onViolated) => {
1474
+ for (const predicate of invariantPredicates) {
1475
+ if (!isPredicateViolated(predicate, state, undefined)) continue;
1476
+ violatingStates.add(state);
1477
+ onViolated(predicate);
1478
+ }
1479
+ },
1480
+ checkReplayedInitialState: (state, tracing, addFingerprint, onViolated) => {
1481
+ const holdsIn = (
1482
+ covered: CoveredCheck | undefined,
1483
+ expression: Expression,
1484
+ scope: Scope | undefined,
1485
+ ) => holdsReplayed(covered, expression, getContext(tracing, state, undefined, scope));
1486
+ const isInModel = constraintPredicates.every((constraint) =>
1487
+ holdsIn(
1488
+ coveredConstraintChecks.get(constraint.predicate),
1489
+ constraint.predicate,
1490
+ constraint.scope,
1340
1491
  ),
1341
1492
  );
1342
- if (violated.length > 0) violatingStates.add(state);
1343
- return violated;
1344
- },
1345
- checkReplayedInitialState: (state, tracing, addFingerprint) => {
1346
- const holdsIn = (expression: Expression, scope: Scope | undefined) =>
1347
- holdsLikeTlc(expression, getContext(tracing, state, undefined, scope));
1348
- if (constraints.every((constraint) => holdsIn(constraint.predicate, constraint.scope))) {
1349
- addFingerprint();
1493
+ if (isInModel) addFingerprint();
1494
+ for (const invariant of invariantPredicates) {
1495
+ const covered = coveredInvariantChecks.get(invariant.predicate);
1496
+ if (holdsIn(covered, invariant.predicate, invariant.scope)) continue;
1497
+ onViolated({ status: "invariant-violation", name: invariant.name });
1350
1498
  }
1351
- const invariant = invariantPredicates.find((check) => !holdsIn(check.predicate, check.scope));
1352
- if (invariant) return { status: "invariant-violation", name: invariant.name };
1353
1499
  const predicate = properties.initialPredicates.find(
1354
- (check) => !holdsIn(check.expression, check.scope),
1500
+ (check, index) => !holdsIn(coveredInitialPredicates[index], check.expression, check.scope),
1355
1501
  );
1356
- return predicate && { status: "liveness-violation", name: predicate.name };
1502
+ if (predicate) onViolated({ status: "liveness-violation", name: predicate.name });
1357
1503
  },
1358
1504
  checkReplayedSuccessor: (state, next, tracing, addFingerprint) => {
1359
1505
  const isInModel =
1360
- constraints.every((constraint) =>
1361
- holdsLikeTlc(
1506
+ constraintPredicates.every((constraint) =>
1507
+ holdsReplayed(
1508
+ coveredConstraintChecks.get(constraint.predicate),
1362
1509
  constraint.predicate,
1363
1510
  getContext(tracing, next, undefined, constraint.scope),
1364
1511
  ),
1365
1512
  ) &&
1366
- actionConstraints.every((constraint) =>
1367
- holdsLikeTlc(constraint.expression, getContext(tracing, state, next, constraint.scope)),
1513
+ actionConstraints.every((constraint, index) =>
1514
+ holdsReplayed(
1515
+ coveredActionConstraints[index],
1516
+ constraint.expression,
1517
+ getContext(tracing, state, next, constraint.scope),
1518
+ ),
1368
1519
  );
1369
1520
  // TLC checks the invariants of a successor it has not seen, even outside the model.
1370
1521
  const isUnseen = isInModel ? addFingerprint() : true;
1371
1522
  return (
1372
1523
  (!isUnseen ||
1373
1524
  invariantPredicates.every((invariant) =>
1374
- holdsLikeTlc(
1525
+ holdsReplayed(
1526
+ coveredInvariantChecks.get(invariant.predicate),
1375
1527
  invariant.predicate,
1376
1528
  getContext(tracing, next, undefined, invariant.scope),
1377
1529
  ),
1378
1530
  )) &&
1379
- actionProperties.every((property) =>
1380
- holdsLikeTlc(property.box, getContext(tracing, state, next, property.scope)),
1531
+ actionProperties.every((property, index) =>
1532
+ holdsReplayed(
1533
+ coveredActionProperties[index],
1534
+ property.box,
1535
+ getContext(tracing, state, next, property.scope),
1536
+ ),
1381
1537
  )
1382
1538
  );
1383
1539
  },
@@ -1390,31 +1546,32 @@ export const createSearch = (
1390
1546
  ),
1391
1547
  findFailedInitialPredicate,
1392
1548
  findViolatedActionProperty: (state, next) =>
1393
- isCoveredHeld(coveredActionProperties, state, next)
1394
- ? undefined
1395
- : actionProperties.find((property) => {
1396
- try {
1397
- return (
1398
- !holdsLikeTlc(
1399
- property.action,
1400
- getContext(environment, state, next, property.scope),
1401
- () =>
1402
- `Attempted to evaluate an expression of form [A]_e, but A was not a boolean.\n${describeRange(property.box)}`,
1403
- ) &&
1404
- !holds(
1405
- property.unchanged,
1406
- getContext(environment, state, next, property.scope),
1407
- "a subscript",
1408
- )
1409
- );
1410
- } catch (error) {
1411
- throw withHeadline(
1412
- withNextStateExitCode(error),
1413
- MESSAGE_CODE.actionPropertyEvaluationFailed,
1414
- `Evaluating action property ${property.name} failed.`,
1415
- );
1416
- }
1417
- }),
1549
+ actionProperties.find((property, index) => {
1550
+ const value =
1551
+ coverage && evaluateCovered(coverage, coveredActionProperties[index], state, next);
1552
+ if (typeof value === "boolean") return !value;
1553
+ try {
1554
+ return (
1555
+ !holdsLikeTlc(
1556
+ property.action,
1557
+ getContext(environment, state, next, property.scope),
1558
+ () =>
1559
+ `Attempted to evaluate an expression of form [A]_e, but A was not a boolean.\n${describeRange(property.box)}`,
1560
+ ) &&
1561
+ !holds(
1562
+ property.unchanged,
1563
+ getContext(environment, state, next, property.scope),
1564
+ "a subscript",
1565
+ )
1566
+ );
1567
+ } catch (error) {
1568
+ throw withHeadline(
1569
+ withNextStateExitCode(error),
1570
+ MESSAGE_CODE.actionPropertyEvaluationFailed,
1571
+ `Evaluating action property ${property.name} failed.`,
1572
+ );
1573
+ }
1574
+ }),
1418
1575
  satisfiesActionConstraints: (state, next) =>
1419
1576
  satisfiesCovered(coveredActionConstraints, state, next) ??
1420
1577
  actionConstraints.every((constraint) => holdsActionConstraint(constraint, state, next)),