tla-ts 0.0.3-dev.9c2dda8 → 0.0.3-dev.b1578d0

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.9c2dda8",
3
+ "version": "0.0.3-dev.b1578d0",
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;
@@ -820,7 +841,10 @@ export const createSearch = (
820
841
  )
821
842
  );
822
843
  } catch (error) {
823
- throw withHeadline(error, `Evaluating action property ${property.name} failed.`);
844
+ throw withHeadline(
845
+ withNextStateExitCode(error),
846
+ `Evaluating action property ${property.name} failed.`,
847
+ );
824
848
  }
825
849
  }),
826
850
  satisfiesActionConstraints: (state, next) =>
@@ -828,8 +852,7 @@ export const createSearch = (
828
852
  holdsLikeTlc(
829
853
  constraint.expression,
830
854
  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)}`,
855
+ (expression) => `${UNEXPECTED_EXCEPTION}${getExpectedBoolean(expression, environment)}`,
833
856
  ),
834
857
  ),
835
858
  trackStatePossible:
@@ -857,6 +880,11 @@ export const createSearch = (
857
880
  };
858
881
  };
859
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
+
860
888
  const withHeadline = (error: unknown, headline: string) =>
861
889
  error instanceof TlaEvaluationError
862
890
  ? setExitCode(
@@ -865,8 +893,15 @@ const withHeadline = (error: unknown, headline: string) =>
865
893
  )
866
894
  : error;
867
895
 
896
+ // TLC finishes the -dump file whether or not the search finds a violation.
868
897
  export const checkSequentially = (options: CheckOptions): CheckResult => {
869
- 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 => {
870
905
  const config = typeof options.config === "string" ? parseConfig(options.config) : options.config;
871
906
  const onPrint = options.onPrint ?? console.log;
872
907
  // TLC prints again while it rebuilds a trace, between the states it prints. Printing those lines
@@ -962,8 +997,36 @@ export const checkSequentially = (options: CheckOptions): CheckResult => {
962
997
  const getFingerprintState = search.getFingerprintState;
963
998
  const nextActions = { value: undefined as SpecAction[] | undefined };
964
999
  const isReducing = config.view !== undefined || config.symmetry !== undefined;
1000
+ const tlcFingerprints: number[] = [];
965
1001
  const liveness = withLivenessExitCode(() =>
966
- 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
+ }),
967
1030
  );
968
1031
  const isCanonicalizedFirst = search.isSymmetric || liveness !== undefined;
969
1032
 
@@ -985,11 +1048,16 @@ export const checkSequentially = (options: CheckOptions): CheckResult => {
985
1048
  position: number,
986
1049
  loopStart: number | undefined,
987
1050
  ) => {
988
- const state = steps[position].state;
989
- const next = (steps[position + 1] ?? steps[loopStart ?? position]).state;
990
1051
  // TLC evaluates TLCGet("level") and Trace in an alias at the state's position in the trace.
991
1052
  runtime.getLevel = () => position + 1;
992
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) => {
993
1061
  try {
994
1062
  const body = getConfigDefinition("alias", alias, environment).body;
995
1063
  const value = evaluate(createIdentifier(alias), getContext(environment, state, next));
@@ -1104,7 +1172,7 @@ export const checkSequentially = (options: CheckOptions): CheckResult => {
1104
1172
  outDegrees: failureOutDegrees,
1105
1173
  };
1106
1174
  };
1107
- const getPathTrace = (path: number[], loopStart?: number) => {
1175
+ const getPathSteps = (path: number[], loopStart?: number) => {
1108
1176
  const steps = getPathStates(path, NEXT_RECOVERY_FAILURE);
1109
1177
  const last = steps[steps.length - 1].state;
1110
1178
  const isClosed =
@@ -1113,7 +1181,7 @@ export const checkSequentially = (options: CheckOptions): CheckResult => {
1113
1181
  loopStart === path.length - 1 ||
1114
1182
  findSuccessorWithFingerprint(last, path[loopStart]) !== undefined;
1115
1183
  if (!isClosed) throw new TlaEvaluationError(NEXT_RECOVERY_FAILURE);
1116
- return toTrace(steps, path, loopStart);
1184
+ return steps;
1117
1185
  };
1118
1186
  const getStateHash = (state: Value[]) => {
1119
1187
  let hash = 0x811c9dc5;
@@ -1179,7 +1247,7 @@ export const checkSequentially = (options: CheckOptions): CheckResult => {
1179
1247
  };
1180
1248
  runtime.getCurrentState = () => (current.index === -1 ? undefined : states[current.index]);
1181
1249
  runtime.setLivenessSource = (index) => {
1182
- current.livenessSource = index;
1250
+ current.livenessSource = index ?? -1;
1183
1251
  };
1184
1252
  runtime.getLevel = (state) => {
1185
1253
  const source = current.livenessSource;
@@ -1190,6 +1258,18 @@ export const checkSequentially = (options: CheckOptions): CheckResult => {
1190
1258
  return current.isExpanding ? depths[current.index] + 1 : 0;
1191
1259
  };
1192
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
+
1193
1273
  const visitInitialState = (state: Value[]) => {
1194
1274
  canonicalizeState(state);
1195
1275
  runtime.generatedStates++;
@@ -1206,6 +1286,7 @@ export const checkSequentially = (options: CheckOptions): CheckResult => {
1206
1286
  countDistinctState(1);
1207
1287
  runtime.queueSize++;
1208
1288
  liveness?.addInitialState(states.length, state);
1289
+ stateWriter?.writeInitialState(getGraphState(state, 1));
1209
1290
  }
1210
1291
  const violated = search.findViolatedInvariant(state);
1211
1292
  if (violated) {
@@ -1226,7 +1307,13 @@ export const checkSequentially = (options: CheckOptions): CheckResult => {
1226
1307
  addState(state, fingerprintState, -1, undefined);
1227
1308
  return undefined;
1228
1309
  };
1229
- 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
+ ) => {
1230
1317
  const state = states[index];
1231
1318
  runtime.generatedStates++;
1232
1319
  current.candidate = successor.state;
@@ -1240,6 +1327,14 @@ export const checkSequentially = (options: CheckOptions): CheckResult => {
1240
1327
  const isInModel = isStateInModel && search.satisfiesActionConstraints(state, successor.state);
1241
1328
  if (isInModel) search.trackActionPossible(state, successor.state);
1242
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
+ }
1243
1338
  if (existing !== -1 && liveness) {
1244
1339
  const stored = states[existing];
1245
1340
  const isStored = stored.every((value, position) => value === successor.state[position]);
@@ -1311,23 +1406,55 @@ export const checkSequentially = (options: CheckOptions): CheckResult => {
1311
1406
  }
1312
1407
  return createSuccess();
1313
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
+ };
1314
1446
  const expandState = (index: number) => {
1315
1447
  const state = states[index];
1316
1448
  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
- );
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
+ });
1331
1458
  current.isExpanding = false;
1332
1459
  if (outcome.result) return outcome.result;
1333
1460
  if (successorCount === 0 && config.checkDeadlock) {
@@ -1335,32 +1462,43 @@ export const checkSequentially = (options: CheckOptions): CheckResult => {
1335
1462
  }
1336
1463
  try {
1337
1464
  const accepted = liveness?.addState(index, state, liveSuccessors);
1338
- current.livenessSource = -1;
1339
- 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
+ );
1340
1471
  return reportViolation("property-violation", {
1341
- name: accepted.name,
1342
- trace: getPathTrace(accepted.path),
1472
+ name: properties[0],
1473
+ properties,
1474
+ trace: toTrace(steps, accepted),
1343
1475
  });
1344
1476
  } catch (error) {
1345
1477
  return toFailure(error, getStateTrace(index), undefined, getPartialOutDegrees());
1346
1478
  }
1347
1479
  };
1348
- 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) => {
1349
1482
  const path = [...lasso.prefix, ...lasso.cycle];
1350
- const trace = getPathTrace(path, lasso.prefix.length);
1351
- 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];
1352
1491
  const last = path[path.length - 1];
1492
+ const lastState = steps[steps.length - 1].state;
1353
1493
  const loopLabel =
1354
- back === last ? undefined : withoutOutput(() => getLabel(last, states[last], states[back]));
1494
+ back === last ? undefined : withoutOutput(() => getLabel(last, lastState, states[back]));
1355
1495
  return reportViolation(
1356
1496
  "liveness-violation",
1357
- { name: lasso.name, trace, loopStart: lasso.prefix.length, loopLabel },
1497
+ { name: properties[0], properties, trace, loopStart, loopLabel },
1358
1498
  () =>
1359
1499
  back === last
1360
1500
  ? trace[trace.length - 1].action
1361
- : getTraceSuccessors(states[last]).find((successor) =>
1362
- isSameState(successor.state, states[back]),
1363
- )?.action,
1501
+ : findSuccessorWithFingerprint(lastState, back)?.action,
1364
1502
  );
1365
1503
  };
1366
1504
  const isPeriodic = liveness !== undefined && options.livenessCheck !== "final";
@@ -1373,11 +1511,9 @@ export const checkSequentially = (options: CheckOptions): CheckResult => {
1373
1511
  if (!isGrown || periodic.time > (now - startedAt) * LIVENESS_RATIO) return undefined;
1374
1512
  periodic.size = expanded;
1375
1513
  const lasso = liveness?.findViolation();
1376
- current.livenessSource = -1;
1377
1514
  periodic.time += performance.now() - now;
1378
1515
  return lasso;
1379
1516
  };
1380
- setNextStatePhase(true);
1381
1517
  for (let index = 0; index < states.length && !runtime.isStopped; index++) {
1382
1518
  current.index = index;
1383
1519
  current.candidate = undefined;
@@ -1386,22 +1522,21 @@ export const checkSequentially = (options: CheckOptions): CheckResult => {
1386
1522
  try {
1387
1523
  outcome.result = expandState(index);
1388
1524
  } catch (error) {
1389
- outcome.result = toFailure(error, getStateTrace(index));
1525
+ outcome.result = toFailure(withNextStateExitCode(error), getStateTrace(index));
1390
1526
  }
1391
1527
  if (outcome.result) return outcome.result;
1392
1528
  outDegrees[getOutDegreeBucket()]++;
1393
1529
  expansion.newStates = 0;
1394
1530
  if (isPeriodic && performance.now() >= periodic.at) {
1395
1531
  const lasso = findPeriodicViolation(index + 1);
1396
- if (lasso) return reportLasso(lasso);
1532
+ if (liveness && lasso) return reportLasso(liveness, lasso);
1397
1533
  }
1398
1534
  }
1399
1535
 
1400
1536
  current.index = -1;
1401
1537
  current.candidate = undefined;
1402
1538
  const lasso = liveness?.findViolation();
1403
- current.livenessSource = -1;
1404
- if (lasso) return reportLasso(lasso);
1539
+ if (liveness && lasso) return reportLasso(liveness, lasso);
1405
1540
 
1406
1541
  const postconditionViolation = search.findPostconditionViolation();
1407
1542
  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
  };
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",