tla-ts 0.0.3 → 0.0.4-dev.0be9567
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 +32 -12
- package/dist/cli.cjs +1 -1
- package/dist/cli.js +1 -1
- package/dist/index.cjs +1 -1
- package/dist/index.d.cts +162 -8
- package/dist/index.d.ts +162 -8
- 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 +45 -18
- package/dist/run-cli.js +45 -18
- package/dist/transfer.cjs +1393 -18
- package/dist/transfer.js +1393 -18
- package/package.json +5 -1
- package/src/ast.ts +147 -6
- package/src/bags.ts +4 -7
- package/src/builtins.ts +29 -11
- package/src/bundled-modules.ts +3 -3
- package/src/canonical.ts +4 -3
- package/src/check.ts +1539 -235
- package/src/cli-options.ts +11 -5
- package/src/cli.ts +8 -1
- package/src/codegen.ts +98 -39
- package/src/config.ts +254 -181
- package/src/dependencies.ts +2 -2
- package/src/environment.ts +540 -140
- package/src/errors.ts +224 -3
- package/src/evaluate.ts +994 -279
- package/src/exit-codes.ts +22 -43
- package/src/fingerprints.ts +46 -11
- package/src/index.ts +1 -0
- package/src/instances.ts +19 -16
- package/src/java-overrides.ts +104 -25
- package/src/levels.ts +191 -45
- package/src/lexer.ts +127 -30
- package/src/live-check.ts +867 -0
- package/src/liveness.ts +218 -572
- package/src/obligation-expression.ts +2 -2
- package/src/obligation-source.ts +2 -0
- package/src/parallel-worker.ts +174 -213
- package/src/parallel.ts +131 -39
- package/src/parser.ts +456 -147
- package/src/pcal-ast.ts +770 -0
- package/src/pcal-parse.ts +1523 -0
- package/src/pcal-tokenize.ts +516 -0
- package/src/pcal-translate.ts +1230 -0
- package/src/pcal-validate.ts +454 -0
- package/src/randomization.ts +24 -7
- package/src/resolve.ts +1481 -426
- package/src/run-cli.ts +1212 -143
- package/src/runtime.ts +19 -1
- package/src/sany-builtins.ts +147 -0
- package/src/sany-generator.ts +3128 -0
- package/src/sany-levels.ts +1208 -0
- package/src/sany-lexer.ts +545 -0
- package/src/sany-linter.ts +122 -0
- package/src/sany-modules.ts +1398 -0
- package/src/sany-nodes.ts +463 -0
- package/src/sany-parse-error.ts +2161 -0
- package/src/sany-report.ts +356 -0
- package/src/sany-selectors.ts +738 -0
- package/src/sany-source.ts +248 -0
- package/src/sany-xml.ts +1017 -0
- package/src/spec-description.ts +42 -11
- package/src/standard-modules.ts +203 -148
- package/src/standard-ranges.ts +116 -0
- package/src/state-graph.ts +180 -0
- package/src/subexpressions.ts +231 -171
- package/src/substitution-levels.ts +38 -17
- package/src/successors.ts +220 -108
- package/src/symmetry.ts +194 -54
- package/src/tableau.ts +54 -25
- package/src/tlc-ext.ts +42 -29
- package/src/tlc-messages.ts +329 -0
- package/src/tlc-module.ts +52 -43
- package/src/tlc-modules.ts +4 -0
- package/src/tlc-order.ts +78 -10
- package/src/tlc-random.ts +37 -9
- package/src/tlc-replay.ts +655 -0
- package/src/tlc-summary.ts +20 -5
- package/src/tlc-version.ts +18 -0
- package/src/transfer.ts +15 -3
- package/src/value-sources.ts +29 -0
- package/src/values.ts +743 -189
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/cli.ts
CHANGED
|
@@ -1,6 +1,13 @@
|
|
|
1
1
|
#!/usr/bin/env node
|
|
2
2
|
import { enableCompileCache } from "node:module";
|
|
3
|
+
import { join } from "node:path";
|
|
3
4
|
|
|
4
|
-
|
|
5
|
+
// When tla-ts runs in place of java, it keeps its temporary files where Java would.
|
|
6
|
+
const JAVA_TMPDIR_PROPERTY = "-Djava.io.tmpdir=";
|
|
7
|
+
const javaTmpdir = process.argv
|
|
8
|
+
.find((arg) => arg.startsWith(JAVA_TMPDIR_PROPERTY))
|
|
9
|
+
?.slice(JAVA_TMPDIR_PROPERTY.length);
|
|
10
|
+
|
|
11
|
+
enableCompileCache?.(javaTmpdir && join(javaTmpdir, "node-compile-cache"));
|
|
5
12
|
|
|
6
13
|
void import("./run-cli").then((module) => module.runCli());
|
package/src/codegen.ts
CHANGED
|
@@ -1,34 +1,36 @@
|
|
|
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
|
-
getEnumeratedElements,
|
|
10
6
|
getConditionError,
|
|
11
|
-
|
|
7
|
+
getJunctionError,
|
|
12
8
|
getDomainOperator,
|
|
13
9
|
getSubsetOperator,
|
|
14
10
|
getEvaluator,
|
|
15
|
-
|
|
11
|
+
getFieldSelector,
|
|
12
|
+
getMissingArgumentDescriber,
|
|
13
|
+
getQuantifierElements,
|
|
16
14
|
isClosedConstant,
|
|
17
|
-
isLocallyResolved,
|
|
18
15
|
isTlcInteger,
|
|
19
16
|
isValueArgument,
|
|
20
17
|
isWorthCaching,
|
|
21
18
|
keepLazy,
|
|
22
19
|
resolveGlobalOperator,
|
|
20
|
+
expectFunction,
|
|
21
|
+
toKeepLazyContext,
|
|
22
|
+
createPrimeOutsideActionError,
|
|
23
|
+
createUnassignedError,
|
|
24
|
+
getSortedFields,
|
|
25
|
+
hasDuplicateFields,
|
|
23
26
|
type Context,
|
|
24
27
|
type Environment,
|
|
25
28
|
type Evaluator,
|
|
26
29
|
} from "./evaluate";
|
|
27
30
|
import {
|
|
28
31
|
applyFunction,
|
|
29
|
-
compareValues,
|
|
30
32
|
createEnumeratedSet,
|
|
31
|
-
|
|
33
|
+
createSortedRecord,
|
|
32
34
|
createTuple,
|
|
33
35
|
createWrittenRecord,
|
|
34
36
|
valuesEqual,
|
|
@@ -72,33 +74,32 @@ const createRuntime = () => ({
|
|
|
72
74
|
if (typeof value !== "boolean") throw getConditionError(expression, value);
|
|
73
75
|
return value;
|
|
74
76
|
},
|
|
75
|
-
|
|
76
|
-
if (typeof value !== "boolean") throw
|
|
77
|
+
junct: (value: Value, expression: Expression & { kind: "And" | "Or" }, index: number) => {
|
|
78
|
+
if (typeof value !== "boolean") throw getJunctionError(expression, index, value);
|
|
77
79
|
return value;
|
|
78
80
|
},
|
|
79
81
|
apply: applyFunction,
|
|
82
|
+
expectFunction,
|
|
80
83
|
tuple: createTuple,
|
|
81
84
|
set: createEnumeratedSet,
|
|
82
|
-
record:
|
|
85
|
+
record: createSortedRecord,
|
|
83
86
|
writtenRecord: createWrittenRecord,
|
|
84
87
|
equal: valuesEqual,
|
|
85
|
-
enumerate:
|
|
88
|
+
enumerate: getQuantifierElements,
|
|
86
89
|
unassigned: (name: string, expression: Expression): never => {
|
|
87
|
-
throw
|
|
88
|
-
`The variable ${name} is not assigned at ${describeLocation(expression)}`,
|
|
89
|
-
);
|
|
90
|
+
throw createUnassignedError(name, expression);
|
|
90
91
|
},
|
|
91
92
|
primeOutsideAction: (expression: Expression): never => {
|
|
92
|
-
throw
|
|
93
|
-
`A primed expression appears outside an action at ${describeLocation(expression)}`,
|
|
94
|
-
);
|
|
93
|
+
throw createPrimeOutsideActionError(expression);
|
|
95
94
|
},
|
|
96
95
|
prime: (context: Context): Context => ({
|
|
97
96
|
environment: context.environment,
|
|
98
97
|
scope: context.scope,
|
|
99
98
|
state: context.next,
|
|
100
99
|
next: undefined,
|
|
100
|
+
isKeepLazy: context.isKeepLazy,
|
|
101
101
|
}),
|
|
102
|
+
keepLazyContext: toKeepLazyContext,
|
|
102
103
|
extend: (context: Context, names: string[], values: Value[]): Context => ({
|
|
103
104
|
environment: context.environment,
|
|
104
105
|
scope: names.reduce(
|
|
@@ -107,6 +108,7 @@ const createRuntime = () => ({
|
|
|
107
108
|
),
|
|
108
109
|
state: context.state,
|
|
109
110
|
next: context.next,
|
|
111
|
+
isKeepLazy: context.isKeepLazy,
|
|
110
112
|
}),
|
|
111
113
|
});
|
|
112
114
|
|
|
@@ -157,7 +159,7 @@ const generateQuantifier = (
|
|
|
157
159
|
const lists = expression.bounds.map(() => createLocal(generator));
|
|
158
160
|
const declarations = expression.bounds.map(
|
|
159
161
|
(bound, index) =>
|
|
160
|
-
`const ${lists[index]} = enumerate(${generateExpression(generator, bound.set, inner)}, ${addReference(generator, bound.set)});`,
|
|
162
|
+
`const ${lists[index]} = enumerate(${generateExpression(generator, bound.set, inner)}, ${addReference(generator, bound.set)}, ${JSON.stringify(generator.environment.runtime.version)});`,
|
|
161
163
|
);
|
|
162
164
|
const elements = expression.bounds.map((bound) => {
|
|
163
165
|
const local = createLocal(generator);
|
|
@@ -165,13 +167,17 @@ const generateQuantifier = (
|
|
|
165
167
|
return local;
|
|
166
168
|
});
|
|
167
169
|
const test = `if (bool(${generateExpression(generator, expression.body, inner)}, ${description}) !== ${isForall}) return ${!isForall};`;
|
|
170
|
+
// enumerate returns an array, or an interval, which has a low end, to step through.
|
|
168
171
|
const loops = elements.reduce((code, element, index) => {
|
|
169
172
|
const position = createLocal(generator);
|
|
170
|
-
|
|
173
|
+
const low = createLocal(generator);
|
|
174
|
+
const size = createLocal(generator);
|
|
175
|
+
const list = lists[index];
|
|
176
|
+
return `for (let ${position} = 0, ${low} = ${list}.low, ${size} = ${low} === undefined ? ${list}.length : ${list}.high - ${low} + 1; ${position} < ${size}; ${position}++) { const ${element} = ${low} === undefined ? ${list}[${position}] : ${low} + ${position}; ${code} }`;
|
|
171
177
|
}, test);
|
|
172
178
|
const parameters = outer.map((local) => `, ${local}`).join("");
|
|
173
179
|
generator.helpers.push(
|
|
174
|
-
`function ${name}(context, state, next${parameters}) { let primed; ${declarations.join(" ")} ${loops} return ${isForall}; }`,
|
|
180
|
+
`function ${name}(context, state, next${parameters}) { let primed; let applied; ${declarations.join(" ")} ${loops} return ${isForall}; }`,
|
|
175
181
|
);
|
|
176
182
|
return `${name}(${frame.context}, ${frame.state}, ${frame.isPrimed ? "undefined" : frame.next}${parameters})`;
|
|
177
183
|
};
|
|
@@ -215,6 +221,49 @@ const generateApply = (
|
|
|
215
221
|
return generateDelegate(generator, expression, frame);
|
|
216
222
|
};
|
|
217
223
|
|
|
224
|
+
// Whether an expression only reads values, so that it constructs no function whatever the control.
|
|
225
|
+
const isConstructionFree = (
|
|
226
|
+
expression: Expression,
|
|
227
|
+
frame: Frame,
|
|
228
|
+
environment: Environment,
|
|
229
|
+
): boolean => {
|
|
230
|
+
switch (expression.kind) {
|
|
231
|
+
case "Identifier": {
|
|
232
|
+
if (frame.locals.has(expression.name)) return true;
|
|
233
|
+
if (isLocallyResolved(expression)) return false;
|
|
234
|
+
const global = findGlobalName(expression.name, environment);
|
|
235
|
+
return global?.kind === "Variable" || global?.kind === "Value";
|
|
236
|
+
}
|
|
237
|
+
case "Prime":
|
|
238
|
+
return isConstructionFree(expression.expression, frame, environment);
|
|
239
|
+
case "FieldAccess":
|
|
240
|
+
return isConstructionFree(expression.record, frame, environment);
|
|
241
|
+
case "FunctionApplication":
|
|
242
|
+
return [expression.function, ...expression.args].every((child) =>
|
|
243
|
+
isConstructionFree(child, frame, environment),
|
|
244
|
+
);
|
|
245
|
+
default:
|
|
246
|
+
return false;
|
|
247
|
+
}
|
|
248
|
+
};
|
|
249
|
+
|
|
250
|
+
// Whether the generated code evaluates an expression only in the context its frame names. A primed
|
|
251
|
+
// expression doesn't, since it shares the generated function's primed context.
|
|
252
|
+
const isReadOnly = (expression: Expression): boolean => {
|
|
253
|
+
switch (expression.kind) {
|
|
254
|
+
case "Identifier":
|
|
255
|
+
case "Number":
|
|
256
|
+
case "String":
|
|
257
|
+
return true;
|
|
258
|
+
case "FieldAccess":
|
|
259
|
+
return isReadOnly(expression.record);
|
|
260
|
+
case "FunctionApplication":
|
|
261
|
+
return [expression.function, ...expression.args].every(isReadOnly);
|
|
262
|
+
default:
|
|
263
|
+
return false;
|
|
264
|
+
}
|
|
265
|
+
};
|
|
266
|
+
|
|
218
267
|
const generateExpression = (generator: Generator, expression: Expression, frame: Frame): string => {
|
|
219
268
|
const generate = (node: Expression, nodeFrame = frame) =>
|
|
220
269
|
generateExpression(generator, node, nodeFrame);
|
|
@@ -244,31 +293,41 @@ const generateExpression = (generator: Generator, expression: Expression, frame:
|
|
|
244
293
|
}
|
|
245
294
|
case "Apply":
|
|
246
295
|
return generateApply(generator, expression, frame);
|
|
247
|
-
case "And":
|
|
296
|
+
case "And":
|
|
297
|
+
case "Or": {
|
|
248
298
|
const node = addReference(generator, expression);
|
|
249
|
-
|
|
299
|
+
const operator = expression.kind === "And" ? " && " : " || ";
|
|
300
|
+
return `(${expression.operands.map((operand, index) => `junct(${generate(operand)}, ${node}, ${index})`).join(operator)})`;
|
|
250
301
|
}
|
|
251
|
-
case "Or":
|
|
252
|
-
return `(${expression.operands.map((operand) => `bool(${generate(operand)}, "a disjunct")`).join(" || ")})`;
|
|
253
302
|
case "If":
|
|
254
303
|
return `(condition(${generate(expression.condition)}, ${addReference(generator, expression)}) ? ${generate(expression.consequent)} : ${generate(expression.alternative)})`;
|
|
255
304
|
case "FunctionApplication": {
|
|
256
305
|
keepLazy(expression.function);
|
|
257
|
-
|
|
306
|
+
// The interpreter evaluates a function that may construct one with EvalControl.KeepLazy.
|
|
307
|
+
const keepLazyFrame = { ...frame, context: `keepLazyContext(${frame.context})` };
|
|
308
|
+
const evaluatedFunction = isConstructionFree(
|
|
309
|
+
expression.function,
|
|
310
|
+
frame,
|
|
311
|
+
generator.environment,
|
|
312
|
+
)
|
|
313
|
+
? generate(expression.function)
|
|
314
|
+
: isReadOnly(expression.function)
|
|
315
|
+
? generate(expression.function, keepLazyFrame)
|
|
316
|
+
: generateDelegate(generator, expression.function, keepLazyFrame);
|
|
317
|
+
// Tool#evalAppl checks that it applies a function before it evaluates the argument. The check
|
|
318
|
+
// is written out, as calling expectFunction for each application costs more.
|
|
319
|
+
const functionCode = `(applied = ${evaluatedFunction}, typeof applied === "object" && (applied.kind === "Function" || applied.kind === "LazyFunction") ? applied : expectFunction(applied, ${addReference(generator, expression)}))`;
|
|
320
|
+
const describeMissing = getMissingArgumentDescriber(generator.environment.runtime.version);
|
|
321
|
+
const error = describeMissing ? `, ${addReference(generator, describeMissing)}` : "";
|
|
258
322
|
if (expression.args.length === 1)
|
|
259
|
-
return `apply(${functionCode}, ${generate(expression.args[0])})`;
|
|
260
|
-
return `apply(${functionCode}, tuple([${expression.args.map((arg) => generate(arg)).join(", ")}]))`;
|
|
323
|
+
return `apply(${functionCode}, ${generate(expression.args[0])}${error})`;
|
|
324
|
+
return `apply(${functionCode}, tuple([${expression.args.map((arg) => generate(arg)).join(", ")}])${error})`;
|
|
261
325
|
}
|
|
262
326
|
case "FieldAccess":
|
|
263
|
-
return
|
|
327
|
+
return `${addReference(generator, getFieldSelector(expression))}(${generate(expression.record)})`;
|
|
264
328
|
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);
|
|
329
|
+
const fields = getSortedFields(expression.fields);
|
|
330
|
+
if (hasDuplicateFields(fields)) return generateDelegate(generator, expression, frame);
|
|
272
331
|
const names = addReference(
|
|
273
332
|
generator,
|
|
274
333
|
fields.map((field) => field.name),
|
|
@@ -330,7 +389,7 @@ export const generateEvaluator = (
|
|
|
330
389
|
};
|
|
331
390
|
const body = generateExpression(generator, expression, frame);
|
|
332
391
|
const referenceNames = generator.references.map((_, index) => `reference${index}`);
|
|
333
|
-
const source = `${generator.helpers.join("\n")}\nreturn (context) => { const state = context.state; const next = context.next; let primed; return ${body}; };`;
|
|
392
|
+
const source = `${generator.helpers.join("\n")}\nreturn (context) => { const state = context.state; const next = context.next; let primed; let applied; return ${body}; };`;
|
|
334
393
|
runtime.value ??= createRuntime();
|
|
335
394
|
const helpers = runtime.value;
|
|
336
395
|
const helperNames = Object.keys(helpers);
|