tla-ts 0.0.1 → 0.0.3-dev.037ac3b
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 +98 -39
- package/dist/index.cjs +1 -1
- package/dist/index.d.cts +225 -30
- package/dist/index.d.ts +225 -30
- 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 -1
- package/dist/run-cli.js +21 -1
- package/dist/transfer.cjs +400 -39
- package/dist/transfer.js +400 -39
- package/package.json +6 -2
- package/src/ast.ts +213 -6
- package/src/bags.ts +161 -71
- package/src/builtins.ts +203 -23
- package/src/bundled-modules.ts +63 -32
- package/src/check.ts +1132 -258
- package/src/cli-options.ts +64 -0
- package/src/codegen.ts +58 -34
- package/src/config.ts +39 -11
- package/src/dependencies.ts +2 -2
- package/src/environment.ts +557 -153
- package/src/errors.ts +66 -1
- package/src/evaluate.ts +553 -258
- package/src/exit-codes.ts +53 -0
- package/src/fingerprints.ts +48 -13
- package/src/index.ts +9 -4
- package/src/instances.ts +235 -79
- package/src/java-overrides.ts +241 -0
- package/src/json.ts +153 -72
- package/src/levels.ts +850 -0
- package/src/lexer.ts +108 -29
- package/src/live-check.ts +692 -0
- package/src/liveness.ts +71 -596
- 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 +186 -201
- package/src/parallel.ts +179 -84
- package/src/parser.ts +970 -206
- package/src/pretty-print.ts +259 -0
- package/src/randomization.ts +24 -113
- package/src/resolve.ts +483 -51
- package/src/run-cli.ts +473 -62
- package/src/runtime.ts +65 -28
- package/src/spec-description.ts +521 -0
- package/src/standard-levels.ts +105 -0
- package/src/standard-modules.ts +218 -92
- package/src/state-graph.ts +157 -0
- package/src/subexpressions.ts +31 -45
- package/src/substitution-levels.ts +184 -0
- package/src/successors.ts +336 -57
- package/src/symmetry.ts +79 -23
- package/src/tableau.ts +93 -60
- package/src/tlc-ext.ts +148 -44
- package/src/tlc-module.ts +71 -66
- package/src/tlc-modules.ts +1022 -0
- package/src/tlc-order.ts +511 -0
- package/src/tlc-random.ts +414 -0
- package/src/tlc-summary.ts +124 -0
- package/src/transfer.ts +26 -5
- package/src/values.ts +1285 -179
package/src/tlc-ext.ts
CHANGED
|
@@ -1,5 +1,5 @@
|
|
|
1
1
|
import {
|
|
2
|
-
|
|
2
|
+
createJavaOverrideError,
|
|
3
3
|
defineHigherOrderOperator,
|
|
4
4
|
defineLazyOperator,
|
|
5
5
|
defineOperator,
|
|
@@ -8,16 +8,11 @@ import {
|
|
|
8
8
|
getThunk,
|
|
9
9
|
getValue,
|
|
10
10
|
} from "./builtins";
|
|
11
|
-
import { TlaEvaluationError } from "./errors";
|
|
12
|
-
import {
|
|
13
|
-
|
|
14
|
-
|
|
15
|
-
|
|
16
|
-
isLocallyResolved,
|
|
17
|
-
type Builtin,
|
|
18
|
-
type Environment,
|
|
19
|
-
} from "./evaluate";
|
|
20
|
-
import type { Definition, Expression } from "./ast";
|
|
11
|
+
import { TlaEvaluationError, TlaModuleError, TlaUnsupportedError } from "./errors";
|
|
12
|
+
import { getTlcFingerprint } from "./tlc-random";
|
|
13
|
+
import { evaluate, expectBoolean, getDefinition, type Builtin, type Environment } from "./evaluate";
|
|
14
|
+
import { getChildren, isLocallyResolved, type Definition, type Expression } from "./ast";
|
|
15
|
+
import type { TraceStep } from "./check";
|
|
21
16
|
import {
|
|
22
17
|
getNamedRegisters,
|
|
23
18
|
getPossibleCounts,
|
|
@@ -31,18 +26,74 @@ import {
|
|
|
31
26
|
createSet,
|
|
32
27
|
createTuple,
|
|
33
28
|
formatValue,
|
|
29
|
+
getDomain,
|
|
34
30
|
getSequenceElements,
|
|
35
|
-
getValueHash,
|
|
36
31
|
getValueKey,
|
|
32
|
+
isFunctionValue,
|
|
37
33
|
toFiniteSet,
|
|
38
34
|
valuesEqual,
|
|
39
35
|
type Value,
|
|
40
36
|
} from "./values";
|
|
41
37
|
|
|
42
|
-
const
|
|
43
|
-
|
|
44
|
-
|
|
45
|
-
|
|
38
|
+
const OVERRIDE_PARAMETERS =
|
|
39
|
+
"tlc2.tool.impl.Tool,tla2sany.semantic.ExprOrOpArgNode[],tlc2.util.Context,tlc2.tool.TLCState,tlc2.tool.TLCState,int,tlc2.tool.coverage.CostModel";
|
|
40
|
+
|
|
41
|
+
const ASSERT_ERROR_METHOD = `public static synchronized tlc2.value.impl.Value tlc2.module.TLCExt.assertError(${OVERRIDE_PARAMETERS})`;
|
|
42
|
+
|
|
43
|
+
const TRACE_METHOD = `public static tlc2.value.impl.TupleValue tlc2.module.TLCExt.getTrace(${OVERRIDE_PARAMETERS}) throws java.io.IOException`;
|
|
44
|
+
|
|
45
|
+
const PICK_SUCCESSOR_METHOD = `public static synchronized tlc2.value.impl.Value tlc2.module.TLCExt.pickSuccessor(${OVERRIDE_PARAMETERS})`;
|
|
46
|
+
|
|
47
|
+
const createEmptyCounterExample = () =>
|
|
48
|
+
createRecord([
|
|
49
|
+
["action", createSet([])],
|
|
50
|
+
["state", createSet([])],
|
|
51
|
+
]);
|
|
52
|
+
|
|
53
|
+
const createBuiltinLocation = () =>
|
|
54
|
+
createRecord([
|
|
55
|
+
["beginLine", 0],
|
|
56
|
+
["beginColumn", 0],
|
|
57
|
+
["endLine", 0],
|
|
58
|
+
["endColumn", 0],
|
|
59
|
+
["module", "--TLA+ BUILTINS--"],
|
|
60
|
+
]);
|
|
61
|
+
|
|
62
|
+
// TLC's record for an action it doesn't store, such as every action in breadth-first search.
|
|
63
|
+
export const createActionRecord = (action: string | undefined) =>
|
|
64
|
+
createRecord([
|
|
65
|
+
["name", action ?? "UnnamedAction"],
|
|
66
|
+
["location", createBuiltinLocation()],
|
|
67
|
+
]);
|
|
68
|
+
|
|
69
|
+
// TLC's CounterExample is a graph of the violating behavior: the states numbered from 1, an edge
|
|
70
|
+
// for each step, and for a lasso an edge from the last state back to where the loop starts.
|
|
71
|
+
export const createCounterExample = (
|
|
72
|
+
trace: TraceStep[],
|
|
73
|
+
loop: { start: number; action: string | undefined } | undefined,
|
|
74
|
+
) => {
|
|
75
|
+
const states = trace.map((step, index) =>
|
|
76
|
+
createTuple([index + 1, createRecord(Object.entries(step.state))]),
|
|
77
|
+
);
|
|
78
|
+
const steps = states
|
|
79
|
+
.slice(1)
|
|
80
|
+
.map((state, index) =>
|
|
81
|
+
createTuple([states[index], createActionRecord(trace[index + 1].action), state]),
|
|
82
|
+
);
|
|
83
|
+
const closing = loop
|
|
84
|
+
? [
|
|
85
|
+
createTuple([
|
|
86
|
+
states[states.length - 1],
|
|
87
|
+
createActionRecord(loop.action),
|
|
88
|
+
states[loop.start],
|
|
89
|
+
]),
|
|
90
|
+
]
|
|
91
|
+
: [];
|
|
92
|
+
return createRecord([
|
|
93
|
+
["action", createSet([...steps, ...closing])],
|
|
94
|
+
["state", createSet(states)],
|
|
95
|
+
]);
|
|
96
|
+
};
|
|
46
97
|
|
|
47
98
|
const getRegister = (runtime: CheckerRuntime, key: Value) => {
|
|
48
99
|
if (typeof key === "number") return runtime.registers.get(key);
|
|
@@ -52,16 +103,36 @@ const getRegister = (runtime: CheckerRuntime, key: Value) => {
|
|
|
52
103
|
return undefined;
|
|
53
104
|
};
|
|
54
105
|
|
|
55
|
-
|
|
106
|
+
// TLC's TLCSet. TLCExt's TLCGetAndSet is a TLA+ definition that calls it.
|
|
107
|
+
export const setTlcValue = (
|
|
108
|
+
runtime: CheckerRuntime,
|
|
109
|
+
print: (text: string) => void,
|
|
110
|
+
key: Value,
|
|
111
|
+
value: Value,
|
|
112
|
+
) => {
|
|
56
113
|
if (typeof key === "number" && key >= 0) {
|
|
57
114
|
runtime.registers.set(key, value);
|
|
58
115
|
return;
|
|
59
116
|
}
|
|
117
|
+
if (key === "exit") {
|
|
118
|
+
if (value === true) runtime.isStopped = true;
|
|
119
|
+
return;
|
|
120
|
+
}
|
|
121
|
+
if (key === "pause") {
|
|
122
|
+
if (value !== true) return;
|
|
123
|
+
print("Press enter to resume model checking.");
|
|
124
|
+
runtime.pause();
|
|
125
|
+
return;
|
|
126
|
+
}
|
|
60
127
|
if (typeof key === "string" && key.startsWith(NAMED_REGISTER_PREFIX)) {
|
|
61
128
|
runtime.namedRegisters.set(key, value);
|
|
62
129
|
return;
|
|
63
130
|
}
|
|
64
|
-
|
|
131
|
+
if (typeof key === "string" && key.startsWith("-D")) {
|
|
132
|
+
runtime.properties.set(key.slice(2), formatValue(value));
|
|
133
|
+
return;
|
|
134
|
+
}
|
|
135
|
+
throw new TlaModuleError(
|
|
65
136
|
`The first argument of TLCSet should be a nonnegative integer, but instead it is:\n${formatValue(key)}`,
|
|
66
137
|
);
|
|
67
138
|
};
|
|
@@ -112,13 +183,20 @@ export const createTlcExtOperators = (
|
|
|
112
183
|
const right = getValue(args, 1, "AssertEq");
|
|
113
184
|
const isEqual = valuesEqual(left, right);
|
|
114
185
|
if (!isEqual) {
|
|
115
|
-
print("Assertion failed");
|
|
186
|
+
print(formatValue("Assertion failed", true));
|
|
116
187
|
print(formatValue(left, true));
|
|
117
188
|
print(formatValue(right, true));
|
|
118
189
|
}
|
|
119
190
|
return isEqual;
|
|
120
191
|
}),
|
|
121
192
|
defineLazyOperator("AssertError", 2, (args) => {
|
|
193
|
+
const message = getOperator(args, 0, "AssertError").expression;
|
|
194
|
+
if (message && message.kind !== "String") {
|
|
195
|
+
throw createJavaOverrideError(
|
|
196
|
+
ASSERT_ERROR_METHOD,
|
|
197
|
+
`In computing AssertError, a non-string expression (line ${message.location.line}, col ${message.location.column}) was used as the err of an AssertError(err, exp).`,
|
|
198
|
+
);
|
|
199
|
+
}
|
|
122
200
|
const expected = getThunk(args, 0, "AssertError")();
|
|
123
201
|
try {
|
|
124
202
|
getThunk(args, 1, "AssertError")();
|
|
@@ -137,53 +215,80 @@ export const createTlcExtOperators = (
|
|
|
137
215
|
const key = getValue(args, 0, "TLCGetAndSet");
|
|
138
216
|
const previous = getRegister(runtime, key) ?? getValue(args, 3, "TLCGetAndSet");
|
|
139
217
|
const update = getOperator(args, 1, "TLCGetAndSet");
|
|
140
|
-
|
|
218
|
+
setTlcValue(
|
|
219
|
+
runtime,
|
|
220
|
+
print,
|
|
221
|
+
key,
|
|
222
|
+
update.call([previous, getValue(args, 2, "TLCGetAndSet")]),
|
|
223
|
+
);
|
|
141
224
|
return previous;
|
|
142
225
|
}),
|
|
143
226
|
isStateLevel: true,
|
|
144
227
|
},
|
|
145
228
|
defineStateOperator("Trace", 0, (_, context) => {
|
|
146
229
|
const state = context?.state;
|
|
147
|
-
if (!state || !isCompleteState(state)) {
|
|
148
|
-
|
|
149
|
-
|
|
230
|
+
if (!context || !state || !isCompleteState(state)) {
|
|
231
|
+
const unassigned = (context?.environment.variables ?? []).filter(
|
|
232
|
+
(_, index) => state?.[index] === undefined,
|
|
233
|
+
);
|
|
234
|
+
throw createJavaOverrideError(
|
|
235
|
+
TRACE_METHOD,
|
|
236
|
+
`In evaluating TLCExt!Trace, the state is not completely specified yet (variable${unassigned.length > 1 ? "s" : ""} ${unassigned.join(", ")} undefined).`,
|
|
150
237
|
);
|
|
151
238
|
}
|
|
152
239
|
return createTuple(
|
|
153
240
|
runtime.getBehavior(state).map((step) => toStateRecord(step, context.environment)),
|
|
154
241
|
);
|
|
155
242
|
}),
|
|
156
|
-
|
|
243
|
+
defineStateOperator(
|
|
244
|
+
"CounterExample",
|
|
245
|
+
0,
|
|
246
|
+
() => runtime.counterExample ?? createEmptyCounterExample(),
|
|
247
|
+
),
|
|
157
248
|
defineOperator("ToTrace", 1, (args) => {
|
|
158
249
|
const counterExample = getValue(args, 0, "ToTrace");
|
|
250
|
+
if (
|
|
251
|
+
!isFunctionValue(counterExample) ||
|
|
252
|
+
!valuesEqual(getDomain(counterExample), createSet(["action", "state"]))
|
|
253
|
+
) {
|
|
254
|
+
throw new TlaEvaluationError(
|
|
255
|
+
`The argument of ToTrace should be a CounterExample, but instead it is:\n${formatValue(counterExample)}`,
|
|
256
|
+
);
|
|
257
|
+
}
|
|
159
258
|
const states = toFiniteSet(applyFunction(counterExample, "state")).elements.map(
|
|
160
259
|
(pair) => getSequenceElements(pair) ?? [],
|
|
161
260
|
);
|
|
162
261
|
return createTuple(
|
|
163
|
-
[
|
|
164
|
-
.sort((left, right) => Number(left[0]) - Number(right[0]))
|
|
165
|
-
.map((pair) => pair[1]),
|
|
262
|
+
states.sort((left, right) => Number(left[0]) - Number(right[0])).map((pair) => pair[1]),
|
|
166
263
|
);
|
|
167
264
|
}),
|
|
168
265
|
defineOperator("TLCModelValue", 1, (args) => {
|
|
169
266
|
const name = getValue(args, 0, "TLCModelValue");
|
|
170
267
|
if (typeof name !== "string") {
|
|
171
|
-
throw new
|
|
268
|
+
throw new TlaModuleError(
|
|
172
269
|
`The argument of ModelValue should be a string, but instead it is:\n${formatValue(name)}`,
|
|
173
270
|
);
|
|
174
271
|
}
|
|
175
272
|
return createModelValue(name);
|
|
176
273
|
}),
|
|
177
|
-
|
|
178
|
-
|
|
179
|
-
return true;
|
|
180
|
-
}),
|
|
274
|
+
// TLC runs the deferred expression only in simulation, when it extends a behavior.
|
|
275
|
+
defineLazyOperator("TLCDefer", 1, () => true),
|
|
181
276
|
defineOperator("TLCNoOp", 1, (args) => getValue(args, 0, "TLCNoOp")),
|
|
182
277
|
defineLazyOperator("PickSuccessor", 1, (args, context) => {
|
|
183
|
-
if (getThunk(args, 0, "PickSuccessor")() === true) return true;
|
|
184
278
|
const next = context?.next;
|
|
185
|
-
if (!next || !isCompleteState(next))
|
|
186
|
-
|
|
279
|
+
if (!next || !isCompleteState(next)) {
|
|
280
|
+
throw createJavaOverrideError(
|
|
281
|
+
PICK_SUCCESSOR_METHOD,
|
|
282
|
+
'Cannot invoke "tlc2.value.IValue.fingerPrint(long)" because "minVals[i]" is null',
|
|
283
|
+
);
|
|
284
|
+
}
|
|
285
|
+
if (runtime.isSeen(next)) return true;
|
|
286
|
+
if (expectBoolean(getThunk(args, 0, "PickSuccessor")(), "the condition of PickSuccessor")) {
|
|
287
|
+
return true;
|
|
288
|
+
}
|
|
289
|
+
throw new TlaUnsupportedError(
|
|
290
|
+
"PickSuccessor needs interactive input to extend the behavior with a new state",
|
|
291
|
+
);
|
|
187
292
|
}),
|
|
188
293
|
defineLazyOperator("TLCCache", 2, (args, context) => {
|
|
189
294
|
const expression = getOperator(args, 0, "TLCCache");
|
|
@@ -200,18 +305,20 @@ export const createTlcExtOperators = (
|
|
|
200
305
|
cache.set(closure, value);
|
|
201
306
|
return value;
|
|
202
307
|
}),
|
|
203
|
-
defineOperator("TLCFP", 1, (args) =>
|
|
308
|
+
defineOperator("TLCFP", 1, (args) =>
|
|
309
|
+
Number(BigInt.asIntN(32, getTlcFingerprint([getValue(args, 0, "TLCFP")]))),
|
|
310
|
+
),
|
|
204
311
|
defineStateOperator("TLCEvalDefinition", 1, (args, context) => {
|
|
205
312
|
const name = getValue(args, 0, "TLCEvalDefinition");
|
|
206
313
|
const definition =
|
|
207
314
|
typeof name === "string" && context ? getDefinition(name, context.environment) : undefined;
|
|
208
315
|
if (!definition || typeof name !== "string" || !context) {
|
|
209
|
-
throw new
|
|
316
|
+
throw new TlaModuleError(
|
|
210
317
|
`The argument of TLCEvalDefinition should be a name of a definition reachable from the root module, but instead it is:\n${formatValue(name)}`,
|
|
211
318
|
);
|
|
212
319
|
}
|
|
213
320
|
if (definition.kind === "Operator" && definition.params.length > 0) {
|
|
214
|
-
throw new
|
|
321
|
+
throw new TlaModuleError(
|
|
215
322
|
`The argument of TLCEvalDefinition should be a zero-arity definition, but instead it is:\n${name}`,
|
|
216
323
|
);
|
|
217
324
|
}
|
|
@@ -225,12 +332,9 @@ export const createPossibleOperators = (
|
|
|
225
332
|
runtime: CheckerRuntime,
|
|
226
333
|
): Builtin[] => [
|
|
227
334
|
defineStateOperator("_Track", 2, (args) => {
|
|
228
|
-
const name = getValue(args, 1, "_Track");
|
|
229
|
-
const count = runtime.possibleCounts.get(
|
|
230
|
-
runtime.possibleCounts.set(
|
|
231
|
-
String(name),
|
|
232
|
-
getValue(args, 0, "_Track") === true ? count + 1 : count,
|
|
233
|
-
);
|
|
335
|
+
const name = String(getValue(args, 1, "_Track"));
|
|
336
|
+
const count = runtime.possibleCounts.get(name) ?? 0;
|
|
337
|
+
runtime.possibleCounts.set(name, getValue(args, 0, "_Track") === true ? count + 1 : count);
|
|
234
338
|
return true;
|
|
235
339
|
}),
|
|
236
340
|
defineStateOperator("_Counts", 0, () => getPossibleCounts(runtime)),
|
package/src/tlc-module.ts
CHANGED
|
@@ -1,43 +1,55 @@
|
|
|
1
|
-
import {
|
|
1
|
+
import { TlaModuleError } from "./errors";
|
|
2
|
+
import { EXIT_STATUS } from "./exit-codes";
|
|
2
3
|
import type { Builtin } from "./evaluate";
|
|
4
|
+
import { prettyPrint } from "./pretty-print";
|
|
3
5
|
import {
|
|
4
6
|
defineConstant,
|
|
5
7
|
defineHigherOrderOperator,
|
|
6
8
|
defineOperator,
|
|
7
9
|
defineStateOperator,
|
|
8
10
|
getElements,
|
|
11
|
+
getEnumerableSet,
|
|
12
|
+
getFunction,
|
|
9
13
|
getOperator,
|
|
10
14
|
getSequence,
|
|
11
15
|
getValue,
|
|
12
16
|
} from "./builtins";
|
|
13
17
|
import { getNamedRegisters, NAMED_REGISTER_PREFIX, type CheckerRuntime } from "./runtime";
|
|
18
|
+
import { createActionRecord, setTlcValue } from "./tlc-ext";
|
|
19
|
+
import { getRandomElement } from "./tlc-random";
|
|
14
20
|
import {
|
|
21
|
+
ANY_SET,
|
|
15
22
|
createFunction,
|
|
16
23
|
createRecord,
|
|
17
24
|
createSet,
|
|
18
25
|
createTuple,
|
|
26
|
+
createWrittenFunction,
|
|
19
27
|
formatValue,
|
|
20
|
-
|
|
28
|
+
getWrittenPairs,
|
|
29
|
+
toFiniteSet,
|
|
21
30
|
type Value,
|
|
31
|
+
rankString,
|
|
22
32
|
} from "./values";
|
|
23
33
|
|
|
24
|
-
const
|
|
25
|
-
|
|
26
|
-
|
|
27
|
-
|
|
28
|
-
["endLine", 0],
|
|
29
|
-
["endColumn", 0],
|
|
30
|
-
["module", "--unknown--"],
|
|
31
|
-
]);
|
|
34
|
+
const padTime = (value: number) => String(value).padStart(2, "0");
|
|
35
|
+
|
|
36
|
+
const formatCalendarVersion = (date: Date) =>
|
|
37
|
+
`${date.getUTCFullYear()}.${padTime(date.getUTCMonth() + 1)}.${padTime(date.getUTCDate())}.${padTime(date.getUTCHours())}${padTime(date.getUTCMinutes())}${padTime(date.getUTCSeconds())}`;
|
|
32
38
|
|
|
33
39
|
const getRegisterFunction = <Key extends Value>(registers: Map<Key, Value>) =>
|
|
34
40
|
createFunction([...registers].map(([key, value]): [Value, Value] => [key, createTuple([value])]));
|
|
35
41
|
|
|
42
|
+
// TLC creates its model checker after it processes the spec, so these are undefined before then.
|
|
43
|
+
const CHECKER_KEYS = new Set(["diameter", "generated", "distinct", "queue", "stats", "config"]);
|
|
44
|
+
|
|
36
45
|
const getRuntimeValue = (
|
|
37
46
|
runtime: CheckerRuntime,
|
|
38
47
|
key: string,
|
|
39
48
|
state: (Value | undefined)[] | undefined,
|
|
40
|
-
)
|
|
49
|
+
) => {
|
|
50
|
+
if (!runtime.isStarted && CHECKER_KEYS.has(key)) {
|
|
51
|
+
throw new TlaModuleError(`TLCGet(${key}) was undefined.`);
|
|
52
|
+
}
|
|
41
53
|
const duration = Math.floor((Date.now() - runtime.startedAt) / 1000);
|
|
42
54
|
switch (key) {
|
|
43
55
|
case "level":
|
|
@@ -67,23 +79,24 @@ const getRuntimeValue = (
|
|
|
67
79
|
["mode", "bfs"],
|
|
68
80
|
["deadlock", runtime.checkDeadlock],
|
|
69
81
|
["worker", 1],
|
|
70
|
-
["seed",
|
|
82
|
+
["seed", String(runtime.seed)],
|
|
71
83
|
["fingerprint", "0"],
|
|
72
|
-
["install", ""],
|
|
84
|
+
["install", "unknown"],
|
|
73
85
|
]);
|
|
74
|
-
case "revision":
|
|
86
|
+
case "revision": {
|
|
87
|
+
const now = new Date();
|
|
75
88
|
return createRecord([
|
|
76
89
|
["count", 0],
|
|
77
|
-
["timestamp",
|
|
78
|
-
["date",
|
|
79
|
-
["tag", "
|
|
80
|
-
["calver",
|
|
90
|
+
["timestamp", Math.floor(now.getTime() / 1000)],
|
|
91
|
+
["date", rankString(`${now.toISOString().slice(0, 19)}.${now.getUTCMilliseconds()}Z`)],
|
|
92
|
+
["tag", "development"],
|
|
93
|
+
["calver", rankString(formatCalendarVersion(new Date(runtime.startedAt)))],
|
|
81
94
|
]);
|
|
95
|
+
}
|
|
96
|
+
case "spec":
|
|
97
|
+
return runtime.getSpecification();
|
|
82
98
|
case "action":
|
|
83
|
-
return
|
|
84
|
-
["name", "UnnamedAction"],
|
|
85
|
-
["location", createLocationRecord()],
|
|
86
|
-
]);
|
|
99
|
+
return createActionRecord(undefined);
|
|
87
100
|
case "all":
|
|
88
101
|
return getRegisterFunction(runtime.registers);
|
|
89
102
|
case "all:named":
|
|
@@ -91,11 +104,11 @@ const getRuntimeValue = (
|
|
|
91
104
|
}
|
|
92
105
|
if (key.startsWith(NAMED_REGISTER_PREFIX)) {
|
|
93
106
|
const value = getNamedRegisters(runtime).get(key);
|
|
94
|
-
if (value === undefined) throw new
|
|
107
|
+
if (value === undefined) throw new TlaModuleError(`TLCGet(${key}) was undefined.`);
|
|
95
108
|
return value;
|
|
96
109
|
}
|
|
97
|
-
if (key.startsWith("-D")) return runtime.properties.get(key.slice(2)) ?? key;
|
|
98
|
-
throw new
|
|
110
|
+
if (key.startsWith("-D")) return rankString(runtime.properties.get(key.slice(2)) ?? key);
|
|
111
|
+
throw new TlaModuleError(`TLCGet(${key}) was undefined.`);
|
|
99
112
|
};
|
|
100
113
|
|
|
101
114
|
const getPermutations = (elements: Value[]): Value[][] =>
|
|
@@ -108,24 +121,34 @@ const getPermutations = (elements: Value[]): Value[][] =>
|
|
|
108
121
|
]),
|
|
109
122
|
);
|
|
110
123
|
|
|
124
|
+
// TLC sorts the value of a TLCEval argument that it caches, with every value inside it.
|
|
125
|
+
const normalizeDeeply = (value: Value): void => {
|
|
126
|
+
if (typeof value !== "object") return;
|
|
127
|
+
if (value.kind === "Set" || value.kind === "MixedSet") {
|
|
128
|
+
toFiniteSet(value).elements.forEach(normalizeDeeply);
|
|
129
|
+
}
|
|
130
|
+
if (value.kind === "Function") value.range.forEach(normalizeDeeply);
|
|
131
|
+
};
|
|
132
|
+
|
|
111
133
|
export const createTlcOperators = (
|
|
112
134
|
print: (text: string) => void,
|
|
113
135
|
runtime: CheckerRuntime,
|
|
114
136
|
): Builtin[] => [
|
|
115
137
|
defineOperator("Print", 2, (args) => {
|
|
116
138
|
print(
|
|
117
|
-
`${formatValue(getValue(args, 0, "Print"), true)} ${formatValue(getValue(args, 1, "Print"), true)}`,
|
|
139
|
+
`${prettyPrint(formatValue(getValue(args, 0, "Print"), true, true))} ${prettyPrint(formatValue(getValue(args, 1, "Print"), true, true))}`,
|
|
118
140
|
);
|
|
119
141
|
return getValue(args, 1, "Print");
|
|
120
142
|
}),
|
|
121
143
|
defineOperator("PrintT", 1, (args) => {
|
|
122
|
-
print(formatValue(getValue(args, 0, "PrintT"), true));
|
|
144
|
+
print(prettyPrint(formatValue(getValue(args, 0, "PrintT"), true, true)));
|
|
123
145
|
return true;
|
|
124
146
|
}),
|
|
125
147
|
defineOperator("Assert", 2, (args) => {
|
|
126
148
|
if (getValue(args, 0, "Assert") !== true) {
|
|
127
|
-
throw new
|
|
128
|
-
`The first argument of Assert evaluated to FALSE; the second argument was:\n${formatValue(getValue(args, 1, "Assert"))}`,
|
|
149
|
+
throw new TlaModuleError(
|
|
150
|
+
`The first argument of Assert evaluated to FALSE; the second argument was:\n${prettyPrint(formatValue(getValue(args, 1, "Assert")))}`,
|
|
151
|
+
EXIT_STATUS.assertViolation,
|
|
129
152
|
);
|
|
130
153
|
}
|
|
131
154
|
return true;
|
|
@@ -135,15 +158,18 @@ export const createTlcOperators = (
|
|
|
135
158
|
createFunction([[getValue(args, 0, ":>"), getValue(args, 1, ":>")]]),
|
|
136
159
|
),
|
|
137
160
|
defineOperator("@@", 2, (args) => {
|
|
138
|
-
const left =
|
|
139
|
-
const right =
|
|
140
|
-
return
|
|
141
|
-
|
|
142
|
-
|
|
143
|
-
|
|
161
|
+
const left = getFunction(args, 0, "@@");
|
|
162
|
+
const right = getFunction(args, 1, "@@");
|
|
163
|
+
return createWrittenFunction([...getWrittenPairs(left), ...getWrittenPairs(right)]);
|
|
164
|
+
}),
|
|
165
|
+
defineOperator("ToString", 1, (args) =>
|
|
166
|
+
rankString(formatValue(getValue(args, 0, "ToString"), true)),
|
|
167
|
+
),
|
|
168
|
+
defineOperator("TLCEval", 1, (args) => {
|
|
169
|
+
const value = getValue(args, 0, "TLCEval");
|
|
170
|
+
normalizeDeeply(value);
|
|
171
|
+
return value;
|
|
144
172
|
}),
|
|
145
|
-
defineOperator("ToString", 1, (args) => formatValue(getValue(args, 0, "ToString"))),
|
|
146
|
-
defineOperator("TLCEval", 1, (args) => getValue(args, 0, "TLCEval")),
|
|
147
173
|
defineOperator("Permutations", 1, (args) => {
|
|
148
174
|
const elements = getElements(args, 0, "Permutations");
|
|
149
175
|
return createSet(
|
|
@@ -171,11 +197,11 @@ export const createTlcOperators = (
|
|
|
171
197
|
const key = getValue(args, 0, "TLCGet");
|
|
172
198
|
if (typeof key === "number" && key >= 0) {
|
|
173
199
|
const value = runtime.registers.get(key);
|
|
174
|
-
if (value === undefined) throw new
|
|
200
|
+
if (value === undefined) throw new TlaModuleError(`TLCGet(${key}) was undefined.`);
|
|
175
201
|
return value;
|
|
176
202
|
}
|
|
177
203
|
if (typeof key !== "string") {
|
|
178
|
-
throw new
|
|
204
|
+
throw new TlaModuleError(
|
|
179
205
|
`The argument of TLCGet should be a nonnegative integer, but instead it is:\n${formatValue(key)}`,
|
|
180
206
|
);
|
|
181
207
|
}
|
|
@@ -183,32 +209,11 @@ export const createTlcOperators = (
|
|
|
183
209
|
}),
|
|
184
210
|
defineStateOperator("TLCSet", 2, (args) => {
|
|
185
211
|
const key = getValue(args, 0, "TLCSet");
|
|
186
|
-
|
|
187
|
-
|
|
188
|
-
runtime.registers.set(key, value);
|
|
189
|
-
return true;
|
|
190
|
-
}
|
|
191
|
-
if (key === "exit") {
|
|
192
|
-
if (value === true) runtime.isStopped = true;
|
|
193
|
-
return true;
|
|
194
|
-
}
|
|
195
|
-
if (key === "pause") return true;
|
|
196
|
-
if (typeof key === "string" && key.startsWith(NAMED_REGISTER_PREFIX)) {
|
|
197
|
-
runtime.namedRegisters.set(key, value);
|
|
198
|
-
return true;
|
|
199
|
-
}
|
|
200
|
-
if (typeof key === "string" && key.startsWith("-D")) {
|
|
201
|
-
runtime.properties.set(key.slice(2), formatValue(value));
|
|
202
|
-
return true;
|
|
203
|
-
}
|
|
204
|
-
throw new TlaEvaluationError(
|
|
205
|
-
`The first argument of TLCSet should be a nonnegative integer, but instead it is:\n${formatValue(key)}`,
|
|
206
|
-
);
|
|
207
|
-
}),
|
|
208
|
-
defineConstant("Any", { kind: "InfiniteSet", name: "Any" }),
|
|
209
|
-
defineOperator("RandomElement", 1, (args) => {
|
|
210
|
-
const elements = getElements(args, 0, "RandomElement");
|
|
211
|
-
if (elements.length === 0) throw new TlaEvaluationError("RandomElement of the empty set");
|
|
212
|
-
return elements[Math.floor(runtime.random() * elements.length)];
|
|
212
|
+
setTlcValue(runtime, print, key, getValue(args, 1, "TLCSet"));
|
|
213
|
+
return true;
|
|
213
214
|
}),
|
|
215
|
+
defineConstant("Any", ANY_SET),
|
|
216
|
+
defineOperator("RandomElement", 1, (args) =>
|
|
217
|
+
getRandomElement(getEnumerableSet(args, 0, "RandomElement"), runtime.getRandom()),
|
|
218
|
+
),
|
|
214
219
|
];
|