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.
- package/README.md +78 -12
- package/dist/index.cjs +1 -1
- package/dist/index.d.cts +60 -1
- package/dist/index.d.ts +60 -1
- package/dist/index.js +1 -1
- package/dist/parallel-worker.cjs +2 -2
- package/dist/parallel-worker.js +2 -2
- package/dist/parallel.cjs +1 -1
- package/dist/parallel.js +2 -2
- package/dist/run-cli.cjs +21 -2
- package/dist/run-cli.js +21 -2
- package/dist/transfer.cjs +27 -15
- package/dist/transfer.js +27 -15
- package/package.json +3 -1
- package/src/ast.ts +134 -4
- package/src/check.ts +230 -62
- package/src/cli-options.ts +64 -0
- package/src/codegen.ts +9 -19
- package/src/dependencies.ts +2 -2
- package/src/environment.ts +75 -16
- package/src/errors.ts +46 -3
- package/src/evaluate.ts +78 -136
- package/src/exit-codes.ts +21 -43
- package/src/fingerprints.ts +46 -11
- package/src/instances.ts +15 -14
- package/src/levels.ts +8 -8
- package/src/lexer.ts +11 -2
- package/src/live-check.ts +710 -0
- package/src/liveness.ts +5 -523
- package/src/obligation-action.ts +384 -0
- package/src/obligation-anon.ts +575 -0
- package/src/obligation-deref.ts +637 -0
- package/src/obligation-expression.ts +1060 -0
- package/src/obligation-format.ts +406 -0
- package/src/obligation-generate.ts +1074 -0
- package/src/obligation-levels.ts +329 -0
- package/src/obligation-module.ts +1042 -0
- package/src/obligation-printer.ts +889 -0
- package/src/obligation-proof.ts +76 -0
- package/src/obligation-source.ts +1084 -0
- package/src/obligation-tuples.ts +184 -0
- package/src/obligations.ts +316 -0
- package/src/parallel-worker.ts +166 -210
- package/src/parallel.ts +76 -35
- package/src/parser.ts +297 -53
- package/src/resolve.ts +16 -15
- package/src/run-cli.ts +353 -40
- package/src/runtime.ts +3 -1
- package/src/spec-description.ts +18 -6
- package/src/standard-levels.ts +3 -3
- package/src/state-graph.ts +157 -0
- package/src/subexpressions.ts +10 -10
- package/src/successors.ts +17 -9
- package/src/symmetry.ts +14 -2
- package/src/tlc-ext.ts +29 -12
- package/src/tlc-module.ts +9 -28
- package/src/tlc-order.ts +17 -3
- package/src/transfer.ts +22 -1
- package/src/values.ts +70 -23
package/src/check.ts
CHANGED
|
@@ -1,15 +1,27 @@
|
|
|
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,
|
|
@@ -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
|
-
|
|
27
|
-
|
|
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
|
-
|
|
488
|
-
|
|
489
|
-
|
|
490
|
-
|
|
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
|
-
|
|
747
|
-
|
|
748
|
-
|
|
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(
|
|
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
|
-
|
|
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
|
|
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
|
|
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 = (
|
|
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
|
|
1285
|
-
|
|
1286
|
-
|
|
1287
|
-
|
|
1288
|
-
(
|
|
1289
|
-
|
|
1290
|
-
|
|
1291
|
-
|
|
1292
|
-
|
|
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
|
-
|
|
1306
|
-
|
|
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:
|
|
1309
|
-
|
|
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
|
-
|
|
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
|
|
1318
|
-
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];
|
|
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,
|
|
1494
|
+
back === last ? undefined : withoutOutput(() => getLabel(last, lastState, states[back]));
|
|
1322
1495
|
return reportViolation(
|
|
1323
1496
|
"liveness-violation",
|
|
1324
|
-
{ name:
|
|
1497
|
+
{ name: properties[0], properties, trace, loopStart, loopLabel },
|
|
1325
1498
|
() =>
|
|
1326
1499
|
back === last
|
|
1327
1500
|
? trace[trace.length - 1].action
|
|
1328
|
-
:
|
|
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
|
-
|
|
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
|
|
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",
|