tla-ts 0.0.3-dev.3cf2ad0 → 0.0.3-dev.52c5b61
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/README.md +16 -2
- package/dist/index.cjs +1 -1
- package/dist/index.d.cts +9 -0
- package/dist/index.d.ts +9 -0
- package/dist/index.js +1 -1
- package/dist/parallel-worker.cjs +1 -1
- package/dist/parallel-worker.js +2 -2
- package/dist/parallel.cjs +1 -1
- package/dist/parallel.js +2 -2
- package/dist/run-cli.cjs +17 -16
- package/dist/run-cli.js +6 -5
- package/dist/transfer.cjs +27 -15
- package/dist/transfer.js +27 -15
- package/package.json +1 -1
- package/src/ast.ts +90 -0
- package/src/check.ts +188 -53
- package/src/cli-options.ts +11 -5
- package/src/codegen.ts +9 -19
- package/src/dependencies.ts +2 -2
- package/src/environment.ts +47 -12
- package/src/errors.ts +9 -2
- package/src/evaluate.ts +75 -135
- package/src/exit-codes.ts +21 -43
- package/src/instances.ts +15 -14
- package/src/levels.ts +8 -8
- package/src/lexer.ts +5 -1
- package/src/live-check.ts +710 -0
- package/src/liveness.ts +5 -523
- package/src/parallel-worker.ts +5 -1
- package/src/parallel.ts +18 -2
- package/src/parser.ts +12 -1
- package/src/resolve.ts +16 -15
- package/src/run-cli.ts +58 -13
- package/src/runtime.ts +1 -1
- package/src/spec-description.ts +18 -6
- package/src/state-graph.ts +157 -0
- package/src/subexpressions.ts +10 -10
- package/src/successors.ts +17 -9
- package/src/symmetry.ts +9 -1
- package/src/tlc-ext.ts +29 -12
- package/src/tlc-module.ts +3 -28
- package/src/tlc-order.ts +17 -3
- package/src/values.ts +11 -0
package/package.json
CHANGED
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
|
|
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 {
|
|
6
|
-
|
|
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
|
-
|
|
28
|
-
|
|
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(
|
|
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
|
-
|
|
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
|
|
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
|
|
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 = (
|
|
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
|
|
1318
|
-
|
|
1319
|
-
|
|
1320
|
-
|
|
1321
|
-
(
|
|
1322
|
-
|
|
1323
|
-
|
|
1324
|
-
|
|
1325
|
-
|
|
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
|
-
|
|
1339
|
-
|
|
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:
|
|
1342
|
-
|
|
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
|
-
|
|
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
|
|
1351
|
-
const
|
|
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,
|
|
1494
|
+
back === last ? undefined : withoutOutput(() => getLabel(last, lastState, states[back]));
|
|
1355
1495
|
return reportViolation(
|
|
1356
1496
|
"liveness-violation",
|
|
1357
|
-
{ name:
|
|
1497
|
+
{ name: properties[0], properties, trace, loopStart, loopLabel },
|
|
1358
1498
|
() =>
|
|
1359
1499
|
back === last
|
|
1360
1500
|
? trace[trace.length - 1].action
|
|
1361
|
-
:
|
|
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
|
-
|
|
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) {
|
package/src/cli-options.ts
CHANGED
|
@@ -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
|
|
41
|
-
if (
|
|
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
|
-
|
|
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:
|
|
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
|
|
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
|
|
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
|
|
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 =
|
|
266
|
-
|
|
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),
|
package/src/dependencies.ts
CHANGED
|
@@ -1,5 +1,5 @@
|
|
|
1
|
-
import type
|
|
2
|
-
import {
|
|
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",
|