tla-ts 0.0.10-dev.09e53c2a6 → 0.0.10-dev.1ebc153bd

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 (214) 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 +2 -1
  7. package/dist/index.d.ts +2 -1
  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 +43 -43
  14. package/dist/prove.js +78 -78
  15. package/dist/run.cjs +33 -35
  16. package/dist/run.js +44 -46
  17. package/dist/tlapm.cjs +1 -1
  18. package/dist/tlapm.js +2 -2
  19. package/dist/transfer.cjs +43 -43
  20. package/dist/transfer.js +38 -38
  21. package/dist/worker.cjs +6 -6
  22. package/dist/worker.js +6 -6
  23. package/package.json +1 -1
  24. package/src/ast.ts +1 -0
  25. package/src/bags.ts +46 -28
  26. package/src/check-trace.ts +2 -16
  27. package/src/check.ts +152 -64
  28. package/src/cli/runtime-invariants.ts +20 -56
  29. package/src/cli/tlc-arguments.ts +2 -2
  30. package/src/cli/tlc-output.ts +1 -2
  31. package/src/cli/tlc.ts +13 -8
  32. package/src/cli/xml-exporter.ts +1 -1
  33. package/src/codegen.ts +9 -5
  34. package/src/dependencies.ts +49 -9
  35. package/src/dfid.ts +9 -2
  36. package/src/environment.ts +57 -33
  37. package/src/errors.ts +7 -0
  38. package/src/evaluate.ts +92 -32
  39. package/src/exit-codes.ts +4 -2
  40. package/src/instances.ts +5 -5
  41. package/src/java-overrides.ts +2 -2
  42. package/src/levels.ts +138 -90
  43. package/src/liveness-checker.ts +43 -4
  44. package/src/liveness.ts +1 -1
  45. package/src/obligations/index.ts +1 -1
  46. package/src/obligations/normalize.ts +1 -4
  47. package/src/obligations/printer.ts +5 -5
  48. package/src/parallel-worker.ts +8 -2
  49. package/src/parallel.ts +5 -0
  50. package/src/parser.ts +106 -144
  51. package/src/prover/isabelle/isar/attrib.ts +4 -4
  52. package/src/prover/isabelle/isar/rule-cases.ts +8 -6
  53. package/src/prover/isabelle/provers/clasimp.ts +1 -1
  54. package/src/prover/isabelle/provers/hypsubst.ts +2 -2
  55. package/src/prover/isabelle/pure/rewriter.ts +3 -3
  56. package/src/prover/isabelle/pure/term.ts +3 -3
  57. package/src/prover/prep/md5.ts +26 -29
  58. package/src/prover/smt/rewrite.ts +2 -7
  59. package/src/prover/smt/simplify.ts +1 -1
  60. package/src/prover/smt/solver/asserted-formulas.ts +66 -1
  61. package/src/prover/smt/solver/ast-lt.ts +1 -1
  62. package/src/prover/smt/solver/ast.ts +58 -11
  63. package/src/prover/smt/solver/blast-term-ite.ts +47 -0
  64. package/src/prover/smt/solver/bound-simplifier.ts +2 -3
  65. package/src/prover/smt/solver/bv-decl-plugin.ts +13 -10
  66. package/src/prover/smt/solver/bv-rewriter.ts +1 -1
  67. package/src/prover/smt/solver/card2bv.ts +3 -5
  68. package/src/prover/smt/solver/cofactor-elim-term-ite.ts +2 -3
  69. package/src/prover/smt/solver/context.ts +24 -3
  70. package/src/prover/smt/solver/ctx-simplify.ts +1 -2
  71. package/src/prover/smt/solver/datatype-decl-plugin.ts +15 -7
  72. package/src/prover/smt/solver/dependent-expr-state.ts +9 -4
  73. package/src/prover/smt/solver/diff-neq.ts +1 -2
  74. package/src/prover/smt/solver/elim-term-ite-tactic.ts +48 -0
  75. package/src/prover/smt/solver/elim-uncnstr.ts +4 -7
  76. package/src/prover/smt/solver/euf/arith-internalize.ts +1 -1
  77. package/src/prover/smt/solver/euf/array-internalize.ts +1 -1
  78. package/src/prover/smt/solver/euf/bv-internalize.ts +1 -1
  79. package/src/prover/smt/solver/euf/egraph.ts +4 -10
  80. package/src/prover/smt/solver/euf/euf-solver.ts +1 -2
  81. package/src/prover/smt/solver/euf/mam.ts +1 -5
  82. package/src/prover/smt/solver/euf/q-ematch.ts +1 -2
  83. package/src/prover/smt/solver/euf/th-solver.ts +0 -7
  84. package/src/prover/smt/solver/expr2polynomial.ts +204 -79
  85. package/src/prover/smt/solver/factor.ts +36 -14
  86. package/src/prover/smt/solver/fd-solver.ts +2 -0
  87. package/src/prover/smt/solver/fix-dl-var.ts +1 -2
  88. package/src/prover/smt/solver/fpa-rewriter.ts +1 -2
  89. package/src/prover/smt/solver/fpa2bv-converter.ts +3 -1
  90. package/src/prover/smt/solver/fpa2bv-rewriter.ts +1 -0
  91. package/src/prover/smt/solver/goal.ts +6 -3
  92. package/src/prover/smt/solver/goal2nlsat.ts +57 -30
  93. package/src/prover/smt/solver/hashtable.ts +4 -0
  94. package/src/prover/smt/solver/logic-tactics.ts +9 -2
  95. package/src/prover/smt/solver/lp/containers.ts +7 -1
  96. package/src/prover/smt/solver/lp/cross-nested.ts +1 -3
  97. package/src/prover/smt/solver/lp/lp-settings.ts +1 -1
  98. package/src/prover/smt/solver/lp/nex-creator.ts +3 -2
  99. package/src/prover/smt/solver/lp/nex.ts +2 -1
  100. package/src/prover/smt/solver/lp/nla-core.ts +1 -1
  101. package/src/prover/smt/solver/lp/nla-grobner.ts +158 -80
  102. package/src/prover/smt/solver/lp/nra-solver.ts +45 -39
  103. package/src/prover/smt/solver/lp/pdd-interval.ts +6 -2
  104. package/src/prover/smt/solver/lp/pdd-simplifier.ts +60 -20
  105. package/src/prover/smt/solver/lp/pdd-solver.ts +72 -39
  106. package/src/prover/smt/solver/lp/pdd.ts +725 -290
  107. package/src/prover/smt/solver/lp/union-find.ts +1 -1
  108. package/src/prover/smt/solver/mam-compiler.ts +1 -1
  109. package/src/prover/smt/solver/model-based-opt.ts +1 -1
  110. package/src/prover/smt/solver/model-generator.ts +3 -1
  111. package/src/prover/smt/solver/mpf.ts +2 -4
  112. package/src/prover/smt/solver/mus.ts +2 -3
  113. package/src/prover/smt/solver/muz/dl-context.ts +10 -4
  114. package/src/prover/smt/solver/muz/dl-mk-slice.ts +3 -3
  115. package/src/prover/smt/solver/muz/dl-rule.ts +2 -2
  116. package/src/prover/smt/solver/muz/horn-subsume-model-converter.ts +1 -1
  117. package/src/prover/smt/solver/muz/horn-tactic.ts +1 -1
  118. package/src/prover/smt/solver/muz/spacer-context.ts +2 -4
  119. package/src/prover/smt/solver/muz/spacer-pdr.ts +1 -0
  120. package/src/prover/smt/solver/nlqsat.ts +1 -1
  121. package/src/prover/smt/solver/nlsat/algebraic.ts +196 -92
  122. package/src/prover/smt/solver/nlsat/atoms.ts +52 -33
  123. package/src/prover/smt/solver/nlsat/explain.ts +375 -217
  124. package/src/prover/smt/solver/nlsat/levelwise.ts +460 -240
  125. package/src/prover/smt/solver/nlsat/polynomial.ts +2366 -681
  126. package/src/prover/smt/solver/nlsat/solver.ts +74 -64
  127. package/src/prover/smt/solver/nlsat/transcendentals.ts +41 -17
  128. package/src/prover/smt/solver/nlsat/upolynomial-factorization.ts +8 -4
  129. package/src/prover/smt/solver/nlsat/upolynomial.ts +41 -18
  130. package/src/prover/smt/solver/nlsat-tactic.ts +1 -1
  131. package/src/prover/smt/solver/nnf.ts +6 -2
  132. package/src/prover/smt/solver/opt-context.ts +9 -3
  133. package/src/prover/smt/solver/opt-nlsat.ts +29 -18
  134. package/src/prover/smt/solver/opt-preprocess.ts +1 -1
  135. package/src/prover/smt/solver/opt-solver.ts +6 -3
  136. package/src/prover/smt/solver/optsmt.ts +1 -1
  137. package/src/prover/smt/solver/pb-rewriter.ts +1 -4
  138. package/src/prover/smt/solver/poly-rewriter.ts +74 -18
  139. package/src/prover/smt/solver/probes.ts +88 -23
  140. package/src/prover/smt/solver/proto-model.ts +4 -6
  141. package/src/prover/smt/solver/qe-arith-plugin.ts +2 -4
  142. package/src/prover/smt/solver/qe-lite.ts +2 -2
  143. package/src/prover/smt/solver/qe.ts +3 -2
  144. package/src/prover/smt/solver/quantifier-manager.ts +14 -9
  145. package/src/prover/smt/solver/recfun-decl-plugin.ts +2 -1
  146. package/src/prover/smt/solver/rlimit.ts +4 -0
  147. package/src/prover/smt/solver/sat/config.ts +1 -1
  148. package/src/prover/smt/solver/sat/inc-sat-solver.ts +26 -1
  149. package/src/prover/smt/solver/sat/model-converter.ts +1 -1
  150. package/src/prover/smt/solver/sat/pb-solver.ts +1 -1
  151. package/src/prover/smt/solver/sat/sat-tactic.ts +4 -3
  152. package/src/prover/smt/solver/sat/simplifier.ts +1 -1
  153. package/src/prover/smt/solver/sat/solver.ts +25 -47
  154. package/src/prover/smt/solver/seq-axioms.ts +20 -35
  155. package/src/prover/smt/solver/seq-decl-plugin.ts +1 -1
  156. package/src/prover/smt/solver/seq-derive.ts +4 -7
  157. package/src/prover/smt/solver/seq-eq-solver.ts +2 -2
  158. package/src/prover/smt/solver/seq-monadic.ts +7 -5
  159. package/src/prover/smt/solver/seq-re-rewriter.ts +2 -1
  160. package/src/prover/smt/solver/seq-re-util.ts +1 -1
  161. package/src/prover/smt/solver/seq-regex-bisim.ts +1 -1
  162. package/src/prover/smt/solver/seq-regex-live.ts +2 -2
  163. package/src/prover/smt/solver/seq-rewriter.ts +31 -29
  164. package/src/prover/smt/solver/seq-skolem.ts +0 -23
  165. package/src/prover/smt/solver/seq-view-witness.ts +4 -4
  166. package/src/prover/smt/solver/smt-kernel.ts +9 -3
  167. package/src/prover/smt/solver/smt-setup.ts +68 -6
  168. package/src/prover/smt/solver/smtlib-parser.ts +558 -220
  169. package/src/prover/smt/solver/smtlib-script.ts +495 -153
  170. package/src/prover/smt/solver/solve-eqs.ts +13 -21
  171. package/src/prover/smt/solver/tactic.ts +219 -130
  172. package/src/prover/smt/solver/theory-bv.ts +2 -2
  173. package/src/prover/smt/solver/theory-lra-final-check.ts +1 -1
  174. package/src/prover/smt/solver/theory-lra-internalize.ts +1 -0
  175. package/src/prover/smt/solver/theory-lra-propagate.ts +6 -4
  176. package/src/prover/smt/solver/theory-lra.ts +0 -1
  177. package/src/prover/smt/solver/theory-pb.ts +24 -7
  178. package/src/prover/smt/solver/theory-seq-solve.ts +1 -1
  179. package/src/prover/smt/solver/theory-seq-state.ts +2 -21
  180. package/src/prover/tlapm/cache.ts +8 -8
  181. package/src/prover/zenon/equality-rules.ts +24 -0
  182. package/src/prover/zenon/expr.ts +21 -0
  183. package/src/prover/zenon/index-table.ts +7 -2
  184. package/src/prover/zenon/isar-case.ts +1 -1
  185. package/src/prover/zenon/isar.ts +2 -2
  186. package/src/prover/zenon/phrase.ts +1 -1
  187. package/src/prover/zenon/rules.ts +2 -1
  188. package/src/resolve.ts +624 -187
  189. package/src/runtime.ts +3 -1
  190. package/src/sany/builtins.ts +10 -10
  191. package/src/sany/generation.ts +2 -13
  192. package/src/sany/generator-definitions.ts +3 -1
  193. package/src/sany/generator-expressions.ts +36 -30
  194. package/src/sany/generator-proofs.ts +5 -3
  195. package/src/sany/generator.ts +2 -1
  196. package/src/sany/lexer.ts +3 -3
  197. package/src/sany/modules.ts +4 -2
  198. package/src/sany/nodes.ts +1 -1
  199. package/src/sany/selectors.ts +11 -6
  200. package/src/sany/xml.ts +2 -3
  201. package/src/search.ts +51 -22
  202. package/src/spec-description.ts +2 -2
  203. package/src/subexpressions.ts +265 -94
  204. package/src/successors.ts +1 -0
  205. package/src/symmetry.ts +1 -1
  206. package/src/tlc/jar-data.ts +10 -0
  207. package/src/tlc/messages.ts +3 -3
  208. package/src/tlc/order.ts +14 -3
  209. package/src/tlc/tlc-operators.ts +3 -1
  210. package/src/tlc/tlcext-operators.ts +18 -5
  211. package/src/tlc/trace-spec.ts +5 -5
  212. package/src/typed-tier.ts +29 -23
  213. package/src/typescript/types.ts +2 -2
  214. package/src/values.ts +46 -27
@@ -16,15 +16,21 @@ import {
16
16
  } from "./ast";
17
17
  import { formatRange, TlaSyntaxError } from "./errors";
18
18
  import { getSourceName, mapChildren, mapDefinition } from "./instances";
19
+ import { resolveSynonym } from "./tlc/jar-data";
19
20
  import {
20
21
  getArity,
21
22
  getBinder,
22
23
  getNameSelectors,
23
24
  getOperandIndex,
24
25
  getOperands,
26
+ getParamArities,
27
+ isBefore,
25
28
  LOCAL_RESOLUTION,
29
+ nullSelections,
26
30
  selectionErrors,
27
31
  selections,
32
+ type NullSelection,
33
+ type SelectionArguments,
28
34
  } from "./resolve";
29
35
 
30
36
  type Lookup = (name: string) => Definition | undefined;
@@ -49,6 +55,29 @@ interface SelectingName {
49
55
 
50
56
  const SELECTION_NAME = "$subexpression";
51
57
 
58
+ const getSelectorName = (selector: Selector) => {
59
+ switch (selector.kind) {
60
+ case "Name":
61
+ return selector.name;
62
+ case "Operand":
63
+ return typeof selector.operand === "number"
64
+ ? `argument selector ${selector.operand}`
65
+ : selector.operand;
66
+ case "Bound":
67
+ return "!(...)";
68
+ case "At":
69
+ return "@";
70
+ case "Colon":
71
+ return ":";
72
+ }
73
+ };
74
+
75
+ const getExpressionArguments = (
76
+ operator: string,
77
+ range: SourceRange | undefined,
78
+ args: Expression[],
79
+ ): SelectionArguments => ({ operator, range, args, params: args.map(() => 0) });
80
+
52
81
  const createError = (message: string, location: SourceLocation) =>
53
82
  new TlaSyntaxError(`${message} at line ${location.line}, column ${location.column}`);
54
83
 
@@ -152,21 +181,26 @@ const applyDefinition = (definition: Definition, selection: Selection) => {
152
181
  const selectSubexpression = (
153
182
  selectors: Selector[],
154
183
  lookup: Lookup,
184
+ isGoal: (name: string) => boolean,
155
185
  reference: Expression & SelectingName,
156
186
  isOperator: boolean,
157
187
  ): Expression => {
158
188
  const location = reference.location;
159
189
  const selection: Selection = { params: [], args: [], lets: [], location };
160
190
  let selectorIndex = 0;
161
- let current = undefined as Expression | undefined;
191
+ let current: Expression | undefined;
162
192
  let isFailed = false;
193
+ const nulls: NullSelection[] = [];
194
+ const applications: SelectionArguments[] = [];
195
+ const checkNull = (node: Expression | undefined, message: string) => {
196
+ const range = reference.selectorRanges?.[selectorIndex];
197
+ if (node && range) nulls.push({ node, error: { location: formatRange(range), message } });
198
+ };
163
199
 
164
200
  const report = (range: SourceRange | undefined, message: string) => {
165
201
  if (!range) throw createError(message, location);
166
202
  selectionErrors.set(reference, {
167
- args: selectors
168
- .slice(0, selectorIndex)
169
- .flatMap((selector) => ("args" in selector ? selector.args : [])),
203
+ applications,
170
204
  error: { location: formatRange(range), message },
171
205
  });
172
206
  isFailed = true;
@@ -178,6 +212,7 @@ const selectSubexpression = (
178
212
  const args: Expression[] = [];
179
213
  while (selectorIndex < selectors.length) {
180
214
  const selector = selectors[selectorIndex];
215
+ if (selector.kind !== "Name" && !local) return undefined;
181
216
  if (selector.kind !== "Name") throw createError("Expected an operator name", location);
182
217
  names.push(selector.name);
183
218
  args.push(...selector.args);
@@ -194,16 +229,38 @@ const selectSubexpression = (
194
229
 
195
230
  const enterDefinition = (local: Definition[] | undefined) => {
196
231
  const found = findDefinition(local);
232
+ if (!found) {
233
+ isFailed = true;
234
+ return undefined;
235
+ }
197
236
  const definition = found.definition;
198
237
  const arity = getArity(definition);
199
238
  const isLast = selectorIndex === selectors.length - 1;
200
239
  if (found.args.length !== arity && (!isOperator || found.args.length !== 0)) {
201
240
  return report(
202
241
  reference.argumentRanges?.[selectorIndex] ?? location.range,
203
- `The operator ${found.name} requires ${arity - found.earlier} arguments.`,
242
+ `The operator ${resolveSynonym(found.name)} requires ${arity - found.earlier} arguments.`,
204
243
  );
205
244
  }
206
245
  if (isLast) return { definition, args: found.args };
246
+ applications.push({
247
+ operator: found.name,
248
+ range: reference.selectorRanges?.[selectorIndex],
249
+ args: found.args,
250
+ params: getParamArities(definition),
251
+ });
252
+ const range = definition.location.range;
253
+ if (
254
+ definition.isRecursive &&
255
+ range &&
256
+ range.module === location.range?.module &&
257
+ isBefore(location, range.end)
258
+ ) {
259
+ return report(
260
+ reference.selectorRanges?.[selectorIndex],
261
+ `Subexpression of \`${found.name}' used inside the operator's definition.`,
262
+ );
263
+ }
207
264
  if (definition.kind !== "Operator") {
208
265
  throw createError(`Cannot select a subexpression of ${definition.name}`, location);
209
266
  }
@@ -228,6 +285,7 @@ const selectSubexpression = (
228
285
  selection.lets.push(...found.lets);
229
286
  selection.params.push(...params.map((name) => ({ name, arity: 0 })));
230
287
  selection.args.push(...selector.args);
288
+ applications.push(getExpressionArguments(selector.name, range, selector.args));
231
289
  current = found.label.body;
232
290
  selectorIndex++;
233
291
  }
@@ -236,14 +294,42 @@ const selectSubexpression = (
236
294
  const selectOperand = (selector: Selector) => {
237
295
  if (!current) throw createError("Subexpression selection failed", location);
238
296
  if (selector.kind === "Colon") return;
297
+ const range = reference.selectorRanges?.[selectorIndex];
298
+ const currentRange = current.location.range;
299
+ if (
300
+ (current.kind === "Subexpression" ||
301
+ (current.kind === "Identifier" && current.name.includes("!")) ||
302
+ (current.kind === "Apply" && current.operator.includes("!"))) &&
303
+ (currentRange?.module !== location.range?.module || isBefore(current.location, location))
304
+ ) {
305
+ const selected = resolveSubexpressions(current, lookup, isGoal);
306
+ if (selectionErrors.has(selected)) {
307
+ report(
308
+ range,
309
+ `Choosing operand \`${getSelectorName(selector)}' of subexpression with no operands.`,
310
+ );
311
+ return;
312
+ }
313
+ if (selections.has(selected) && selected.kind !== "Lambda") {
314
+ current =
315
+ selected.kind === "Let" &&
316
+ selected.body.kind === "Apply" &&
317
+ selected.body.operator === SELECTION_NAME
318
+ ? selected.body
319
+ : // SANY wraps a selection without parameters in $Nop, whose only operand is the selection.
320
+ { kind: "Tuple", elements: [selected], location: selected.location };
321
+ }
322
+ }
239
323
  if (current.kind === "Label") {
240
324
  current = current.body;
241
325
  selectOperand(selector);
242
326
  return;
243
327
  }
328
+ const nonexistent = `Nonexistent operand specified by \`${getSelectorName(selector)}'.`;
244
329
  if (current.kind === "Let") {
245
330
  if (selector.kind !== "Operand" || getOperandIndex(selector.operand, 1) !== 0) {
246
- throw createError("A LET/IN expression has only one operand", location);
331
+ report(range, "A LET/IN expression has only one operand.");
332
+ return;
247
333
  }
248
334
  selection.lets.push(current.definitions);
249
335
  current = current.body;
@@ -252,32 +338,63 @@ const selectSubexpression = (
252
338
  const binder = getBinder(current);
253
339
  if (binder && (selector.kind === "Bound" || selector.kind === "At")) {
254
340
  selection.params.push(...binder.names.map((name) => ({ name, arity: 0 })));
255
- if (selector.kind === "Bound") selection.args.push(...selector.args);
341
+ if (selector.kind === "Bound") {
342
+ selection.args.push(...selector.args);
343
+ applications.push(getExpressionArguments("", range, selector.args));
344
+ }
256
345
  current = binder.body;
257
346
  return;
258
347
  }
259
- if (current.kind === "Case" && selector.kind === "Operand") {
348
+ if (current.kind === "Case") {
260
349
  const arms = [
261
350
  ...current.arms,
262
351
  ...(current.other ? [{ condition: undefined, body: current.other }] : []),
263
352
  ];
264
- const arm = arms[getOperandIndex(selector.operand, arms.length)];
265
- const next = selectors[selectorIndex + 1];
266
- if (!arm || next?.kind !== "Operand") {
267
- throw createError("A subexpression of CASE must have the form !i!j", location);
353
+ if (selectorIndex === selectors.length - 1) {
354
+ report(range, "Subexpression of CASE must have form !i!j.");
355
+ return;
356
+ }
357
+ const arm =
358
+ selector.kind === "Operand"
359
+ ? arms[getOperandIndex(selector.operand, arms.length)]
360
+ : undefined;
361
+ if (!arm) {
362
+ report(range, nonexistent);
363
+ return;
268
364
  }
269
365
  selectorIndex++;
270
- const part = getOperandIndex(next.operand, 2);
271
- const chosen = part === 0 ? arm.condition : part === 1 ? arm.body : undefined;
272
- if (!chosen) throw createError("Nonexistent CASE operand", location);
366
+ const next = selectors[selectorIndex];
367
+ const part = next.kind === "Operand" ? getOperandIndex(next.operand, 2) : -1;
368
+ const nextRange = reference.selectorRanges?.[selectorIndex];
369
+ if (part === -1) {
370
+ report(
371
+ nextRange,
372
+ "Second selector for CASE subexpression must specify one of two operands.",
373
+ );
374
+ return;
375
+ }
376
+ const chosen = part === 0 ? arm.condition : arm.body;
377
+ if (!chosen) {
378
+ report(nextRange, "Selecting OTHER in a CASE statement.");
379
+ return;
380
+ }
273
381
  current = chosen;
274
382
  return;
275
383
  }
276
- if (selector.kind !== "Operand")
277
- throw createError("Unexpected subexpression selector", location);
278
384
  const operands = binder ? binder.sets : getOperands(current);
385
+ if (!operands && current.kind !== "Identifier") {
386
+ report(range, "Selecting subexpression of expression that has none.");
387
+ return;
388
+ }
389
+ if (selector.kind !== "Operand") {
390
+ report(range, nonexistent);
391
+ return;
392
+ }
279
393
  const operand = operands?.[getOperandIndex(selector.operand, operands.length)];
280
- if (!operand) throw createError("Nonexistent operand specified by the selector", location);
394
+ if (!operand) {
395
+ report(range, nonexistent);
396
+ return;
397
+ }
281
398
  current = operand;
282
399
  };
283
400
 
@@ -304,12 +421,30 @@ const selectSubexpression = (
304
421
  followLabels();
305
422
  continue;
306
423
  }
424
+ if (selector.kind !== "Colon") {
425
+ checkNull(
426
+ current,
427
+ "Subexpression selection failed, probably due to an error in the selected expression.",
428
+ );
429
+ }
307
430
  selectOperand(selector);
431
+ checkNull(
432
+ current,
433
+ `An unexpected null node specified by '${getSelectorName(selectors[selectorIndex])}'.\nThis is probably due to a previous error.`,
434
+ );
308
435
  selectorIndex++;
309
436
  }
310
437
  if (isFailed) return reference;
311
438
  if (!current) throw createError("Subexpression selection failed", location);
312
- return createApplication(selection, current);
439
+ const params = selection.params.length;
440
+ const args = selection.args.length;
441
+ if (params !== args && (!isOperator || args > 0)) {
442
+ report(location.range, `Expected ${params} arguments but found ${args}.`);
443
+ return reference;
444
+ }
445
+ const selected = createApplication(selection, current);
446
+ nullSelections.set(selected, nulls);
447
+ return selected;
313
448
  };
314
449
 
315
450
  const getQualifiedSelectors = (
@@ -373,7 +508,8 @@ const resolveSubexpressions = (
373
508
  : undefined;
374
509
  const first = selectors?.[0];
375
510
  if (!selectors || (first?.kind === "Name" && isGoal(first.name))) return mapped;
376
- const selected = selectSubexpression(selectors, lookup, mapped, isOperator);
511
+ if (first?.kind === "Name" && selectors[1].kind !== "Name" && !lookup(first.name)) return mapped;
512
+ const selected = selectSubexpression(selectors, lookup, isGoal, mapped, isOperator);
377
513
  if (selected !== mapped) selections.add(selected);
378
514
  return selected;
379
515
  };
@@ -427,89 +563,122 @@ export const resolveModuleSubexpressions = (module: Module, available: Definitio
427
563
  },
428
564
  ];
429
565
  });
430
- const lookup = createLookup([...available, ...module.definitions]);
566
+ const own = new Set([...module.definitions, ...clauses]);
567
+ const recursive = new Map(
568
+ module.units.flatMap((unit): [string, SourceLocation][] =>
569
+ unit.kind === "Recursive"
570
+ ? unit.declarations.map((declaration) => [declaration.name, declaration.location])
571
+ : [],
572
+ ),
573
+ );
574
+ const isDeclaredBefore = (definition: Definition, location: SourceLocation) => {
575
+ const declared = recursive.get(definition.name);
576
+ return (
577
+ isBefore(definition.location, location) ||
578
+ (definition.isRecursive && declared !== undefined && isBefore(declared, location))
579
+ );
580
+ };
581
+ const getVisibleLookup =
582
+ (lookup: Lookup, location: SourceLocation): Lookup =>
583
+ (name) => {
584
+ const definition = lookup(name);
585
+ return definition && (!own.has(definition) || isDeclaredBefore(definition, location))
586
+ ? definition
587
+ : undefined;
588
+ };
589
+ const proofLookup = createLookup([...available, ...module.definitions]);
431
590
  const isGoal = (name: string) => goals.has(name);
432
591
  const definitionLookup = createLookup([...available, ...module.definitions, ...clauses]);
433
- const resolve = (expression: Expression) =>
592
+ const resolve = (expression: Expression, location: SourceLocation) =>
434
593
  resolveSubexpressions(
435
594
  expression,
436
- definitionLookup,
595
+ getVisibleLookup(definitionLookup, location),
437
596
  (name) => isGoal(name) && clauses.every((clause) => clause.name !== name),
438
597
  );
439
- const isProofGoal = (name: string) => isGoal(name) || !lookup(name);
440
- const resolveInProof = (expression: Expression) =>
441
- resolveSubexpressions(expression, lookup, isProofGoal);
442
- const resolveFacts = (facts: Fact[]) =>
443
- facts.map((fact) => (fact.kind === "ModuleFact" ? fact : resolveInProof(fact)));
444
- const resolveBounds = (bounds: Bound[]) =>
445
- bounds.map((bound) => ({ ...bound, set: resolveInProof(bound.set) }));
446
- const resolveStatement = (statement: Expression | AssumeProve): Expression | AssumeProve =>
447
- statement.kind === "AssumeProve"
448
- ? {
449
- ...statement,
450
- assumptions: statement.assumptions.map((assumption) =>
451
- assumption.kind === "NewSymbol"
452
- ? { ...assumption, set: assumption.set && resolveInProof(assumption.set) }
453
- : resolveStatement(assumption),
454
- ),
455
- conclusion: resolveInProof(statement.conclusion),
456
- }
457
- : resolveInProof(statement);
458
- const resolveStep = (body: StepBody): StepBody => {
459
- switch (body.kind) {
460
- case "Use":
461
- case "Hide":
462
- return { ...body, facts: resolveFacts(body.facts) };
463
- case "Instance":
464
- return resolveInstance(body, lookup, isProofGoal);
465
- case "Define":
466
- return {
467
- ...body,
468
- definitions: body.definitions.map((definition) =>
469
- definition.kind === "Instance"
470
- ? resolveInstance(definition, lookup, isProofGoal)
471
- : mapDefinition(definition, resolveInProof),
472
- ),
473
- };
474
- case "Have":
475
- case "Case":
476
- return { ...body, expression: resolveInProof(body.expression) };
477
- case "Witness":
478
- return { ...body, expressions: body.expressions.map(resolveInProof) };
479
- case "Take":
480
- return { ...body, bounds: resolveBounds(body.bounds) };
481
- case "Pick":
482
- return { ...body, bounds: resolveBounds(body.bounds), body: resolveInProof(body.body) };
483
- case "Assert":
484
- return { ...body, statement: resolveStatement(body.statement) };
485
- default:
486
- return body;
487
- }
488
- };
489
- const resolveProof = (proof: Proof | undefined): Proof | undefined =>
490
- proof?.kind === "By"
491
- ? { ...proof, facts: resolveFacts(proof.facts) }
492
- : proof?.kind === "Steps"
598
+ const createProofResolver = (location: SourceLocation) => {
599
+ const lookup = getVisibleLookup(proofLookup, location);
600
+ const isProofGoal = (name: string) => isGoal(name) || !lookup(name);
601
+ const resolveInProof = (expression: Expression) =>
602
+ resolveSubexpressions(expression, lookup, isProofGoal);
603
+ const resolveFacts = (facts: Fact[]) =>
604
+ facts.map((fact) => (fact.kind === "ModuleFact" ? fact : resolveInProof(fact)));
605
+ const resolveBounds = (bounds: Bound[]) =>
606
+ bounds.map((bound) => ({ ...bound, set: resolveInProof(bound.set) }));
607
+ const resolveStatement = (statement: Expression | AssumeProve): Expression | AssumeProve =>
608
+ statement.kind === "AssumeProve"
493
609
  ? {
494
- ...proof,
495
- steps: proof.steps.map((step) => ({
496
- ...step,
497
- body: resolveStep(step.body),
498
- proof: resolveProof(step.proof),
499
- })),
610
+ ...statement,
611
+ assumptions: statement.assumptions.map((assumption) =>
612
+ assumption.kind === "NewSymbol"
613
+ ? { ...assumption, set: assumption.set && resolveInProof(assumption.set) }
614
+ : resolveStatement(assumption),
615
+ ),
616
+ conclusion: resolveInProof(statement.conclusion),
500
617
  }
501
- : proof;
618
+ : resolveInProof(statement);
619
+ const resolveStep = (body: StepBody): StepBody => {
620
+ switch (body.kind) {
621
+ case "Use":
622
+ case "Hide":
623
+ return { ...body, facts: resolveFacts(body.facts) };
624
+ case "Instance":
625
+ return resolveInstance(body, lookup, isProofGoal);
626
+ case "Define":
627
+ return {
628
+ ...body,
629
+ definitions: body.definitions.map((definition) =>
630
+ definition.kind === "Instance"
631
+ ? resolveInstance(definition, lookup, isProofGoal)
632
+ : mapDefinition(definition, resolveInProof),
633
+ ),
634
+ };
635
+ case "Have":
636
+ case "Case":
637
+ return { ...body, expression: resolveInProof(body.expression) };
638
+ case "Witness":
639
+ return { ...body, expressions: body.expressions.map(resolveInProof) };
640
+ case "Take":
641
+ return { ...body, bounds: resolveBounds(body.bounds) };
642
+ case "Pick":
643
+ return { ...body, bounds: resolveBounds(body.bounds), body: resolveInProof(body.body) };
644
+ case "Assert":
645
+ return { ...body, statement: resolveStatement(body.statement) };
646
+ default:
647
+ return body;
648
+ }
649
+ };
650
+ const resolveProof = (proof: Proof | undefined): Proof | undefined =>
651
+ proof?.kind === "By"
652
+ ? { ...proof, facts: resolveFacts(proof.facts) }
653
+ : proof?.kind === "Steps"
654
+ ? {
655
+ ...proof,
656
+ steps: proof.steps.map((step) => ({
657
+ ...step,
658
+ body: resolveStep(step.body),
659
+ proof: resolveProof(step.proof),
660
+ })),
661
+ }
662
+ : proof;
663
+ return { resolveFacts, resolveStatement, resolveProof };
664
+ };
502
665
  const resolved = {
503
666
  ...module,
504
- theorems: module.theorems.map((theorem) => ({
505
- ...theorem,
506
- statement:
507
- theorem.name !== undefined && theorem.statement.kind !== "AssumeProve"
508
- ? theorem.statement
509
- : resolveStatement(theorem.statement),
510
- proof: resolveProof(theorem.proof),
667
+ theorems: module.theorems.map((theorem) => {
668
+ const resolver = createProofResolver(theorem.location);
669
+ return {
670
+ ...theorem,
671
+ statement:
672
+ theorem.name !== undefined && theorem.statement.kind !== "AssumeProve"
673
+ ? theorem.statement
674
+ : resolver.resolveStatement(theorem.statement),
675
+ proof: resolver.resolveProof(theorem.proof),
676
+ };
677
+ }),
678
+ uses: module.uses.map((use) => ({
679
+ ...use,
680
+ facts: createProofResolver(use.location).resolveFacts(use.facts),
511
681
  })),
512
- uses: module.uses.map((use) => ({ ...use, facts: resolveFacts(use.facts) })),
513
682
  };
514
683
  const hasReferences =
515
684
  module.definitions.some((definition) => containsReference(definition.body)) ||
@@ -517,10 +686,12 @@ export const resolveModuleSubexpressions = (module: Module, available: Definitio
517
686
  if (!hasReferences) return resolved;
518
687
  return {
519
688
  ...resolved,
520
- definitions: module.definitions.map((definition) => mapDefinition(definition, resolve)),
689
+ definitions: module.definitions.map((definition) =>
690
+ mapDefinition(definition, (expression) => resolve(expression, definition.location)),
691
+ ),
521
692
  assumptions: module.assumptions.map((assumption) => ({
522
693
  ...assumption,
523
- expression: resolve(assumption.expression),
694
+ expression: resolve(assumption.expression, assumption.location),
524
695
  })),
525
696
  };
526
697
  };
package/src/successors.ts CHANGED
@@ -723,6 +723,7 @@ const compileIdentifier = (
723
723
  !definition ||
724
724
  (expression.location.range && getStartupValue(definition, environment) !== undefined)
725
725
  ) {
726
+ // Deviation from TLC: Tool#getInitStates prints an unassigned variable's declaration as the non-boolean value it found.
726
727
  guard(run, scope, partial, action, isFixed, onComplete);
727
728
  return;
728
729
  }
package/src/symmetry.ts CHANGED
@@ -24,7 +24,7 @@ export type Images = Map<string, ModelValue>;
24
24
 
25
25
  const getPermutationKey = (permutation: Images) =>
26
26
  [...permutation]
27
- .map(([name, image]) => `${name}>${image.name}`)
27
+ .map((entry) => `${entry[0]}>${entry[1].name}`)
28
28
  .sort()
29
29
  .join(",");
30
30
 
@@ -143,6 +143,16 @@ export const SANY_OPERATOR_SYNONYMS = [
143
143
  ["^+", "⁺"],
144
144
  ];
145
145
 
146
+ const SYNONYMS = new Map(
147
+ SANY_OPERATOR_SYNONYMS.flatMap((names) => names.slice(1).map((synonym) => [synonym, names[0]])),
148
+ );
149
+
150
+ export const resolveSynonym = (name: string) =>
151
+ name
152
+ .split("!")
153
+ .map((part) => SYNONYMS.get(part) ?? (part === "~" ? "\\lnot" : part))
154
+ .join("!");
155
+
146
156
  export const TLC_STARTUP_STRINGS = [
147
157
  "STRING",
148
158
  "FALSE",
@@ -345,14 +345,14 @@ interface CodedMessage {
345
345
  let codedMessagePatterns: { pattern: RegExp; message: CodedMessage }[] | undefined;
346
346
 
347
347
  const getCodedMessagePatterns = () =>
348
- (codedMessagePatterns ??= CODED_MESSAGES.map(([code, template, isEvalException]) => ({
348
+ (codedMessagePatterns ??= CODED_MESSAGES.map((codedMessage) => ({
349
349
  pattern: new RegExp(
350
- `^${template
350
+ `^${codedMessage[1]
351
351
  .split(/%\d+%/)
352
352
  .map((part) => part.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"))
353
353
  .join("[\\s\\S]*")}$`,
354
354
  ),
355
- message: { code, isEvalException },
355
+ message: { code: codedMessage[0], isEvalException: codedMessage[2] },
356
356
  })));
357
357
 
358
358
  const UNCODED_MESSAGE_PATTERN =
package/src/tlc/order.ts CHANGED
@@ -444,7 +444,11 @@ const createContexts = (getParsed: ModuleSet) => {
444
444
  };
445
445
  };
446
446
 
447
- const getStringOrder = (getParsed: ModuleSet, config: ModelConfig): string[] => {
447
+ const getStringOrder = (
448
+ getParsed: ModuleSet,
449
+ config: ModelConfig,
450
+ runtimeModules: string[],
451
+ ): string[] => {
448
452
  const order = new Set<string>();
449
453
  const intern = (text: string) => {
450
454
  order.add(text);
@@ -541,12 +545,19 @@ const getStringOrder = (getParsed: ModuleSet, config: ModelConfig): string[] =>
541
545
  });
542
546
  };
543
547
  analyze(undefined);
548
+ runtimeModules.forEach((name) => {
549
+ const tokens = getUnitTokens(name);
550
+ getParsedTexts(tokens).forEach(intern);
551
+ tokens.forEach((token) => {
552
+ if (token.kind === "String") intern(token.text);
553
+ });
554
+ });
544
555
  TLC_RUNTIME_STRINGS.forEach(intern);
545
556
  return [...order];
546
557
  };
547
558
 
548
559
  export interface TlcOrder {
549
- getStringOrder: (config: ModelConfig) => string[];
560
+ getStringOrder: (config: ModelConfig, runtimeModules: string[]) => string[];
550
561
  getDeclarationOrder: (kind: "variable" | "constant") => string[];
551
562
  createDefinitionOrder: () => (name: string | undefined) => string[];
552
563
  parseModule: (source: string) => Module;
@@ -558,7 +569,7 @@ export const createTlcOrder = (source: string, loadModule: ModuleLoader): TlcOrd
558
569
  let contexts: ReturnType<typeof createContexts> | undefined;
559
570
  const getContexts = () => (contexts ??= createContexts(getParsed));
560
571
  return {
561
- getStringOrder: (config) => getStringOrder(getParsed, config),
572
+ getStringOrder: (config, runtimeModules) => getStringOrder(getParsed, config, runtimeModules),
562
573
  getDeclarationOrder: (kind) =>
563
574
  getContexts()
564
575
  .getContext(undefined)
@@ -43,7 +43,9 @@ const formatCalendarVersion = (date: Date) =>
43
43
  `${date.getUTCFullYear()}.${zeroPad(date.getUTCMonth() + 1)}.${zeroPad(date.getUTCDate())}.${zeroPad(date.getUTCHours())}${zeroPad(date.getUTCMinutes())}${zeroPad(date.getUTCSeconds())}`;
44
44
 
45
45
  const getRegisterFunction = <Key extends Value>(registers: Map<Key, Value>) =>
46
- createFunction([...registers].map(([key, value]): [Value, Value] => [key, createTuple([value])]));
46
+ createFunction(
47
+ [...registers].map((entry): [Value, Value] => [entry[0], createTuple([entry[1]])]),
48
+ );
47
49
 
48
50
  const createTlcRecord = (fields: [string, Value][]) =>
49
51
  setFunctionClass(createWrittenFunction(fields), "record");
@@ -263,10 +263,13 @@ export const createTlcExtOperators = (
263
263
  defineOperator("TLCNoOp", 1, (args) => getValue(args, 0, "TLCNoOp")),
264
264
  {
265
265
  ...defineLazyOperator("PickSuccessor", 1, (args, context) => {
266
- // Deviation from TLC: TLCExt#pickSuccessor fingerprints a partial successor and fails, where TLCExt.tla promises TRUE.
267
266
  const next = context?.next ?? (context?.environment.variables ?? []).map(() => undefined);
268
- if (!isCompleteState(next)) return true;
269
- if (context?.next && runtime.isSeen(next)) return true;
267
+ // A simulation remembers no states, so TLC evaluates the guard before it looks at the successor.
268
+ if (runtime.getSimulationValue === undefined) {
269
+ // Deviation from TLC: TLCExt#pickSuccessor fingerprints a partial successor and fails, where TLCExt.tla promises TRUE.
270
+ if (!isCompleteState(next)) return true;
271
+ if (context?.next && runtime.isSeen(next)) return true;
272
+ }
270
273
  const guard = getOperator(args, 0, "PickSuccessor");
271
274
  const isPicked = guard.call([]);
272
275
  if (typeof isPicked !== "boolean") {
@@ -274,7 +277,13 @@ export const createTlcExtOperators = (
274
277
  `In evaluating TLCExt!PickSuccessor, a non-boolean expression (${getKindString(isPicked)}) was used as the condition of an IF.\n${guard.expression ? describeNode(guard.expression) : ""}`,
275
278
  );
276
279
  }
277
- if (isPicked || !context?.next || !context.state || !isCompleteState(context.state)) {
280
+ if (
281
+ isPicked ||
282
+ !context?.next ||
283
+ !isCompleteState(next) ||
284
+ !context.state ||
285
+ !isCompleteState(context.state)
286
+ ) {
278
287
  return true;
279
288
  }
280
289
  const state = context.state;
@@ -303,9 +312,13 @@ export const createTlcExtOperators = (
303
312
  } else if (answer[0] === "d") {
304
313
  printOverride(formatState(runtime.toRecord(next), runtime.toRecord(state)));
305
314
  } else if (answer[0] === "e") {
315
+ if (runtime.markExplored) {
316
+ runtime.markExplored(next);
317
+ return true;
318
+ }
306
319
  if (runtime.getSimulationValue === undefined) {
307
320
  throw new TlaUnsupportedError(
308
- "tla-ts can't mark a state explored while it checks a model.",
321
+ "tla-ts can't mark a state explored while it searches depth first.",
309
322
  );
310
323
  }
311
324
  printOverride(