tla-ts 0.0.3-dev.e946acb → 0.0.3-dev.eba78ea

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.
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "tla-ts",
3
- "version": "0.0.3-dev.e946acb",
3
+ "version": "0.0.3-dev.eba78ea",
4
4
  "description": "A TLA+ interpreter and model checker in TypeScript, 2× faster than TLC",
5
5
  "keywords": [
6
6
  "formal verification",
package/src/ast.ts CHANGED
@@ -486,3 +486,93 @@ export interface Module {
486
486
  uses: UseOrHide[];
487
487
  units: ModuleUnit[];
488
488
  }
489
+
490
+ export const getChildren = (expression: Expression): Expression[] => {
491
+ switch (expression.kind) {
492
+ case "Number":
493
+ case "Decimal":
494
+ case "String":
495
+ case "Identifier":
496
+ case "OperatorReference":
497
+ case "ExceptAt":
498
+ return [];
499
+ case "Apply":
500
+ return expression.args;
501
+ case "Lambda":
502
+ return [expression.body];
503
+ case "And":
504
+ case "Or":
505
+ return expression.operands;
506
+ case "Prime":
507
+ case "Unchanged":
508
+ case "Enabled":
509
+ case "Always":
510
+ case "Eventually":
511
+ return [expression.expression];
512
+ case "If":
513
+ return [expression.condition, expression.consequent, expression.alternative];
514
+ case "Case":
515
+ return [
516
+ ...expression.arms.flatMap((arm) => [arm.condition, arm.body]),
517
+ ...(expression.other ? [expression.other] : []),
518
+ ];
519
+ case "Let":
520
+ return [
521
+ ...expression.definitions.flatMap((definition) =>
522
+ definition.kind === "Function"
523
+ ? [...definition.bounds.map((bound) => bound.set), definition.body]
524
+ : [definition.body],
525
+ ),
526
+ expression.body,
527
+ ];
528
+ case "Forall":
529
+ case "Exists":
530
+ return [...expression.bounds.map((bound) => bound.set), expression.body];
531
+ case "UnboundedQuantifier":
532
+ return [expression.body];
533
+ case "Choose":
534
+ return [...(expression.set ? [expression.set] : []), expression.body];
535
+ case "SetEnumeration":
536
+ case "Tuple":
537
+ return expression.elements;
538
+ case "SetFilter":
539
+ return [expression.bound.set, expression.predicate];
540
+ case "SetMap":
541
+ return [expression.expression, ...expression.bounds.map((bound) => bound.set)];
542
+ case "FunctionConstruction":
543
+ return [...expression.bounds.map((bound) => bound.set), expression.body];
544
+ case "FunctionSet":
545
+ return [expression.domain, expression.range];
546
+ case "Record":
547
+ case "RecordSet":
548
+ return expression.fields.map((field) => field.value);
549
+ case "Except":
550
+ return [
551
+ expression.function,
552
+ ...expression.updates.flatMap((update) => [
553
+ ...update.path.flatMap((step) => (step.kind === "Index" ? step.args : [])),
554
+ update.value,
555
+ ]),
556
+ ];
557
+ case "FunctionApplication":
558
+ return [expression.function, ...expression.args];
559
+ case "FieldAccess":
560
+ return [expression.record];
561
+ case "Product":
562
+ return expression.factors;
563
+ case "BoxAction":
564
+ case "AngleAction":
565
+ return [expression.action, expression.subscript];
566
+ case "WeakFairness":
567
+ case "StrongFairness":
568
+ return [expression.subscript, expression.action];
569
+ case "Label":
570
+ return [expression.body];
571
+ case "Subexpression":
572
+ return expression.selectors.flatMap((selector) => ("args" in selector ? selector.args : []));
573
+ }
574
+ };
575
+
576
+ export const isLocallyResolved = (expression: Expression) =>
577
+ (expression.kind === "Identifier" || expression.kind === "Apply") &&
578
+ expression.resolution?.kind === "Local";
package/src/check.ts CHANGED
@@ -1,32 +1,41 @@
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,
16
- isLocallyResolved,
17
28
  type Context,
18
29
  type Environment,
19
30
  type Scope,
20
31
  } from "./evaluate";
21
32
  import {
22
33
  createLivenessChecker,
23
- expandTemporal,
24
- getLevel,
25
34
  type Lasso,
35
+ type LivenessChecker,
26
36
  type LiveSuccessor,
27
- type ScopedExpression,
28
- type TemporalProperty,
29
- } from "./liveness";
37
+ } from "./live-check";
38
+ import { expandTemporal, getLevel, type ScopedExpression, type TemporalProperty } from "./liveness";
30
39
  import { ACTION_LEVEL, createLevelAnalyzer, TEMPORAL_LEVEL } from "./levels";
31
40
  import { prettyPrint } from "./pretty-print";
32
41
  import {
@@ -38,10 +47,17 @@ import {
38
47
  } from "./successors";
39
48
  import {
40
49
  getActionLabel,
50
+ getActionSignature,
41
51
  getNextActions,
42
52
  getSpecificationValue,
43
53
  type SpecAction,
44
54
  } from "./spec-description";
55
+ import {
56
+ createStateWriter,
57
+ type GraphState,
58
+ type StateDump,
59
+ type StateWriter,
60
+ } from "./state-graph";
45
61
  import { getRepresentative, getSymmetryGroup } from "./symmetry";
46
62
  import { getTlcStringOrder, getTlcVariableOrder } from "./tlc-order";
47
63
  import { createTlcFingerprinter, getTlcFingerprint } from "./tlc-random";
@@ -51,6 +67,7 @@ import { createCounterExample } from "./tlc-ext";
51
67
  import { getFingerprintDistance, OUT_DEGREE_BUCKETS } from "./tlc-summary";
52
68
  import {
53
69
  combineHash,
70
+ formatState,
54
71
  formatValue,
55
72
  getValueHash,
56
73
  isFunctionValue,
@@ -74,6 +91,8 @@ export interface CheckOptions {
74
91
  workers?: number;
75
92
  // TLC's -lncheck: "final" checks liveness only on the complete state graph.
76
93
  livenessCheck?: "default" | "final";
94
+ // TLC's -dump: writes the reachable states, or with `dot` the state graph, through writeFile.
95
+ dump?: StateDump;
77
96
  }
78
97
 
79
98
  export type CheckStatus =
@@ -95,6 +114,8 @@ export interface TraceStep {
95
114
 
96
115
  export interface Violation {
97
116
  name: string;
117
+ // Every temporal property that a liveness counterexample violates, in the configuration's order.
118
+ properties?: string[];
98
119
  trace: TraceStep[];
99
120
  loopStart: number | undefined;
100
121
  loopLabel?: string;
@@ -507,7 +528,9 @@ const getMembership = (
507
528
  const getStateChecks = (named: NamedExpression[], environment: Environment): StateCheck[] =>
508
529
  named.flatMap((item) =>
509
530
  getConjuncts(item.expression, environment).map((expression) => {
510
- const variables = getReadVariables(expression, environment);
531
+ // A LET or an argument in the scope can read variables the expression doesn't name.
532
+ const variables =
533
+ item.scope === undefined ? getReadVariables(expression, environment) : undefined;
511
534
  return {
512
535
  name: item.name,
513
536
  expression,
@@ -820,7 +843,10 @@ export const createSearch = (
820
843
  )
821
844
  );
822
845
  } catch (error) {
823
- throw withHeadline(error, `Evaluating action property ${property.name} failed.`);
846
+ throw withHeadline(
847
+ withNextStateExitCode(error),
848
+ `Evaluating action property ${property.name} failed.`,
849
+ );
824
850
  }
825
851
  }),
826
852
  satisfiesActionConstraints: (state, next) =>
@@ -828,8 +854,7 @@ export const createSearch = (
828
854
  holdsLikeTlc(
829
855
  constraint.expression,
830
856
  getContext(environment, state, next),
831
- (expression) =>
832
- `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)}`,
857
+ (expression) => `${UNEXPECTED_EXCEPTION}${getExpectedBoolean(expression, environment)}`,
833
858
  ),
834
859
  ),
835
860
  trackStatePossible:
@@ -857,6 +882,11 @@ export const createSearch = (
857
882
  };
858
883
  };
859
884
 
885
+ // TLC exits with the code of a standard module's failure only when the failure escapes the
886
+ // computation of next states. In every other phase, the phase decides the code.
887
+ const withNextStateExitCode = (error: unknown) =>
888
+ error instanceof TlaModuleError ? setExitCode(error, error.exitCode) : error;
889
+
860
890
  const withHeadline = (error: unknown, headline: string) =>
861
891
  error instanceof TlaEvaluationError
862
892
  ? setExitCode(
@@ -865,8 +895,15 @@ const withHeadline = (error: unknown, headline: string) =>
865
895
  )
866
896
  : error;
867
897
 
898
+ // TLC finishes the -dump file whether or not the search finds a violation.
868
899
  export const checkSequentially = (options: CheckOptions): CheckResult => {
869
- setNextStatePhase(false);
900
+ const stateWriter = options.dump && createStateWriter(options.dump, options.writeFile);
901
+ const result = searchStates(options, stateWriter);
902
+ stateWriter?.close();
903
+ return result;
904
+ };
905
+
906
+ const searchStates = (options: CheckOptions, stateWriter: StateWriter | undefined): CheckResult => {
870
907
  const config = typeof options.config === "string" ? parseConfig(options.config) : options.config;
871
908
  const onPrint = options.onPrint ?? console.log;
872
909
  // TLC prints again while it rebuilds a trace, between the states it prints. Printing those lines
@@ -962,8 +999,36 @@ export const checkSequentially = (options: CheckOptions): CheckResult => {
962
999
  const getFingerprintState = search.getFingerprintState;
963
1000
  const nextActions = { value: undefined as SpecAction[] | undefined };
964
1001
  const isReducing = config.view !== undefined || config.symmetry !== undefined;
1002
+ const tlcFingerprints: number[] = [];
965
1003
  const liveness = withLivenessExitCode(() =>
966
- createLivenessChecker(search.properties.liveness, spec.temporals, environment),
1004
+ createLivenessChecker(search.properties.liveness, spec.temporals, environment, {
1005
+ getFingerprint: (index) =>
1006
+ (tlcFingerprints[index] ??= Number(
1007
+ BigInt.asIntN(32, runtime.getFingerprint(states[index])),
1008
+ )),
1009
+ getSuccessors: (state) => {
1010
+ const successors: LiveSuccessor[] = [];
1011
+ if (spec.next === undefined) return successors;
1012
+ forEachSuccessor(
1013
+ spec.next,
1014
+ state,
1015
+ environment,
1016
+ (successor) => {
1017
+ canonicalizeState(successor.state);
1018
+ const isInModel =
1019
+ search.satisfiesConstraints(successor.state, state) &&
1020
+ search.satisfiesActionConstraints(state, successor.state);
1021
+ if (!isInModel) return false;
1022
+ const fingerprintState = getFingerprintState(successor.state);
1023
+ const index = findStateIndex(getStateHash(fingerprintState), fingerprintState);
1024
+ successors.push({ index, state: successor.state });
1025
+ return false;
1026
+ },
1027
+ spec.scope,
1028
+ );
1029
+ return successors;
1030
+ },
1031
+ }),
967
1032
  );
968
1033
  const isCanonicalizedFirst = search.isSymmetric || liveness !== undefined;
969
1034
 
@@ -972,7 +1037,9 @@ export const checkSequentially = (options: CheckOptions): CheckResult => {
972
1037
  const parents: number[] = [];
973
1038
  const actions: (string | undefined)[] = [];
974
1039
  const depths: number[] = [];
975
- const buckets = new Map<number, number | number[]>();
1040
+ // A Map holds at most 2^24 entries, so an open-addressing table keeps each seen state's hash
1041
+ // and its index plus one side by side, probed by the hash.
1042
+ const seen = { slots: new Int32Array(1 << 17), size: 0, shift: 16 };
976
1043
  const canonicalizeState = createCanonicalizer();
977
1044
 
978
1045
  const toRecord = (state: Value[]): Record<string, Value> =>
@@ -985,11 +1052,16 @@ export const checkSequentially = (options: CheckOptions): CheckResult => {
985
1052
  position: number,
986
1053
  loopStart: number | undefined,
987
1054
  ) => {
988
- const state = steps[position].state;
989
- const next = (steps[position + 1] ?? steps[loopStart ?? position]).state;
990
1055
  // TLC evaluates TLCGet("level") and Trace in an alias at the state's position in the trace.
991
1056
  runtime.getLevel = () => position + 1;
992
1057
  runtime.getBehavior = () => steps.slice(0, position + 1).map((step) => step.state);
1058
+ return evaluateAlias(
1059
+ alias,
1060
+ steps[position].state,
1061
+ (steps[position + 1] ?? steps[loopStart ?? position]).state,
1062
+ );
1063
+ };
1064
+ const evaluateAlias = (alias: string, state: Value[], next: Value[] | undefined) => {
993
1065
  try {
994
1066
  const body = getConfigDefinition("alias", alias, environment).body;
995
1067
  const value = evaluate(createIdentifier(alias), getContext(environment, state, next));
@@ -1104,7 +1176,7 @@ export const checkSequentially = (options: CheckOptions): CheckResult => {
1104
1176
  outDegrees: failureOutDegrees,
1105
1177
  };
1106
1178
  };
1107
- const getPathTrace = (path: number[], loopStart?: number) => {
1179
+ const getPathSteps = (path: number[], loopStart?: number) => {
1108
1180
  const steps = getPathStates(path, NEXT_RECOVERY_FAILURE);
1109
1181
  const last = steps[steps.length - 1].state;
1110
1182
  const isClosed =
@@ -1113,7 +1185,7 @@ export const checkSequentially = (options: CheckOptions): CheckResult => {
1113
1185
  loopStart === path.length - 1 ||
1114
1186
  findSuccessorWithFingerprint(last, path[loopStart]) !== undefined;
1115
1187
  if (!isClosed) throw new TlaEvaluationError(NEXT_RECOVERY_FAILURE);
1116
- return toTrace(steps, path, loopStart);
1188
+ return steps;
1117
1189
  };
1118
1190
  const getStateHash = (state: Value[]) => {
1119
1191
  let hash = 0x811c9dc5;
@@ -1127,19 +1199,35 @@ export const checkSequentially = (options: CheckOptions): CheckResult => {
1127
1199
  }
1128
1200
  return true;
1129
1201
  };
1202
+ const getSlot = (hash: number) => (Math.imul(hash, 0x9e3779b1) >>> seen.shift) << 1;
1130
1203
  const findStateIndex = (hash: number, state: Value[]) => {
1131
- const bucket = buckets.get(hash);
1132
- if (bucket === undefined) return -1;
1133
- if (typeof bucket === "number") {
1134
- return isSameState(fingerprintStates[bucket], state) ? bucket : -1;
1204
+ const mask = seen.slots.length - 1;
1205
+ for (let slot = getSlot(hash); ; slot = (slot + 2) & mask) {
1206
+ const entry = seen.slots[slot + 1];
1207
+ if (entry === 0) return -1;
1208
+ if (seen.slots[slot] === hash && isSameState(fingerprintStates[entry - 1], state)) {
1209
+ return entry - 1;
1210
+ }
1135
1211
  }
1136
- return bucket.find((index) => isSameState(fingerprintStates[index], state)) ?? -1;
1212
+ };
1213
+ const insertSeen = (hash: number, entry: number) => {
1214
+ const mask = seen.slots.length - 1;
1215
+ let slot = getSlot(hash);
1216
+ while (seen.slots[slot + 1] !== 0) slot = (slot + 2) & mask;
1217
+ seen.slots[slot] = hash;
1218
+ seen.slots[slot + 1] = entry;
1137
1219
  };
1138
1220
  const markSeen = (hash: number, index: number) => {
1139
- const bucket = buckets.get(hash);
1140
- if (bucket === undefined) buckets.set(hash, index);
1141
- else if (typeof bucket === "number") buckets.set(hash, [bucket, index]);
1142
- else bucket.push(index);
1221
+ seen.size++;
1222
+ if (seen.size * 4 > seen.slots.length) {
1223
+ const slots = seen.slots;
1224
+ seen.slots = new Int32Array(slots.length * 2);
1225
+ seen.shift--;
1226
+ for (let slot = 0; slot < slots.length; slot += 2) {
1227
+ if (slots[slot + 1] !== 0) insertSeen(slots[slot], slots[slot + 1]);
1228
+ }
1229
+ }
1230
+ insertSeen(hash, index + 1);
1143
1231
  };
1144
1232
  const countDistinctState = (depth: number) => {
1145
1233
  runtime.distinctStates = states.length + 1;
@@ -1179,7 +1267,7 @@ export const checkSequentially = (options: CheckOptions): CheckResult => {
1179
1267
  };
1180
1268
  runtime.getCurrentState = () => (current.index === -1 ? undefined : states[current.index]);
1181
1269
  runtime.setLivenessSource = (index) => {
1182
- current.livenessSource = index;
1270
+ current.livenessSource = index ?? -1;
1183
1271
  };
1184
1272
  runtime.getLevel = (state) => {
1185
1273
  const source = current.livenessSource;
@@ -1190,6 +1278,18 @@ export const checkSequentially = (options: CheckOptions): CheckResult => {
1190
1278
  return current.isExpanding ? depths[current.index] + 1 : 0;
1191
1279
  };
1192
1280
 
1281
+ const getGraphState = (state: Value[], level: number): GraphState => ({
1282
+ fingerprint: BigInt.asIntN(64, runtime.getFingerprint(state)),
1283
+ level,
1284
+ getLabel: () =>
1285
+ formatState(
1286
+ config.alias === undefined
1287
+ ? toRecord(state)
1288
+ : evaluateAlias(config.alias, state, undefined),
1289
+ ),
1290
+ getText: () => formatState(toRecord(state)),
1291
+ });
1292
+
1193
1293
  const visitInitialState = (state: Value[]) => {
1194
1294
  canonicalizeState(state);
1195
1295
  runtime.generatedStates++;
@@ -1206,6 +1306,7 @@ export const checkSequentially = (options: CheckOptions): CheckResult => {
1206
1306
  countDistinctState(1);
1207
1307
  runtime.queueSize++;
1208
1308
  liveness?.addInitialState(states.length, state);
1309
+ stateWriter?.writeInitialState(getGraphState(state, 1));
1209
1310
  }
1210
1311
  const violated = search.findViolatedInvariant(state);
1211
1312
  if (violated) {
@@ -1226,7 +1327,13 @@ export const checkSequentially = (options: CheckOptions): CheckResult => {
1226
1327
  addState(state, fingerprintState, -1, undefined);
1227
1328
  return undefined;
1228
1329
  };
1229
- const visitSuccessor = (index: number, successor: Successor, liveSuccessors: LiveSuccessor[]) => {
1330
+ const visitSuccessor = (
1331
+ index: number,
1332
+ successor: Successor,
1333
+ liveSuccessors: LiveSuccessor[],
1334
+ source: GraphState | undefined,
1335
+ action: SpecAction | undefined,
1336
+ ) => {
1230
1337
  const state = states[index];
1231
1338
  runtime.generatedStates++;
1232
1339
  current.candidate = successor.state;
@@ -1240,6 +1347,14 @@ export const checkSequentially = (options: CheckOptions): CheckResult => {
1240
1347
  const isInModel = isStateInModel && search.satisfiesActionConstraints(state, successor.state);
1241
1348
  if (isInModel) search.trackActionPossible(state, successor.state);
1242
1349
  const existing = isInModel ? found : -1;
1350
+ if (source && isInModel) {
1351
+ stateWriter?.writeSuccessor(
1352
+ source,
1353
+ getGraphState(successor.state, depths[index] + 1),
1354
+ existing !== -1,
1355
+ action && { name: action.name, signature: getActionSignature(action) },
1356
+ );
1357
+ }
1243
1358
  if (existing !== -1 && liveness) {
1244
1359
  const stored = states[existing];
1245
1360
  const isStored = stored.every((value, position) => value === successor.state[position]);
@@ -1311,23 +1426,55 @@ export const checkSequentially = (options: CheckOptions): CheckResult => {
1311
1426
  }
1312
1427
  return createSuccess();
1313
1428
  }
1429
+ // TLC labels and colors an edge of the -dump state graph by the action that generated it. When
1430
+ // the graph names its edges, the search generates successors action by action, as TLC does.
1431
+ const isNamingEdges = Boolean(
1432
+ options.dump?.dot && (options.dump.actionLabels || options.dump.colorize),
1433
+ );
1434
+ const forEachActionSuccessor = (
1435
+ state: Value[],
1436
+ onSuccessor: (successor: Successor, action: SpecAction | undefined) => boolean,
1437
+ ) => {
1438
+ if (!isNamingEdges) {
1439
+ return forEachSuccessor(
1440
+ next,
1441
+ state,
1442
+ environment,
1443
+ (successor) => onSuccessor(successor, undefined),
1444
+ spec.scope,
1445
+ );
1446
+ }
1447
+ nextActions.value ??= getNextActions(config, environment, specification.instanceActions);
1448
+ const progress = { isStopped: false };
1449
+ return nextActions.value.reduce((count, action) => {
1450
+ if (progress.isStopped) return count;
1451
+ return (
1452
+ count +
1453
+ forEachSuccessor(
1454
+ action.expression,
1455
+ state,
1456
+ environment,
1457
+ (successor) => {
1458
+ progress.isStopped = onSuccessor(successor, action);
1459
+ return progress.isStopped;
1460
+ },
1461
+ action.scope,
1462
+ )
1463
+ );
1464
+ }, 0);
1465
+ };
1314
1466
  const expandState = (index: number) => {
1315
1467
  const state = states[index];
1316
1468
  const liveSuccessors: LiveSuccessor[] = [];
1317
- const successorCount = forEachSuccessor(
1318
- next,
1319
- state,
1320
- environment,
1321
- (successor) => {
1322
- try {
1323
- outcome.result = visitSuccessor(index, successor, liveSuccessors);
1324
- } catch (error) {
1325
- outcome.result = toFailure(error, getTrace(index, successor));
1326
- }
1327
- return outcome.result !== undefined;
1328
- },
1329
- spec.scope,
1330
- );
1469
+ const source = stateWriter && getGraphState(state, depths[index]);
1470
+ const successorCount = forEachActionSuccessor(state, (successor, action) => {
1471
+ try {
1472
+ outcome.result = visitSuccessor(index, successor, liveSuccessors, source, action);
1473
+ } catch (error) {
1474
+ outcome.result = toFailure(error, getTrace(index, successor));
1475
+ }
1476
+ return outcome.result !== undefined;
1477
+ });
1331
1478
  current.isExpanding = false;
1332
1479
  if (outcome.result) return outcome.result;
1333
1480
  if (successorCount === 0 && config.checkDeadlock) {
@@ -1335,32 +1482,43 @@ export const checkSequentially = (options: CheckOptions): CheckResult => {
1335
1482
  }
1336
1483
  try {
1337
1484
  const accepted = liveness?.addState(index, state, liveSuccessors);
1338
- current.livenessSource = -1;
1339
- if (!accepted) return undefined;
1485
+ if (!liveness || !accepted) return undefined;
1486
+ const steps = getPathSteps(accepted);
1487
+ const properties = liveness.getViolatedProperties(
1488
+ steps.map((step) => step.state),
1489
+ steps.length - 1,
1490
+ );
1340
1491
  return reportViolation("property-violation", {
1341
- name: accepted.name,
1342
- trace: getPathTrace(accepted.path),
1492
+ name: properties[0],
1493
+ properties,
1494
+ trace: toTrace(steps, accepted),
1343
1495
  });
1344
1496
  } catch (error) {
1345
1497
  return toFailure(error, getStateTrace(index), undefined, getPartialOutDegrees());
1346
1498
  }
1347
1499
  };
1348
- const reportLasso = (lasso: Lasso) => {
1500
+ // TLC names the properties and the step back into the cycle from the states it prints.
1501
+ const reportLasso = (checker: LivenessChecker, lasso: Lasso) => {
1349
1502
  const path = [...lasso.prefix, ...lasso.cycle];
1350
- const trace = getPathTrace(path, lasso.prefix.length);
1351
- const back = path[lasso.prefix.length];
1503
+ const loopStart = lasso.prefix.length;
1504
+ const steps = getPathSteps(path, loopStart);
1505
+ const trace = toTrace(steps, path, loopStart);
1506
+ const properties = checker.getViolatedProperties(
1507
+ steps.map((step) => step.state),
1508
+ loopStart,
1509
+ );
1510
+ const back = path[loopStart];
1352
1511
  const last = path[path.length - 1];
1512
+ const lastState = steps[steps.length - 1].state;
1353
1513
  const loopLabel =
1354
- back === last ? undefined : withoutOutput(() => getLabel(last, states[last], states[back]));
1514
+ back === last ? undefined : withoutOutput(() => getLabel(last, lastState, states[back]));
1355
1515
  return reportViolation(
1356
1516
  "liveness-violation",
1357
- { name: lasso.name, trace, loopStart: lasso.prefix.length, loopLabel },
1517
+ { name: properties[0], properties, trace, loopStart, loopLabel },
1358
1518
  () =>
1359
1519
  back === last
1360
1520
  ? trace[trace.length - 1].action
1361
- : getTraceSuccessors(states[last]).find((successor) =>
1362
- isSameState(successor.state, states[back]),
1363
- )?.action,
1521
+ : findSuccessorWithFingerprint(lastState, back)?.action,
1364
1522
  );
1365
1523
  };
1366
1524
  const isPeriodic = liveness !== undefined && options.livenessCheck !== "final";
@@ -1373,11 +1531,9 @@ export const checkSequentially = (options: CheckOptions): CheckResult => {
1373
1531
  if (!isGrown || periodic.time > (now - startedAt) * LIVENESS_RATIO) return undefined;
1374
1532
  periodic.size = expanded;
1375
1533
  const lasso = liveness?.findViolation();
1376
- current.livenessSource = -1;
1377
1534
  periodic.time += performance.now() - now;
1378
1535
  return lasso;
1379
1536
  };
1380
- setNextStatePhase(true);
1381
1537
  for (let index = 0; index < states.length && !runtime.isStopped; index++) {
1382
1538
  current.index = index;
1383
1539
  current.candidate = undefined;
@@ -1386,22 +1542,21 @@ export const checkSequentially = (options: CheckOptions): CheckResult => {
1386
1542
  try {
1387
1543
  outcome.result = expandState(index);
1388
1544
  } catch (error) {
1389
- outcome.result = toFailure(error, getStateTrace(index));
1545
+ outcome.result = toFailure(withNextStateExitCode(error), getStateTrace(index));
1390
1546
  }
1391
1547
  if (outcome.result) return outcome.result;
1392
1548
  outDegrees[getOutDegreeBucket()]++;
1393
1549
  expansion.newStates = 0;
1394
1550
  if (isPeriodic && performance.now() >= periodic.at) {
1395
1551
  const lasso = findPeriodicViolation(index + 1);
1396
- if (lasso) return reportLasso(lasso);
1552
+ if (liveness && lasso) return reportLasso(liveness, lasso);
1397
1553
  }
1398
1554
  }
1399
1555
 
1400
1556
  current.index = -1;
1401
1557
  current.candidate = undefined;
1402
1558
  const lasso = liveness?.findViolation();
1403
- current.livenessSource = -1;
1404
- if (lasso) return reportLasso(lasso);
1559
+ if (liveness && lasso) return reportLasso(liveness, lasso);
1405
1560
 
1406
1561
  const postconditionViolation = search.findPostconditionViolation();
1407
1562
  if (postconditionViolation) {
@@ -2,6 +2,8 @@ export interface OptionSpec {
2
2
  flag: string;
3
3
  isRequired?: boolean;
4
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;
5
7
  }
6
8
 
7
9
  export interface ParsedOption {
@@ -29,27 +31,31 @@ export const defineCommand = (usage: string, specs: OptionSpec[]) => {
29
31
  const arities = new Map(
30
32
  specs.map((spec) => {
31
33
  const [name, ...values] = spec.flag.split(" ");
32
- return [name, values.length];
34
+ return [name, spec.getArity ?? (() => values.length)];
33
35
  }),
34
36
  );
35
37
  const parse = (args: string[]): ParsedArgs => {
36
38
  const options: ParsedOption[] = [];
37
39
  const positionals: string[] = [];
38
40
  const unknown: string[] = [];
41
+ const incomplete: ParsedOption[] = [];
39
42
  for (let index = 0; index < args.length; index++) {
40
- const arity = arities.get(args[index]);
41
- if (arity === undefined) {
43
+ const getArity = arities.get(args[index]);
44
+ if (getArity === undefined) {
42
45
  (args[index].startsWith("-") ? unknown : positionals).push(args[index]);
43
46
  continue;
44
47
  }
45
- options.push({ name: args[index], values: args.slice(index + 1, index + 1 + arity) });
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);
46
52
  index += arity;
47
53
  }
48
54
  return {
49
55
  options,
50
56
  positionals,
51
57
  unknown,
52
- incomplete: options.find((option) => option.values.length < (arities.get(option.name) ?? 0)),
58
+ incomplete: incomplete[0],
53
59
  has: (name) => options.some((option) => option.name === name),
54
60
  get: (name) => options.findLast((option) => option.name === name)?.values,
55
61
  };