tla-ts 0.0.3-dev.b0f84e8 → 0.0.3-dev.b4e335d

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 (81) hide show
  1. package/dist/cli.cjs +1 -1
  2. package/dist/cli.js +1 -1
  3. package/dist/index.cjs +1 -1
  4. package/dist/index.d.cts +150 -8
  5. package/dist/index.d.ts +150 -8
  6. package/dist/index.js +1 -1
  7. package/dist/parallel-worker.cjs +1 -1
  8. package/dist/parallel-worker.js +2 -2
  9. package/dist/parallel.cjs +1 -1
  10. package/dist/parallel.js +2 -2
  11. package/dist/run-cli.cjs +1351 -20
  12. package/dist/run-cli.js +1351 -20
  13. package/dist/transfer.cjs +86 -28
  14. package/dist/transfer.js +86 -28
  15. package/package.json +5 -1
  16. package/src/ast.ts +57 -6
  17. package/src/bags.ts +4 -7
  18. package/src/builtins.ts +29 -11
  19. package/src/bundled-modules.ts +3 -3
  20. package/src/canonical.ts +4 -3
  21. package/src/check.ts +1393 -226
  22. package/src/cli.ts +8 -1
  23. package/src/codegen.ts +68 -18
  24. package/src/config.ts +252 -179
  25. package/src/environment.ts +457 -132
  26. package/src/errors.ts +217 -3
  27. package/src/evaluate.ts +722 -112
  28. package/src/exit-codes.ts +5 -4
  29. package/src/index.ts +1 -0
  30. package/src/instances.ts +4 -2
  31. package/src/java-overrides.ts +104 -25
  32. package/src/levels.ts +183 -37
  33. package/src/lexer.ts +112 -29
  34. package/src/live-check.ts +220 -102
  35. package/src/liveness.ts +216 -52
  36. package/src/obligation-expression.ts +2 -2
  37. package/src/obligation-source.ts +2 -0
  38. package/src/parallel-worker.ts +8 -3
  39. package/src/parallel.ts +56 -5
  40. package/src/parser.ts +445 -147
  41. package/src/pcal-ast.ts +770 -0
  42. package/src/pcal-parse.ts +1523 -0
  43. package/src/pcal-tokenize.ts +516 -0
  44. package/src/pcal-translate.ts +1230 -0
  45. package/src/pcal-validate.ts +454 -0
  46. package/src/randomization.ts +24 -7
  47. package/src/resolve.ts +1465 -411
  48. package/src/run-cli.ts +1167 -155
  49. package/src/runtime.ts +16 -0
  50. package/src/sany-builtins.ts +147 -0
  51. package/src/sany-generator.ts +3128 -0
  52. package/src/sany-levels.ts +1208 -0
  53. package/src/sany-lexer.ts +545 -0
  54. package/src/sany-linter.ts +122 -0
  55. package/src/sany-modules.ts +1398 -0
  56. package/src/sany-nodes.ts +463 -0
  57. package/src/sany-parse-error.ts +2161 -0
  58. package/src/sany-report.ts +354 -0
  59. package/src/sany-selectors.ts +738 -0
  60. package/src/sany-source.ts +248 -0
  61. package/src/sany-xml.ts +1017 -0
  62. package/src/spec-description.ts +26 -7
  63. package/src/standard-modules.ts +200 -148
  64. package/src/standard-ranges.ts +116 -0
  65. package/src/state-graph.ts +29 -6
  66. package/src/subexpressions.ts +221 -161
  67. package/src/substitution-levels.ts +38 -17
  68. package/src/successors.ts +207 -103
  69. package/src/symmetry.ts +180 -52
  70. package/src/tableau.ts +54 -25
  71. package/src/tlc-ext.ts +13 -17
  72. package/src/tlc-messages.ts +329 -0
  73. package/src/tlc-module.ts +46 -18
  74. package/src/tlc-order.ts +56 -6
  75. package/src/tlc-random.ts +37 -9
  76. package/src/tlc-replay.ts +655 -0
  77. package/src/tlc-summary.ts +20 -5
  78. package/src/tlc-version.ts +18 -0
  79. package/src/transfer.ts +15 -3
  80. package/src/value-sources.ts +29 -0
  81. package/src/values.ts +697 -180
package/src/liveness.ts CHANGED
@@ -1,12 +1,15 @@
1
- import { isLocallyResolved, type Definition, type Expression } from "./ast";
2
- import { TlaConfigError, TlaEvaluationError } from "./errors";
1
+ import { isLocallyResolved, type Bound, type Definition, type Expression } from "./ast";
2
+ import { getUnexpectedException, TlaEvaluationError, TlaStackOverflowError } from "./errors";
3
3
  import {
4
- describeLocation,
4
+ describeNode,
5
+ describeRange,
5
6
  bindDefinitions,
6
7
  bindOperatorArguments,
7
8
  evaluate,
8
9
  expectBoolean,
9
10
  forEachBinding,
11
+ forEachBoundElement,
12
+ getBoundElements,
10
13
  getDefinition,
11
14
  lookupScope,
12
15
  resolveApplyOperator,
@@ -20,6 +23,8 @@ import {
20
23
  import { mapChildren } from "./instances";
21
24
  import { ACTION_LEVEL, TEMPORAL_LEVEL } from "./levels";
22
25
  import { isEnabled } from "./successors";
26
+ import { EXIT_STATUS, setExitCode } from "./exit-codes";
27
+ import { isEvalException } from "./tlc-messages";
23
28
  import {
24
29
  createBoolean,
25
30
  createJunction,
@@ -36,12 +41,27 @@ export interface ScopedExpression {
36
41
  scope: Scope | undefined;
37
42
  }
38
43
 
44
+ // A part of a temporal formula, with the name TLC gives the part when the formula is a property:
45
+ // a conjunct's location, or the name of the definition the part is the body of.
46
+ interface ExpandedExpression extends ScopedExpression {
47
+ name: string | undefined;
48
+ }
49
+
39
50
  export interface TemporalProperty extends ScopedExpression {
40
51
  name: string;
41
52
  }
42
53
 
43
54
  const MAXIMUM_EXPANSION_DEPTH = 100;
44
55
 
56
+ export const createTautologyError = () =>
57
+ setExitCode(
58
+ new TlaEvaluationError("Temporal formula is a tautology (its negation is unsatisfiable)."),
59
+ EXIT_STATUS.livenessEvaluationFailure,
60
+ );
61
+
62
+ // TLC expands a temporal formula that refers to itself until Java's stack overflows.
63
+ const createStackOverflowError = () => setExitCode(new TlaStackOverflowError(), EXIT_STATUS.error);
64
+
45
65
  const TEMPORAL_OPERATORS = new Set(["~>", "-+->"]);
46
66
 
47
67
  const definitionLevels = new WeakMap<Definition, number>();
@@ -55,9 +75,10 @@ const getConstantContext = (environment: Environment, scope: Scope | undefined):
55
75
  next: undefined,
56
76
  });
57
77
 
58
- const createCannotHandleError = (expression: Expression) =>
78
+ // TLC adds the message of the error that stopped it, when it has one.
79
+ const createCannotHandleError = (expression: Expression, inner?: string) =>
59
80
  new TlaEvaluationError(
60
- `TLC cannot handle the temporal formula at ${describeLocation(expression)}`,
81
+ `TLC cannot handle the temporal formula ${describeRange(expression)}${inner === undefined ? "" : `:\n${inner}`}`,
61
82
  );
62
83
 
63
84
  export const getLevel = (
@@ -80,7 +101,7 @@ export const getLevel = (
80
101
  const definition = getDefinition(name, environment);
81
102
  if (definition) return getDefinitionLevel(definition, environment);
82
103
  const builtin = environment.builtins.get(environment.substitutions.get(name) ?? name);
83
- return builtin ? (builtin.isStateLevel ? 1 : 0) : undefined;
104
+ return builtin ? (builtin.isStateLevel && !builtin.isLevelConstant ? 1 : 0) : undefined;
84
105
  };
85
106
  const getNameLevel = (name: string, node: Expression) => {
86
107
  if (shadowed.has(name)) return 0;
@@ -144,21 +165,53 @@ const getDefinitionLevel = (definition: Definition, environment: Environment) =>
144
165
  return level;
145
166
  };
146
167
 
168
+ // TLC leaves a formula whose sets it fails to enumerate, and doesn't expect an EvalException.
169
+ const getUnrolledElements = (bounds: Bound[], context: Context) => {
170
+ try {
171
+ return getBoundElements(bounds, context);
172
+ } catch (error) {
173
+ if (!(error instanceof TlaEvaluationError)) throw error;
174
+ if (!isEvalException(error)) return undefined;
175
+ throw setExitCode(
176
+ new TlaEvaluationError(
177
+ `${getUnexpectedException("tlc2.tool.EvalException")}${error.message}`,
178
+ ),
179
+ EXIT_STATUS.error,
180
+ );
181
+ }
182
+ };
183
+
147
184
  export const expandTemporal = (
148
185
  expression: Expression,
149
186
  scope: Scope | undefined,
150
187
  environment: Environment,
151
- isUnrollingForall: boolean,
188
+ // Whether TLC expands the formula as a property, which unrolls each \A over a constant set.
189
+ isProperty: boolean,
152
190
  expanding = new Set<Definition>(),
153
- ): ScopedExpression[] => {
191
+ // Whether the expansion entered the body of an instance's definition. Like TLC, it then no
192
+ // longer expands an operator applied to arguments.
193
+ isSubstituted = false,
194
+ name?: string,
195
+ ): ExpandedExpression[] => {
154
196
  const expand = (
155
197
  child: Expression,
156
198
  childScope: Scope | undefined,
199
+ childName = name,
157
200
  childExpanding = expanding,
158
- ): ScopedExpression[] =>
159
- expandTemporal(child, childScope, environment, isUnrollingForall, childExpanding);
201
+ definition?: Definition,
202
+ ): ExpandedExpression[] =>
203
+ expandTemporal(
204
+ child,
205
+ childScope,
206
+ environment,
207
+ isProperty,
208
+ childExpanding,
209
+ isSubstituted ||
210
+ (definition !== undefined && environment.substitutedDefinitions.has(definition)),
211
+ childName,
212
+ );
160
213
  if (expression.kind === "And") {
161
- return expression.operands.flatMap((operand) => expand(operand, scope));
214
+ return expression.operands.flatMap((operand) => expand(operand, scope, describeRange(operand)));
162
215
  }
163
216
  if (expression.kind === "Label") return expand(expression.body, scope);
164
217
  if (expression.kind === "Let") {
@@ -179,35 +232,59 @@ export const expandTemporal = (
179
232
  getDefinitionLevel(definition, environment) > 0
180
233
  ) {
181
234
  if (expanding.has(definition)) {
182
- throw new TlaConfigError(`The definition of ${expression.name} refers to itself`);
235
+ throw createStackOverflowError();
183
236
  }
184
- return expand(definition.body, undefined, new Set([...expanding, definition]));
237
+ return expand(
238
+ definition.body,
239
+ undefined,
240
+ definition.name,
241
+ new Set([...expanding, definition]),
242
+ definition,
243
+ );
185
244
  }
186
245
  }
187
246
  const context = getConstantContext(environment, scope);
188
- if (expression.kind === "Apply" && getLevel(expression, scope, environment) === TEMPORAL_LEVEL) {
247
+ // TLC 1.7.4 never expands an operator applied to arguments. A property expands every one it
248
+ // applies, but a specification only the temporal ones.
249
+ if (
250
+ expression.kind === "Apply" &&
251
+ environment.runtime.version !== "1.7.4" &&
252
+ (isProperty || getLevel(expression, scope, environment) === TEMPORAL_LEVEL)
253
+ ) {
189
254
  const operator = resolveApplyOperator(expression, context);
190
255
  const definition = isLocallyResolved(expression)
191
256
  ? undefined
192
257
  : getDefinition(expression.operator, environment);
193
- if (operator?.kind === "Closure" && !definition?.isRecursive) {
194
- return expand(operator.body, bindOperatorArguments(operator, expression.args, context));
258
+ const isExpandable =
259
+ operator?.kind === "Closure" &&
260
+ operator.params.length === expression.args.length &&
261
+ !definition?.isRecursive &&
262
+ !isSubstituted;
263
+ if (isExpandable) {
264
+ return expand(
265
+ operator.body,
266
+ bindOperatorArguments(operator, expression.args, context),
267
+ expression.operator,
268
+ expanding,
269
+ definition,
270
+ );
195
271
  }
196
272
  }
197
273
  const isUnrolled =
198
- isUnrollingForall &&
274
+ isProperty &&
199
275
  expression.kind === "Forall" &&
200
- getLevel(expression.body, scope, environment) === TEMPORAL_LEVEL &&
201
276
  expression.bounds.every((bound) => getLevel(bound.set, scope, environment) === 0);
202
- if (isUnrolled) {
203
- const expanded: ScopedExpression[] = [];
204
- forEachBinding(expression.bounds, context, (boundScope) => {
205
- expanded.push(...expand(expression.body, boundScope));
277
+ const sets = isUnrolled ? getUnrolledElements(expression.bounds, context) : undefined;
278
+ if (isUnrolled && sets) {
279
+ const expanded: ExpandedExpression[] = [];
280
+ forEachBoundElement(expression.bounds, sets, scope, (boundScope) => {
281
+ expanded.push(...expand(expression.body, boundScope, describeRange(expression.body)));
206
282
  return false;
207
283
  });
284
+ if (expanded.length === 0) throw createTautologyError();
208
285
  return expanded;
209
286
  }
210
- return [{ expression, scope }];
287
+ return [{ expression, scope, name }];
211
288
  };
212
289
 
213
290
  const bindLetDefinitions = (
@@ -234,17 +311,19 @@ export const toLiveExpression = (
234
311
  rootScope: Scope | undefined,
235
312
  environment: Environment,
236
313
  ): LiveExpression => {
314
+ const is174 = environment.runtime.version === "1.7.4";
237
315
  const toAtom = (
238
316
  expression: Expression,
239
317
  scope: Scope | undefined,
240
318
  level: number,
241
319
  ): LiveExpression => {
242
- const atomLevel = level === 0 ? getLevel(expression, scope, environment) : level;
320
+ // TLC after 1.7.4 bounds the level of a formula whose parts are constant by the formula's own.
321
+ const atomLevel = level === 0 && !is174 ? getLevel(expression, scope, environment) : level;
243
322
  if (atomLevel === 0) {
244
323
  const value = evaluate(expression, getConstantContext(environment, scope));
245
324
  if (typeof value !== "boolean") {
246
325
  throw new TlaEvaluationError(
247
- `TLC expected a boolean in the temporal formula at ${describeLocation(expression)}`,
326
+ `TLC expected a boolean value, but did not find one. ${describeNode(expression)}`,
248
327
  );
249
328
  }
250
329
  return createBoolean(value);
@@ -262,9 +341,7 @@ export const toLiveExpression = (
262
341
  scope: Scope | undefined,
263
342
  ) => {
264
343
  if (expansion.depth >= MAXIMUM_EXPANSION_DEPTH) {
265
- throw new TlaEvaluationError(
266
- `TLC overflowed the stack while expanding the temporal formula at ${describeLocation(expression)}`,
267
- );
344
+ throw createStackOverflowError();
268
345
  }
269
346
  expansion.depth++;
270
347
  const result = convert(body, bodyScope);
@@ -284,7 +361,9 @@ export const toLiveExpression = (
284
361
  ? lookupScope(scope, name)
285
362
  : undefined;
286
363
  if (binding?.kind === "Thunk" && definitionThunks.has(binding)) {
287
- return expand(binding.expression, binding.scope, expression, scope);
364
+ return expandCall(expression, () =>
365
+ expand(binding.expression, binding.scope, expression, scope),
366
+ );
288
367
  }
289
368
  const operator =
290
369
  binding?.kind === "Operator"
@@ -296,32 +375,104 @@ export const toLiveExpression = (
296
375
  : resolveGlobalOperator(name, environment);
297
376
  if (operator?.kind !== "Closure") throw createCannotHandleError(expression);
298
377
  const args = expression.kind === "Apply" ? expression.args : [];
299
- return expand(operator.body, bindOperatorArguments(operator, args, context), expression, scope);
378
+ const isRecursive =
379
+ !isLocallyResolved(expression) && getDefinition(name, environment)?.isRecursive === true;
380
+ return expandCall(
381
+ expression,
382
+ () => {
383
+ // TLC 1.7.4 evaluates the arguments of an operator it expands.
384
+ if (is174) {
385
+ args
386
+ .filter((arg) => arg.kind !== "Lambda" && arg.kind !== "OperatorReference")
387
+ .forEach((arg) => evaluate(arg, context));
388
+ }
389
+ return expand(
390
+ operator.body,
391
+ bindOperatorArguments(operator, args, context),
392
+ expression,
393
+ scope,
394
+ );
395
+ },
396
+ isRecursive,
397
+ );
398
+ };
399
+
400
+ // TLC takes an application of an operator whose expansion fails for a formula it can't handle,
401
+ // except that TLC after 1.7.4 fails as the expansion of a recursive operator does.
402
+ const expandCall = (
403
+ expression: Expression,
404
+ expandBody: () => LiveExpression,
405
+ isRecursive = false,
406
+ ) => {
407
+ try {
408
+ return expandBody();
409
+ } catch (error) {
410
+ const isRethrown = error instanceof TlaStackOverflowError || (isRecursive && !is174);
411
+ if (!(error instanceof TlaEvaluationError) || isRethrown) throw error;
412
+ throw createCannotHandleError(expression);
413
+ }
300
414
  };
301
415
 
302
416
  const convertQuantifier = (
303
417
  expression: Expression & { kind: "Forall" | "Exists" },
304
418
  scope: Scope | undefined,
305
419
  ) => {
420
+ const level = getLevel(expression, scope, environment);
306
421
  const isConstant = expression.bounds.every(
307
422
  (bound) => getLevel(bound.set, scope, environment) === 0,
308
423
  );
309
- if (!isConstant) throw createCannotHandleError(expression);
424
+ if (!isConstant) {
425
+ if (level <= ACTION_LEVEL) return toAtom(expression, scope, level);
426
+ throw createCannotHandleError(expression);
427
+ }
310
428
  const operands: LiveExpression[] = [];
311
- forEachBinding(expression.bounds, getConstantContext(environment, scope), (boundScope) => {
312
- operands.push(convert(expression.body, boundScope));
313
- return false;
314
- });
315
429
  const isForall = expression.kind === "Forall";
430
+ // TLC takes a quantified formula whose body fails for one it can't handle, and under \A it adds
431
+ // the message of a failure that isn't an EvalException.
432
+ try {
433
+ forEachBinding(expression.bounds, getConstantContext(environment, scope), (boundScope) => {
434
+ operands.push(convert(expression.body, boundScope));
435
+ return false;
436
+ });
437
+ } catch (error) {
438
+ if (!(error instanceof TlaEvaluationError) || error instanceof TlaStackOverflowError) {
439
+ throw error;
440
+ }
441
+ if (level <= ACTION_LEVEL) return toAtom(expression, scope, level);
442
+ throw createCannotHandleError(
443
+ expression,
444
+ isForall && !isEvalException(error) ? error.message : undefined,
445
+ );
446
+ }
316
447
  if (operands.length === 0) return createBoolean(isForall);
317
- const result = createJunction(isForall ? "And" : "Or", operands);
318
- const level = getLiveLevel(result);
319
- return level > ACTION_LEVEL ? result : toAtom(expression, scope, level);
448
+ return toWhole(expression, scope, createJunction(isForall ? "And" : "Or", operands));
320
449
  };
321
450
 
451
+ // TLC takes a formula whose translated parts are below temporal level whole, at their level.
452
+ const toWhole = (expression: Expression, scope: Scope | undefined, parts: LiveExpression) => {
453
+ const level = getLiveLevel(parts);
454
+ return level > ACTION_LEVEL ? parts : toAtom(expression, scope, level);
455
+ };
456
+
457
+ // The formulas below temporal level whose parts TLC's Liveness.astToLive translates, as one
458
+ // that is constant, such as a quantifier over the empty set, can make the formula constant.
459
+ const isTranslatedWhole = (expression: Expression) =>
460
+ expression.kind === "Label" ||
461
+ expression.kind === "Let" ||
462
+ expression.kind === "And" ||
463
+ expression.kind === "Or" ||
464
+ expression.kind === "Forall" ||
465
+ expression.kind === "Exists" ||
466
+ expression.kind === "If" ||
467
+ (expression.kind === "Apply" &&
468
+ ((expression.operator === "~" && !isLocallyResolved(expression)) ||
469
+ expression.operator === "=>"));
470
+
322
471
  const convert = (expression: Expression, scope: Scope | undefined): LiveExpression => {
323
472
  const level = getLevel(expression, scope, environment);
324
- if (level <= ACTION_LEVEL) return toAtom(expression, scope, level);
473
+ if (level <= ACTION_LEVEL && !isTranslatedWhole(expression)) {
474
+ return toAtom(expression, scope, level);
475
+ }
325
476
  switch (expression.kind) {
326
477
  case "Label":
327
478
  return convert(expression.body, scope);
@@ -342,38 +493,51 @@ export const toLiveExpression = (
342
493
  );
343
494
  }
344
495
  if (expression.operator === "~" && !isLocallyResolved(expression)) {
345
- return createUnary("Not", convert(args[0], scope));
496
+ return toWhole(expression, scope, createUnary("Not", convert(args[0], scope)));
346
497
  }
347
498
  if (expression.operator === "=>") {
348
- return createPair(
349
- "Or",
350
- createUnary("Not", convert(args[0], scope)),
351
- convert(args[1], scope),
499
+ return toWhole(
500
+ expression,
501
+ scope,
502
+ createPair("Or", createUnary("Not", convert(args[0], scope)), convert(args[1], scope)),
352
503
  );
353
504
  }
354
505
  return convertCall(expression, scope);
355
506
  }
356
507
  case "And":
357
508
  case "Or":
358
- return createJunction(
359
- expression.kind,
360
- expression.operands.map((operand) => convert(operand, scope)),
509
+ return toWhole(
510
+ expression,
511
+ scope,
512
+ createJunction(
513
+ expression.kind,
514
+ expression.operands.map((operand) => convert(operand, scope)),
515
+ ),
361
516
  );
362
517
  case "Forall":
363
518
  case "Exists":
364
519
  return convertQuantifier(expression, scope);
365
520
  case "If": {
366
- if (getLevel(expression.condition, scope, environment) === 0) {
521
+ // TLC 1.7.4 translates both branches whatever the guard.
522
+ if (!is174 && getLevel(expression.condition, scope, environment) === 0) {
367
523
  const condition = evaluate(expression.condition, getConstantContext(environment, scope));
368
524
  if (typeof condition === "boolean") {
369
525
  return convert(condition ? expression.consequent : expression.alternative, scope);
370
526
  }
371
527
  }
372
528
  const condition = convert(expression.condition, scope);
373
- return createPair(
374
- "Or",
375
- createPair("And", condition, convert(expression.consequent, scope)),
376
- createPair("And", createUnary("Not", condition), convert(expression.alternative, scope)),
529
+ return toWhole(
530
+ expression,
531
+ scope,
532
+ createPair(
533
+ "Or",
534
+ createPair("And", condition, convert(expression.consequent, scope)),
535
+ createPair(
536
+ "And",
537
+ createUnary("Not", condition),
538
+ convert(expression.alternative, scope),
539
+ ),
540
+ ),
377
541
  );
378
542
  }
379
543
  case "Always":
@@ -874,7 +874,7 @@ export const mapSelectorArgs = (selector: Selector, map: (arg: Expr) => Expr): S
874
874
  ? { ...selector, args: selector.args.map(map) }
875
875
  : selector;
876
876
 
877
- export const mapExceptSpecs = (specs: ExceptSpec[], map: (inner: Expr) => Expr): ExceptSpec[] =>
877
+ const mapExceptSpecs = (specs: ExceptSpec[], map: (inner: Expr) => Expr): ExceptSpec[] =>
878
878
  specs.map((spec) => {
879
879
  const value = map(spec.value);
880
880
  const trail = spec.trail.map((point): ExceptPoint =>
@@ -883,7 +883,7 @@ export const mapExceptSpecs = (specs: ExceptSpec[], map: (inner: Expr) => Expr):
883
883
  return { trail, value };
884
884
  });
885
885
 
886
- export const mapDefnBody = (definition: Defn, map: (body: Expr) => Expr): Defn =>
886
+ const mapDefnBody = (definition: Defn, map: (body: Expr) => Expr): Defn =>
887
887
  definition.kind === "Operator" || definition.kind === "Bpragma"
888
888
  ? { ...definition, body: map(definition.body) }
889
889
  : definition;
@@ -609,6 +609,8 @@ export const createSource = (file: string, text: string, counter: Counter, isExp
609
609
  );
610
610
  case "ExceptAt":
611
611
  return at({ kind: "At", isExcept }, { location });
612
+ case "Bracket":
613
+ throw new TlaProofError("Unexpected [ without a function or subscript");
612
614
  case "FunctionApplication":
613
615
  return at(
614
616
  {
@@ -15,10 +15,10 @@ import type {
15
15
  WorkerMessage,
16
16
  } from "./parallel";
17
17
  import { getSuccessors, type Successor } from "./successors";
18
- import { getTlcStringOrder, getTlcVariableOrder } from "./tlc-order";
18
+ import { getTlcStringOrder, getTlcDeclarationOrder } from "./tlc-order";
19
19
  import { OUT_DEGREE_BUCKETS } from "./tlc-summary";
20
20
  import { createStateDecoder, createStateEncoder, type EncodedStates } from "./transfer";
21
- import { getRankedStringCount, setStringOrder, type Value } from "./values";
21
+ import { getRankedStringCount, setStringOrder, setValueVersion, type Value } from "./values";
22
22
 
23
23
  const WORKER_THREADS_MODULE = "node:worker_threads";
24
24
  const LOCKED = -1;
@@ -51,6 +51,7 @@ const run = (start: StartMessage, parent: Port) => {
51
51
  const loadModule = (name: string) => modules.get(name);
52
52
  const classes = new Map(start.classes);
53
53
  setStringOrder(getTlcStringOrder(start.source, start.config, loadModule));
54
+ setValueVersion(start.version);
54
55
  const startupStrings = getRankedStringCount();
55
56
  const specification = createEnvironment(start.config, {
56
57
  source: start.source,
@@ -58,10 +59,14 @@ const run = (start: StartMessage, parent: Port) => {
58
59
  loadClass: (name) => classes.get(name),
59
60
  print: () => {},
60
61
  files: { readFile: undefined, writeFile: undefined },
62
+ isTool: start.isTool,
63
+ isTraceRecorded: start.isTraceRecorded,
64
+ isWarningEnabled: start.isWarningEnabled,
65
+ version: start.version,
61
66
  });
62
67
  const environment = specification.environment;
63
68
  const search = createSearch(start.config, environment, () =>
64
- getTlcVariableOrder(start.source, loadModule),
69
+ getTlcDeclarationOrder(start.source, loadModule, "variable"),
65
70
  );
66
71
  const nextAction = search?.spec.next;
67
72
  if (!search || nextAction === undefined)
package/src/parallel.ts CHANGED
@@ -4,8 +4,12 @@ import {
4
4
  checkSequentially,
5
5
  createSearch,
6
6
  findAssumptionViolation,
7
+ reportInitialStatesProgress,
8
+ reportStartup,
7
9
  type CheckOptions,
10
+ type CheckProgress,
8
11
  type CheckResult,
12
+ type InitialStates,
9
13
  } from "./check";
10
14
  import { parseConfig, type ModelConfig } from "./config";
11
15
  import { createEnvironment } from "./environment";
@@ -23,7 +27,8 @@ import { getInitialStates } from "./successors";
23
27
  import { getTlcStringOrder, getTlcVariableOrder } from "./tlc-order";
24
28
  import { getFingerprintDistance, OUT_DEGREE_BUCKETS } from "./tlc-summary";
25
29
  import { createStateEncoder, type EncodedStates } from "./transfer";
26
- import { getRankedStringCount, setStringOrder, type Value } from "./values";
30
+ import type { TlcVersion } from "./tlc-version";
31
+ import { getRankedStringCount, setStringOrder, setValueVersion, type Value } from "./values";
27
32
 
28
33
  const WORKER_THREADS_MODULE = "node:worker_threads";
29
34
 
@@ -43,6 +48,10 @@ export interface StartMessage {
43
48
  index: number;
44
49
  ports: (Port | undefined)[];
45
50
  seed: EncodedStates;
51
+ isTool: boolean | undefined;
52
+ isTraceRecorded: boolean | undefined;
53
+ isWarningEnabled: boolean | undefined;
54
+ version: TlcVersion | undefined;
46
55
  fingerprints: SharedFingerprints;
47
56
  requests: Int32Array;
48
57
  remaining: Int32Array;
@@ -101,16 +110,36 @@ const spawnWorker = async (onMessage: (message: WorkerMessage) => void): Promise
101
110
  };
102
111
 
103
112
  export const check = async (options: CheckOptions): Promise<CheckResult> => {
104
- const config = typeof options.config === "string" ? parseConfig(options.config) : options.config;
113
+ const config =
114
+ typeof options.config === "string"
115
+ ? parseConfig(options.config, options.version)
116
+ : options.config;
105
117
  const print = options.onPrint ?? console.log;
106
118
  const printed = { count: 0 };
107
- // The search on the calling thread prints what this one printed while it started, so it skips that.
119
+ // What each point the search reports is about, such as the invariant TLC warns about.
120
+ const getKey = (progress: CheckProgress) =>
121
+ [
122
+ progress.kind,
123
+ "name" in progress ? progress.name : "",
124
+ "count" in progress ? progress.count : "",
125
+ "text" in progress ? progress.text : "",
126
+ ].join(" ");
127
+ const reported = new Set<string>();
128
+ const report = (progress: CheckProgress) => {
129
+ reported.add(getKey(progress));
130
+ options.onProgress?.(progress);
131
+ };
132
+ // The search on the calling thread prints and reports what this one did while it started, so it
133
+ // skips that.
108
134
  const fallBack = () => {
109
135
  const skipped = { count: printed.count };
110
136
  return checkSequentially({
111
137
  ...options,
112
138
  config,
113
139
  onPrint: (text) => (skipped.count-- > 0 ? undefined : print(text)),
140
+ onProgress: (progress) => {
141
+ if (!reported.has(getKey(progress))) options.onProgress?.(progress);
142
+ },
114
143
  });
115
144
  };
116
145
  const count = options.workers ?? 1;
@@ -137,6 +166,7 @@ export const check = async (options: CheckOptions): Promise<CheckResult> => {
137
166
  return bytes;
138
167
  };
139
168
  setStringOrder(getTlcStringOrder(options.source, config, loadModule));
169
+ setValueVersion(options.version);
140
170
  const startupStrings = getRankedStringCount();
141
171
  const specification = createEnvironment(config, {
142
172
  source: options.source,
@@ -147,10 +177,19 @@ export const check = async (options: CheckOptions): Promise<CheckResult> => {
147
177
  print(text);
148
178
  },
149
179
  files: { readFile: options.readFile, writeFile: options.writeFile },
180
+ isTool: options.isTool,
181
+ isTraceRecorded: options.isTraceRecorded,
182
+ isSanyReported: options.isSanyReported,
183
+ isWarningEnabled: options.isWarningEnabled,
184
+ version: options.version,
150
185
  });
186
+ reportStartup(specification, config, report);
151
187
  const environment = specification.environment;
152
- const search = createSearch(config, environment, () =>
153
- getTlcVariableOrder(options.source, loadModule),
188
+ const search = createSearch(
189
+ config,
190
+ environment,
191
+ () => getTlcVariableOrder(options.source, loadModule),
192
+ report,
154
193
  );
155
194
  if (findAssumptionViolation(specification.assumptions, environment)) return fallBack();
156
195
  if (
@@ -172,6 +211,7 @@ export const check = async (options: CheckOptions): Promise<CheckResult> => {
172
211
  distinctStates: 0,
173
212
  queuedStates: 0,
174
213
  depth: 0,
214
+ initialStates: undefined as InitialStates | undefined,
175
215
  outDegrees: Array.from({ length: OUT_DEGREE_BUCKETS }, () => 0),
176
216
  };
177
217
  const tlcFingerprints: BigInt64Array[] = [];
@@ -196,6 +236,7 @@ export const check = async (options: CheckOptions): Promise<CheckResult> => {
196
236
  const seedInitialStates = (init: Expression) => {
197
237
  const seeded: Value[][] = [];
198
238
  for (const state of getInitialStates(init, environment, search.spec.scope)) {
239
+ reportInitialStatesProgress(statistics.generatedStates, report);
199
240
  canonicalize(state);
200
241
  statistics.generatedStates++;
201
242
  writeStateFingerprint(search.getFingerprintState(state), fingerprint);
@@ -217,6 +258,7 @@ export const check = async (options: CheckOptions): Promise<CheckResult> => {
217
258
  return true;
218
259
  };
219
260
  // The sequential search reports a violation or a failed evaluation in the initial states.
261
+ report({ kind: "initial-states-started" });
220
262
  try {
221
263
  if (!seedInitialStates(search.spec.init)) return fallBack();
222
264
  } catch (error) {
@@ -225,6 +267,11 @@ export const check = async (options: CheckOptions): Promise<CheckResult> => {
225
267
  }
226
268
  if (getRankedStringCount() !== startupStrings) return fallBack();
227
269
  statistics.depth = statistics.generatedStates === 0 ? 0 : 1;
270
+ statistics.initialStates = {
271
+ generated: statistics.generatedStates,
272
+ distinct: statistics.distinctStates,
273
+ };
274
+ report({ kind: "initial-states-computed", initialStates: statistics.initialStates });
228
275
  if (statistics.distinctStates === 0) return createSuccess();
229
276
 
230
277
  const reports: WorkerMessage[] = [];
@@ -266,6 +313,10 @@ export const check = async (options: CheckOptions): Promise<CheckResult> => {
266
313
  index,
267
314
  ports,
268
315
  seed,
316
+ isTool: options.isTool,
317
+ isTraceRecorded: options.isTraceRecorded,
318
+ isWarningEnabled: options.isWarningEnabled,
319
+ version: options.version,
269
320
  fingerprints: shared.fingerprints,
270
321
  requests,
271
322
  remaining,