tla-ts 0.0.2 → 0.0.3-dev.19c763f

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 (59) hide show
  1. package/README.md +78 -12
  2. package/dist/index.cjs +1 -1
  3. package/dist/index.d.cts +60 -1
  4. package/dist/index.d.ts +60 -1
  5. package/dist/index.js +1 -1
  6. package/dist/parallel-worker.cjs +2 -2
  7. package/dist/parallel-worker.js +2 -2
  8. package/dist/parallel.cjs +1 -1
  9. package/dist/parallel.js +2 -2
  10. package/dist/run-cli.cjs +21 -2
  11. package/dist/run-cli.js +21 -2
  12. package/dist/transfer.cjs +27 -15
  13. package/dist/transfer.js +27 -15
  14. package/package.json +3 -1
  15. package/src/ast.ts +134 -4
  16. package/src/check.ts +230 -62
  17. package/src/cli-options.ts +64 -0
  18. package/src/codegen.ts +9 -19
  19. package/src/dependencies.ts +2 -2
  20. package/src/environment.ts +75 -16
  21. package/src/errors.ts +46 -3
  22. package/src/evaluate.ts +78 -136
  23. package/src/exit-codes.ts +21 -43
  24. package/src/fingerprints.ts +46 -11
  25. package/src/instances.ts +15 -14
  26. package/src/levels.ts +8 -8
  27. package/src/lexer.ts +11 -2
  28. package/src/live-check.ts +710 -0
  29. package/src/liveness.ts +5 -523
  30. package/src/obligation-action.ts +384 -0
  31. package/src/obligation-anon.ts +575 -0
  32. package/src/obligation-deref.ts +637 -0
  33. package/src/obligation-expression.ts +1060 -0
  34. package/src/obligation-format.ts +406 -0
  35. package/src/obligation-generate.ts +1074 -0
  36. package/src/obligation-levels.ts +329 -0
  37. package/src/obligation-module.ts +1042 -0
  38. package/src/obligation-printer.ts +889 -0
  39. package/src/obligation-proof.ts +76 -0
  40. package/src/obligation-source.ts +1084 -0
  41. package/src/obligation-tuples.ts +184 -0
  42. package/src/obligations.ts +316 -0
  43. package/src/parallel-worker.ts +166 -210
  44. package/src/parallel.ts +76 -35
  45. package/src/parser.ts +297 -53
  46. package/src/resolve.ts +16 -15
  47. package/src/run-cli.ts +353 -40
  48. package/src/runtime.ts +3 -1
  49. package/src/spec-description.ts +18 -6
  50. package/src/standard-levels.ts +3 -3
  51. package/src/state-graph.ts +157 -0
  52. package/src/subexpressions.ts +10 -10
  53. package/src/successors.ts +17 -9
  54. package/src/symmetry.ts +14 -2
  55. package/src/tlc-ext.ts +29 -12
  56. package/src/tlc-module.ts +9 -28
  57. package/src/tlc-order.ts +17 -3
  58. package/src/transfer.ts +22 -1
  59. package/src/values.ts +70 -23
package/src/check.ts CHANGED
@@ -1,15 +1,27 @@
1
- import type { Assumption, Definition, Expression, SourceLocation } from "./ast";
1
+ import {
2
+ getChildren,
3
+ isLocallyResolved,
4
+ type Assumption,
5
+ type Definition,
6
+ type Expression,
7
+ type SourceLocation,
8
+ } from "./ast";
2
9
  import { parseConfig, type ConfigValue, type ModelConfig } from "./config";
3
10
  import { getReadVariables } from "./dependencies";
4
11
  import { createEnvironment } from "./environment";
5
- import { getErrorExitCode, TlaConfigError, TlaEvaluationError, TlaModuleError } from "./errors";
6
- import { EXIT_STATUS, setExitCode, setNextStatePhase, withLivenessExitCode } from "./exit-codes";
12
+ import {
13
+ getErrorExitCode,
14
+ TlaConfigError,
15
+ TlaEvaluationError,
16
+ TlaModuleError,
17
+ UNEXPECTED_EXCEPTION,
18
+ } from "./errors";
19
+ import { EXIT_STATUS, setExitCode, withLivenessExitCode } from "./exit-codes";
7
20
  import {
8
21
  describeRange,
9
22
  evaluate,
10
23
  expectBoolean,
11
24
  formatRange,
12
- getChildren,
13
25
  getDefinition,
14
26
  isConstantLevel,
15
27
  isImpure,
@@ -19,13 +31,11 @@ import {
19
31
  } from "./evaluate";
20
32
  import {
21
33
  createLivenessChecker,
22
- expandTemporal,
23
- getLevel,
24
34
  type Lasso,
35
+ type LivenessChecker,
25
36
  type LiveSuccessor,
26
- type ScopedExpression,
27
- type TemporalProperty,
28
- } from "./liveness";
37
+ } from "./live-check";
38
+ import { expandTemporal, getLevel, type ScopedExpression, type TemporalProperty } from "./liveness";
29
39
  import { ACTION_LEVEL, createLevelAnalyzer, TEMPORAL_LEVEL } from "./levels";
30
40
  import { prettyPrint } from "./pretty-print";
31
41
  import {
@@ -37,10 +47,17 @@ import {
37
47
  } from "./successors";
38
48
  import {
39
49
  getActionLabel,
50
+ getActionSignature,
40
51
  getNextActions,
41
52
  getSpecificationValue,
42
53
  type SpecAction,
43
54
  } from "./spec-description";
55
+ import {
56
+ createStateWriter,
57
+ type GraphState,
58
+ type StateDump,
59
+ type StateWriter,
60
+ } from "./state-graph";
44
61
  import { getRepresentative, getSymmetryGroup } from "./symmetry";
45
62
  import { getTlcStringOrder, getTlcVariableOrder } from "./tlc-order";
46
63
  import { createTlcFingerprinter, getTlcFingerprint } from "./tlc-random";
@@ -50,10 +67,12 @@ import { createCounterExample } from "./tlc-ext";
50
67
  import { getFingerprintDistance, OUT_DEGREE_BUCKETS } from "./tlc-summary";
51
68
  import {
52
69
  combineHash,
70
+ formatState,
53
71
  formatValue,
54
72
  getValueHash,
55
73
  isFunctionValue,
56
74
  isSameValue,
75
+ isUpdatedElementOf,
57
76
  setStringOrder,
58
77
  toFiniteFunction,
59
78
  type Value,
@@ -72,6 +91,8 @@ export interface CheckOptions {
72
91
  workers?: number;
73
92
  // TLC's -lncheck: "final" checks liveness only on the complete state graph.
74
93
  livenessCheck?: "default" | "final";
94
+ // TLC's -dump: writes the reachable states, or with `dot` the state graph, through writeFile.
95
+ dump?: StateDump;
75
96
  }
76
97
 
77
98
  export type CheckStatus =
@@ -93,6 +114,8 @@ export interface TraceStep {
93
114
 
94
115
  export interface Violation {
95
116
  name: string;
117
+ // Every temporal property that a liveness counterexample violates, in the configuration's order.
118
+ properties?: string[];
96
119
  trace: TraceStep[];
97
120
  loopStart: number | undefined;
98
121
  loopLabel?: string;
@@ -139,6 +162,13 @@ interface NamedExpression {
139
162
 
140
163
  interface StateCheck extends NamedExpression {
141
164
  variables: number[] | undefined;
165
+ membership: Membership | undefined;
166
+ }
167
+
168
+ // A conjunct `x \in S` whose S reads no variables.
169
+ interface Membership {
170
+ variable: number;
171
+ set: Expression;
142
172
  }
143
173
 
144
174
  interface ActionProperty {
@@ -481,14 +511,32 @@ const getPossiblePredicates = (names: string[], environment: Environment) =>
481
511
  return { name, expression, scope: undefined };
482
512
  });
483
513
 
514
+ const getMembership = (
515
+ expression: Expression,
516
+ variables: number[] | undefined,
517
+ environment: Environment,
518
+ ): Membership | undefined => {
519
+ if (expression.kind !== "Apply" || expression.operator !== "\\in" || variables?.length !== 1)
520
+ return undefined;
521
+ const element = expression.args[0];
522
+ if (element.kind !== "Identifier" || isLocallyResolved(element)) return undefined;
523
+ return environment.variableIndex.get(element.name) === variables[0]
524
+ ? { variable: variables[0], set: expression.args[1] }
525
+ : undefined;
526
+ };
527
+
484
528
  const getStateChecks = (named: NamedExpression[], environment: Environment): StateCheck[] =>
485
529
  named.flatMap((item) =>
486
- getConjuncts(item.expression, environment).map((expression) => ({
487
- name: item.name,
488
- expression,
489
- scope: item.scope,
490
- variables: getReadVariables(expression, environment),
491
- })),
530
+ getConjuncts(item.expression, environment).map((expression) => {
531
+ const variables = getReadVariables(expression, environment);
532
+ return {
533
+ name: item.name,
534
+ expression,
535
+ scope: item.scope,
536
+ variables,
537
+ membership: getMembership(expression, variables, environment),
538
+ };
539
+ }),
492
540
  );
493
541
 
494
542
  const isUnchangedFor = (stateCheck: StateCheck, state: Value[], parent: Value[] | undefined) => {
@@ -743,10 +791,16 @@ export const createSearch = (
743
791
  invariants.find((invariant) => {
744
792
  if (isUnchangedFor(invariant, state, parent)) return false;
745
793
  try {
746
- return !holdsLikeTlc(
747
- invariant.expression,
748
- getContext(environment, state, undefined, invariant.scope),
749
- );
794
+ const context = getContext(environment, state, undefined, invariant.scope);
795
+ const membership = invariant.membership;
796
+ // The parent satisfies every invariant, so only the entries the step changed can fail.
797
+ return parent && membership
798
+ ? !isUpdatedElementOf(
799
+ state[membership.variable],
800
+ parent[membership.variable],
801
+ evaluate(membership.set, context),
802
+ )
803
+ : !holdsLikeTlc(invariant.expression, context);
750
804
  } catch (error) {
751
805
  // TLC reports a failure only on a state after the initial states as an invariant failure.
752
806
  if (!parent) throw error;
@@ -787,7 +841,10 @@ export const createSearch = (
787
841
  )
788
842
  );
789
843
  } catch (error) {
790
- throw withHeadline(error, `Evaluating action property ${property.name} failed.`);
844
+ throw withHeadline(
845
+ withNextStateExitCode(error),
846
+ `Evaluating action property ${property.name} failed.`,
847
+ );
791
848
  }
792
849
  }),
793
850
  satisfiesActionConstraints: (state, next) =>
@@ -795,8 +852,7 @@ export const createSearch = (
795
852
  holdsLikeTlc(
796
853
  constraint.expression,
797
854
  getContext(environment, state, next),
798
- (expression) =>
799
- `TLC threw an unexpected exception.\nThis was probably caused by an error in the spec or model.\nSee the User Output or TLC Console for clues to what happened.\nThe exception was a java.lang.RuntimeException\n: ${getExpectedBoolean(expression, environment)}`,
855
+ (expression) => `${UNEXPECTED_EXCEPTION}${getExpectedBoolean(expression, environment)}`,
800
856
  ),
801
857
  ),
802
858
  trackStatePossible:
@@ -824,6 +880,11 @@ export const createSearch = (
824
880
  };
825
881
  };
826
882
 
883
+ // TLC exits with the code of a standard module's failure only when the failure escapes the
884
+ // computation of next states. In every other phase, the phase decides the code.
885
+ const withNextStateExitCode = (error: unknown) =>
886
+ error instanceof TlaModuleError ? setExitCode(error, error.exitCode) : error;
887
+
827
888
  const withHeadline = (error: unknown, headline: string) =>
828
889
  error instanceof TlaEvaluationError
829
890
  ? setExitCode(
@@ -832,8 +893,15 @@ const withHeadline = (error: unknown, headline: string) =>
832
893
  )
833
894
  : error;
834
895
 
896
+ // TLC finishes the -dump file whether or not the search finds a violation.
835
897
  export const checkSequentially = (options: CheckOptions): CheckResult => {
836
- setNextStatePhase(false);
898
+ const stateWriter = options.dump && createStateWriter(options.dump, options.writeFile);
899
+ const result = searchStates(options, stateWriter);
900
+ stateWriter?.close();
901
+ return result;
902
+ };
903
+
904
+ const searchStates = (options: CheckOptions, stateWriter: StateWriter | undefined): CheckResult => {
837
905
  const config = typeof options.config === "string" ? parseConfig(options.config) : options.config;
838
906
  const onPrint = options.onPrint ?? console.log;
839
907
  // TLC prints again while it rebuilds a trace, between the states it prints. Printing those lines
@@ -929,8 +997,36 @@ export const checkSequentially = (options: CheckOptions): CheckResult => {
929
997
  const getFingerprintState = search.getFingerprintState;
930
998
  const nextActions = { value: undefined as SpecAction[] | undefined };
931
999
  const isReducing = config.view !== undefined || config.symmetry !== undefined;
1000
+ const tlcFingerprints: number[] = [];
932
1001
  const liveness = withLivenessExitCode(() =>
933
- createLivenessChecker(search.properties.liveness, spec.temporals, environment),
1002
+ createLivenessChecker(search.properties.liveness, spec.temporals, environment, {
1003
+ getFingerprint: (index) =>
1004
+ (tlcFingerprints[index] ??= Number(
1005
+ BigInt.asIntN(32, runtime.getFingerprint(states[index])),
1006
+ )),
1007
+ getSuccessors: (state) => {
1008
+ const successors: LiveSuccessor[] = [];
1009
+ if (spec.next === undefined) return successors;
1010
+ forEachSuccessor(
1011
+ spec.next,
1012
+ state,
1013
+ environment,
1014
+ (successor) => {
1015
+ canonicalizeState(successor.state);
1016
+ const isInModel =
1017
+ search.satisfiesConstraints(successor.state, state) &&
1018
+ search.satisfiesActionConstraints(state, successor.state);
1019
+ if (!isInModel) return false;
1020
+ const fingerprintState = getFingerprintState(successor.state);
1021
+ const index = findStateIndex(getStateHash(fingerprintState), fingerprintState);
1022
+ successors.push({ index, state: successor.state });
1023
+ return false;
1024
+ },
1025
+ spec.scope,
1026
+ );
1027
+ return successors;
1028
+ },
1029
+ }),
934
1030
  );
935
1031
  const isCanonicalizedFirst = search.isSymmetric || liveness !== undefined;
936
1032
 
@@ -952,11 +1048,16 @@ export const checkSequentially = (options: CheckOptions): CheckResult => {
952
1048
  position: number,
953
1049
  loopStart: number | undefined,
954
1050
  ) => {
955
- const state = steps[position].state;
956
- const next = (steps[position + 1] ?? steps[loopStart ?? position]).state;
957
1051
  // TLC evaluates TLCGet("level") and Trace in an alias at the state's position in the trace.
958
1052
  runtime.getLevel = () => position + 1;
959
1053
  runtime.getBehavior = () => steps.slice(0, position + 1).map((step) => step.state);
1054
+ return evaluateAlias(
1055
+ alias,
1056
+ steps[position].state,
1057
+ (steps[position + 1] ?? steps[loopStart ?? position]).state,
1058
+ );
1059
+ };
1060
+ const evaluateAlias = (alias: string, state: Value[], next: Value[] | undefined) => {
960
1061
  try {
961
1062
  const body = getConfigDefinition("alias", alias, environment).body;
962
1063
  const value = evaluate(createIdentifier(alias), getContext(environment, state, next));
@@ -1071,7 +1172,7 @@ export const checkSequentially = (options: CheckOptions): CheckResult => {
1071
1172
  outDegrees: failureOutDegrees,
1072
1173
  };
1073
1174
  };
1074
- const getPathTrace = (path: number[], loopStart?: number) => {
1175
+ const getPathSteps = (path: number[], loopStart?: number) => {
1075
1176
  const steps = getPathStates(path, NEXT_RECOVERY_FAILURE);
1076
1177
  const last = steps[steps.length - 1].state;
1077
1178
  const isClosed =
@@ -1080,7 +1181,7 @@ export const checkSequentially = (options: CheckOptions): CheckResult => {
1080
1181
  loopStart === path.length - 1 ||
1081
1182
  findSuccessorWithFingerprint(last, path[loopStart]) !== undefined;
1082
1183
  if (!isClosed) throw new TlaEvaluationError(NEXT_RECOVERY_FAILURE);
1083
- return toTrace(steps, path, loopStart);
1184
+ return steps;
1084
1185
  };
1085
1186
  const getStateHash = (state: Value[]) => {
1086
1187
  let hash = 0x811c9dc5;
@@ -1146,7 +1247,7 @@ export const checkSequentially = (options: CheckOptions): CheckResult => {
1146
1247
  };
1147
1248
  runtime.getCurrentState = () => (current.index === -1 ? undefined : states[current.index]);
1148
1249
  runtime.setLivenessSource = (index) => {
1149
- current.livenessSource = index;
1250
+ current.livenessSource = index ?? -1;
1150
1251
  };
1151
1252
  runtime.getLevel = (state) => {
1152
1253
  const source = current.livenessSource;
@@ -1157,6 +1258,18 @@ export const checkSequentially = (options: CheckOptions): CheckResult => {
1157
1258
  return current.isExpanding ? depths[current.index] + 1 : 0;
1158
1259
  };
1159
1260
 
1261
+ const getGraphState = (state: Value[], level: number): GraphState => ({
1262
+ fingerprint: BigInt.asIntN(64, runtime.getFingerprint(state)),
1263
+ level,
1264
+ getLabel: () =>
1265
+ formatState(
1266
+ config.alias === undefined
1267
+ ? toRecord(state)
1268
+ : evaluateAlias(config.alias, state, undefined),
1269
+ ),
1270
+ getText: () => formatState(toRecord(state)),
1271
+ });
1272
+
1160
1273
  const visitInitialState = (state: Value[]) => {
1161
1274
  canonicalizeState(state);
1162
1275
  runtime.generatedStates++;
@@ -1173,6 +1286,7 @@ export const checkSequentially = (options: CheckOptions): CheckResult => {
1173
1286
  countDistinctState(1);
1174
1287
  runtime.queueSize++;
1175
1288
  liveness?.addInitialState(states.length, state);
1289
+ stateWriter?.writeInitialState(getGraphState(state, 1));
1176
1290
  }
1177
1291
  const violated = search.findViolatedInvariant(state);
1178
1292
  if (violated) {
@@ -1193,7 +1307,13 @@ export const checkSequentially = (options: CheckOptions): CheckResult => {
1193
1307
  addState(state, fingerprintState, -1, undefined);
1194
1308
  return undefined;
1195
1309
  };
1196
- const visitSuccessor = (index: number, successor: Successor, liveSuccessors: LiveSuccessor[]) => {
1310
+ const visitSuccessor = (
1311
+ index: number,
1312
+ successor: Successor,
1313
+ liveSuccessors: LiveSuccessor[],
1314
+ source: GraphState | undefined,
1315
+ action: SpecAction | undefined,
1316
+ ) => {
1197
1317
  const state = states[index];
1198
1318
  runtime.generatedStates++;
1199
1319
  current.candidate = successor.state;
@@ -1207,6 +1327,14 @@ export const checkSequentially = (options: CheckOptions): CheckResult => {
1207
1327
  const isInModel = isStateInModel && search.satisfiesActionConstraints(state, successor.state);
1208
1328
  if (isInModel) search.trackActionPossible(state, successor.state);
1209
1329
  const existing = isInModel ? found : -1;
1330
+ if (source && isInModel) {
1331
+ stateWriter?.writeSuccessor(
1332
+ source,
1333
+ getGraphState(successor.state, depths[index] + 1),
1334
+ existing !== -1,
1335
+ action && { name: action.name, signature: getActionSignature(action) },
1336
+ );
1337
+ }
1210
1338
  if (existing !== -1 && liveness) {
1211
1339
  const stored = states[existing];
1212
1340
  const isStored = stored.every((value, position) => value === successor.state[position]);
@@ -1278,23 +1406,55 @@ export const checkSequentially = (options: CheckOptions): CheckResult => {
1278
1406
  }
1279
1407
  return createSuccess();
1280
1408
  }
1409
+ // TLC labels and colors an edge of the -dump state graph by the action that generated it. When
1410
+ // the graph names its edges, the search generates successors action by action, as TLC does.
1411
+ const isNamingEdges = Boolean(
1412
+ options.dump?.dot && (options.dump.actionLabels || options.dump.colorize),
1413
+ );
1414
+ const forEachActionSuccessor = (
1415
+ state: Value[],
1416
+ onSuccessor: (successor: Successor, action: SpecAction | undefined) => boolean,
1417
+ ) => {
1418
+ if (!isNamingEdges) {
1419
+ return forEachSuccessor(
1420
+ next,
1421
+ state,
1422
+ environment,
1423
+ (successor) => onSuccessor(successor, undefined),
1424
+ spec.scope,
1425
+ );
1426
+ }
1427
+ nextActions.value ??= getNextActions(config, environment, specification.instanceActions);
1428
+ const progress = { isStopped: false };
1429
+ return nextActions.value.reduce((count, action) => {
1430
+ if (progress.isStopped) return count;
1431
+ return (
1432
+ count +
1433
+ forEachSuccessor(
1434
+ action.expression,
1435
+ state,
1436
+ environment,
1437
+ (successor) => {
1438
+ progress.isStopped = onSuccessor(successor, action);
1439
+ return progress.isStopped;
1440
+ },
1441
+ action.scope,
1442
+ )
1443
+ );
1444
+ }, 0);
1445
+ };
1281
1446
  const expandState = (index: number) => {
1282
1447
  const state = states[index];
1283
1448
  const liveSuccessors: LiveSuccessor[] = [];
1284
- const successorCount = forEachSuccessor(
1285
- next,
1286
- state,
1287
- environment,
1288
- (successor) => {
1289
- try {
1290
- outcome.result = visitSuccessor(index, successor, liveSuccessors);
1291
- } catch (error) {
1292
- outcome.result = toFailure(error, getTrace(index, successor));
1293
- }
1294
- return outcome.result !== undefined;
1295
- },
1296
- spec.scope,
1297
- );
1449
+ const source = stateWriter && getGraphState(state, depths[index]);
1450
+ const successorCount = forEachActionSuccessor(state, (successor, action) => {
1451
+ try {
1452
+ outcome.result = visitSuccessor(index, successor, liveSuccessors, source, action);
1453
+ } catch (error) {
1454
+ outcome.result = toFailure(error, getTrace(index, successor));
1455
+ }
1456
+ return outcome.result !== undefined;
1457
+ });
1298
1458
  current.isExpanding = false;
1299
1459
  if (outcome.result) return outcome.result;
1300
1460
  if (successorCount === 0 && config.checkDeadlock) {
@@ -1302,32 +1462,43 @@ export const checkSequentially = (options: CheckOptions): CheckResult => {
1302
1462
  }
1303
1463
  try {
1304
1464
  const accepted = liveness?.addState(index, state, liveSuccessors);
1305
- current.livenessSource = -1;
1306
- if (!accepted) return undefined;
1465
+ if (!liveness || !accepted) return undefined;
1466
+ const steps = getPathSteps(accepted);
1467
+ const properties = liveness.getViolatedProperties(
1468
+ steps.map((step) => step.state),
1469
+ steps.length - 1,
1470
+ );
1307
1471
  return reportViolation("property-violation", {
1308
- name: accepted.name,
1309
- trace: getPathTrace(accepted.path),
1472
+ name: properties[0],
1473
+ properties,
1474
+ trace: toTrace(steps, accepted),
1310
1475
  });
1311
1476
  } catch (error) {
1312
1477
  return toFailure(error, getStateTrace(index), undefined, getPartialOutDegrees());
1313
1478
  }
1314
1479
  };
1315
- const reportLasso = (lasso: Lasso) => {
1480
+ // TLC names the properties and the step back into the cycle from the states it prints.
1481
+ const reportLasso = (checker: LivenessChecker, lasso: Lasso) => {
1316
1482
  const path = [...lasso.prefix, ...lasso.cycle];
1317
- const trace = getPathTrace(path, lasso.prefix.length);
1318
- const back = path[lasso.prefix.length];
1483
+ const loopStart = lasso.prefix.length;
1484
+ const steps = getPathSteps(path, loopStart);
1485
+ const trace = toTrace(steps, path, loopStart);
1486
+ const properties = checker.getViolatedProperties(
1487
+ steps.map((step) => step.state),
1488
+ loopStart,
1489
+ );
1490
+ const back = path[loopStart];
1319
1491
  const last = path[path.length - 1];
1492
+ const lastState = steps[steps.length - 1].state;
1320
1493
  const loopLabel =
1321
- back === last ? undefined : withoutOutput(() => getLabel(last, states[last], states[back]));
1494
+ back === last ? undefined : withoutOutput(() => getLabel(last, lastState, states[back]));
1322
1495
  return reportViolation(
1323
1496
  "liveness-violation",
1324
- { name: lasso.name, trace, loopStart: lasso.prefix.length, loopLabel },
1497
+ { name: properties[0], properties, trace, loopStart, loopLabel },
1325
1498
  () =>
1326
1499
  back === last
1327
1500
  ? trace[trace.length - 1].action
1328
- : getTraceSuccessors(states[last]).find((successor) =>
1329
- isSameState(successor.state, states[back]),
1330
- )?.action,
1501
+ : findSuccessorWithFingerprint(lastState, back)?.action,
1331
1502
  );
1332
1503
  };
1333
1504
  const isPeriodic = liveness !== undefined && options.livenessCheck !== "final";
@@ -1340,11 +1511,9 @@ export const checkSequentially = (options: CheckOptions): CheckResult => {
1340
1511
  if (!isGrown || periodic.time > (now - startedAt) * LIVENESS_RATIO) return undefined;
1341
1512
  periodic.size = expanded;
1342
1513
  const lasso = liveness?.findViolation();
1343
- current.livenessSource = -1;
1344
1514
  periodic.time += performance.now() - now;
1345
1515
  return lasso;
1346
1516
  };
1347
- setNextStatePhase(true);
1348
1517
  for (let index = 0; index < states.length && !runtime.isStopped; index++) {
1349
1518
  current.index = index;
1350
1519
  current.candidate = undefined;
@@ -1353,22 +1522,21 @@ export const checkSequentially = (options: CheckOptions): CheckResult => {
1353
1522
  try {
1354
1523
  outcome.result = expandState(index);
1355
1524
  } catch (error) {
1356
- outcome.result = toFailure(error, getStateTrace(index));
1525
+ outcome.result = toFailure(withNextStateExitCode(error), getStateTrace(index));
1357
1526
  }
1358
1527
  if (outcome.result) return outcome.result;
1359
1528
  outDegrees[getOutDegreeBucket()]++;
1360
1529
  expansion.newStates = 0;
1361
1530
  if (isPeriodic && performance.now() >= periodic.at) {
1362
1531
  const lasso = findPeriodicViolation(index + 1);
1363
- if (lasso) return reportLasso(lasso);
1532
+ if (liveness && lasso) return reportLasso(liveness, lasso);
1364
1533
  }
1365
1534
  }
1366
1535
 
1367
1536
  current.index = -1;
1368
1537
  current.candidate = undefined;
1369
1538
  const lasso = liveness?.findViolation();
1370
- current.livenessSource = -1;
1371
- if (lasso) return reportLasso(lasso);
1539
+ if (liveness && lasso) return reportLasso(liveness, lasso);
1372
1540
 
1373
1541
  const postconditionViolation = search.findPostconditionViolation();
1374
1542
  if (postconditionViolation) {
@@ -0,0 +1,64 @@
1
+ export interface OptionSpec {
2
+ flag: string;
3
+ isRequired?: boolean;
4
+ isRepeatable?: boolean;
5
+ // How many of the arguments after the flag the option takes, when that depends on them.
6
+ getArity?: (rest: string[]) => number;
7
+ }
8
+
9
+ export interface ParsedOption {
10
+ name: string;
11
+ values: string[];
12
+ }
13
+
14
+ export interface ParsedArgs {
15
+ options: ParsedOption[];
16
+ positionals: string[];
17
+ unknown: string[];
18
+ incomplete: ParsedOption | undefined;
19
+ has: (name: string) => boolean;
20
+ get: (name: string) => string[] | undefined;
21
+ }
22
+
23
+ const formatOption = (spec: OptionSpec) => {
24
+ const text = spec.isRequired ? spec.flag : `[${spec.flag}]`;
25
+ return spec.isRepeatable ? `${text}...` : text;
26
+ };
27
+
28
+ // Each <name> in a flag such as "--toolbox <start> <end>" is one value the option takes, and
29
+ // {options} in the usage stands for the options.
30
+ export const defineCommand = (usage: string, specs: OptionSpec[]) => {
31
+ const arities = new Map(
32
+ specs.map((spec) => {
33
+ const [name, ...values] = spec.flag.split(" ");
34
+ return [name, spec.getArity ?? (() => values.length)];
35
+ }),
36
+ );
37
+ const parse = (args: string[]): ParsedArgs => {
38
+ const options: ParsedOption[] = [];
39
+ const positionals: string[] = [];
40
+ const unknown: string[] = [];
41
+ const incomplete: ParsedOption[] = [];
42
+ for (let index = 0; index < args.length; index++) {
43
+ const getArity = arities.get(args[index]);
44
+ if (getArity === undefined) {
45
+ (args[index].startsWith("-") ? unknown : positionals).push(args[index]);
46
+ continue;
47
+ }
48
+ const arity = getArity(args.slice(index + 1));
49
+ const option = { name: args[index], values: args.slice(index + 1, index + 1 + arity) };
50
+ options.push(option);
51
+ if (option.values.length < arity) incomplete.push(option);
52
+ index += arity;
53
+ }
54
+ return {
55
+ options,
56
+ positionals,
57
+ unknown,
58
+ incomplete: incomplete[0],
59
+ has: (name) => options.some((option) => option.name === name),
60
+ get: (name) => options.findLast((option) => option.name === name)?.values,
61
+ };
62
+ };
63
+ return { usage: usage.replace("{options}", specs.map(formatOption).join(" ")), parse };
64
+ };
package/src/codegen.ts CHANGED
@@ -1,11 +1,8 @@
1
- import type { Expression } from "./ast";
2
- import { TlaEvaluationError } from "./errors";
1
+ import { getChildren, isLocallyResolved, type Expression } from "./ast";
3
2
  import {
4
- describeLocation,
5
3
  bindValue,
6
4
  expectBoolean,
7
5
  findGlobalName,
8
- getChildren,
9
6
  getEnumeratedElements,
10
7
  getConditionError,
11
8
  getConjunctError,
@@ -14,19 +11,21 @@ import {
14
11
  getEvaluator,
15
12
  getFieldError,
16
13
  isClosedConstant,
17
- isLocallyResolved,
18
14
  isTlcInteger,
19
15
  isValueArgument,
20
16
  isWorthCaching,
21
17
  keepLazy,
22
18
  resolveGlobalOperator,
19
+ createPrimeOutsideActionError,
20
+ createUnassignedError,
21
+ getSortedFields,
22
+ hasDuplicateFields,
23
23
  type Context,
24
24
  type Environment,
25
25
  type Evaluator,
26
26
  } from "./evaluate";
27
27
  import {
28
28
  applyFunction,
29
- compareValues,
30
29
  createEnumeratedSet,
31
30
  createSortedFunction,
32
31
  createTuple,
@@ -84,14 +83,10 @@ const createRuntime = () => ({
84
83
  equal: valuesEqual,
85
84
  enumerate: getEnumeratedElements,
86
85
  unassigned: (name: string, expression: Expression): never => {
87
- throw new TlaEvaluationError(
88
- `The variable ${name} is not assigned at ${describeLocation(expression)}`,
89
- );
86
+ throw createUnassignedError(name, expression);
90
87
  },
91
88
  primeOutsideAction: (expression: Expression): never => {
92
- throw new TlaEvaluationError(
93
- `A primed expression appears outside an action at ${describeLocation(expression)}`,
94
- );
89
+ throw createPrimeOutsideActionError(expression);
95
90
  },
96
91
  prime: (context: Context): Context => ({
97
92
  environment: context.environment,
@@ -262,13 +257,8 @@ const generateExpression = (generator: Generator, expression: Expression, frame:
262
257
  case "FieldAccess":
263
258
  return `apply(${generate(expression.record)}, ${JSON.stringify(expression.field)}, ${addReference(generator, getFieldError(expression))})`;
264
259
  case "Record": {
265
- const fields = [...expression.fields].sort((left, right) =>
266
- compareValues(left.name, right.name),
267
- );
268
- const hasDuplicates = fields.some(
269
- (field, index) => index > 0 && fields[index - 1].name === field.name,
270
- );
271
- if (hasDuplicates) return generateDelegate(generator, expression, frame);
260
+ const fields = getSortedFields(expression.fields);
261
+ if (hasDuplicateFields(fields)) return generateDelegate(generator, expression, frame);
272
262
  const names = addReference(
273
263
  generator,
274
264
  fields.map((field) => field.name),
@@ -1,5 +1,5 @@
1
- import type { Definition, Expression } from "./ast";
2
- import { getChildren, isImpureBuiltin, type Environment } from "./evaluate";
1
+ import { getChildren, type Definition, type Expression } from "./ast";
2
+ import { isImpureBuiltin, type Environment } from "./evaluate";
3
3
 
4
4
  const STATE_INDEPENDENT_KINDS = new Set([
5
5
  "Prime",