tla-ts 0.0.10-dev.09e53c2a6 → 0.0.10-dev.11307be75
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/dist/compile.cjs +3 -3
- package/dist/compile.js +1 -1
- package/dist/deciders.cjs +36 -36
- package/dist/deciders.js +54 -54
- package/dist/index.cjs +1 -1
- package/dist/index.d.cts +2 -1
- package/dist/index.d.ts +2 -1
- package/dist/index.js +1 -1
- package/dist/parallel-worker.cjs +1 -1
- package/dist/parallel-worker.js +1 -1
- package/dist/prove-worker.cjs +1 -1
- package/dist/prove-worker.js +1 -1
- package/dist/prove.cjs +43 -43
- package/dist/prove.js +78 -78
- package/dist/run.cjs +33 -35
- package/dist/run.js +44 -46
- package/dist/tlapm.cjs +1 -1
- package/dist/tlapm.js +2 -2
- package/dist/transfer.cjs +43 -43
- package/dist/transfer.js +38 -38
- package/dist/worker.cjs +6 -6
- package/dist/worker.js +6 -6
- package/package.json +1 -1
- package/src/ast.ts +1 -0
- package/src/bags.ts +46 -28
- package/src/check-trace.ts +2 -16
- package/src/check.ts +152 -64
- package/src/cli/runtime-invariants.ts +20 -56
- package/src/cli/tlc-arguments.ts +2 -2
- package/src/cli/tlc-output.ts +1 -2
- package/src/cli/tlc.ts +13 -8
- package/src/cli/xml-exporter.ts +1 -1
- package/src/codegen.ts +9 -5
- package/src/dependencies.ts +49 -9
- package/src/dfid.ts +9 -2
- package/src/environment.ts +57 -33
- package/src/errors.ts +7 -0
- package/src/evaluate.ts +92 -32
- package/src/exit-codes.ts +4 -2
- package/src/instances.ts +5 -5
- package/src/java-overrides.ts +2 -2
- package/src/levels.ts +138 -90
- package/src/liveness-checker.ts +43 -4
- package/src/liveness.ts +1 -1
- package/src/obligations/index.ts +1 -1
- package/src/obligations/normalize.ts +1 -4
- package/src/obligations/printer.ts +5 -5
- package/src/parallel-worker.ts +8 -2
- package/src/parallel.ts +5 -0
- package/src/parser.ts +106 -144
- package/src/prover/isabelle/isar/attrib.ts +4 -4
- package/src/prover/isabelle/isar/rule-cases.ts +8 -6
- package/src/prover/isabelle/provers/clasimp.ts +1 -1
- package/src/prover/isabelle/provers/hypsubst.ts +2 -2
- package/src/prover/isabelle/pure/rewriter.ts +3 -3
- package/src/prover/isabelle/pure/term.ts +3 -3
- package/src/prover/prep/md5.ts +26 -29
- package/src/prover/smt/rewrite.ts +2 -7
- package/src/prover/smt/simplify.ts +1 -1
- package/src/prover/smt/solver/asserted-formulas.ts +66 -1
- package/src/prover/smt/solver/ast-lt.ts +1 -1
- package/src/prover/smt/solver/ast.ts +58 -11
- package/src/prover/smt/solver/blast-term-ite.ts +47 -0
- package/src/prover/smt/solver/bound-simplifier.ts +2 -3
- package/src/prover/smt/solver/bv-decl-plugin.ts +13 -10
- package/src/prover/smt/solver/bv-rewriter.ts +1 -1
- package/src/prover/smt/solver/card2bv.ts +3 -5
- package/src/prover/smt/solver/cofactor-elim-term-ite.ts +2 -3
- package/src/prover/smt/solver/context.ts +24 -3
- package/src/prover/smt/solver/ctx-simplify.ts +1 -2
- package/src/prover/smt/solver/datatype-decl-plugin.ts +15 -7
- package/src/prover/smt/solver/dependent-expr-state.ts +9 -4
- package/src/prover/smt/solver/diff-neq.ts +1 -2
- package/src/prover/smt/solver/elim-term-ite-tactic.ts +48 -0
- package/src/prover/smt/solver/elim-uncnstr.ts +4 -7
- package/src/prover/smt/solver/euf/arith-internalize.ts +1 -1
- package/src/prover/smt/solver/euf/array-internalize.ts +1 -1
- package/src/prover/smt/solver/euf/bv-internalize.ts +1 -1
- package/src/prover/smt/solver/euf/egraph.ts +4 -10
- package/src/prover/smt/solver/euf/euf-solver.ts +1 -2
- package/src/prover/smt/solver/euf/mam.ts +1 -5
- package/src/prover/smt/solver/euf/q-ematch.ts +1 -2
- package/src/prover/smt/solver/euf/th-solver.ts +0 -7
- package/src/prover/smt/solver/expr2polynomial.ts +204 -79
- package/src/prover/smt/solver/factor.ts +36 -14
- package/src/prover/smt/solver/fd-solver.ts +2 -0
- package/src/prover/smt/solver/fix-dl-var.ts +1 -2
- package/src/prover/smt/solver/fpa-rewriter.ts +1 -2
- package/src/prover/smt/solver/fpa2bv-converter.ts +3 -1
- package/src/prover/smt/solver/fpa2bv-rewriter.ts +1 -0
- package/src/prover/smt/solver/goal.ts +6 -3
- package/src/prover/smt/solver/goal2nlsat.ts +57 -30
- package/src/prover/smt/solver/hashtable.ts +4 -0
- package/src/prover/smt/solver/logic-tactics.ts +9 -2
- package/src/prover/smt/solver/lp/containers.ts +7 -1
- package/src/prover/smt/solver/lp/cross-nested.ts +1 -3
- package/src/prover/smt/solver/lp/lp-settings.ts +1 -1
- package/src/prover/smt/solver/lp/nex-creator.ts +3 -2
- package/src/prover/smt/solver/lp/nex.ts +2 -1
- package/src/prover/smt/solver/lp/nla-core.ts +1 -1
- package/src/prover/smt/solver/lp/nla-grobner.ts +158 -80
- package/src/prover/smt/solver/lp/nra-solver.ts +45 -39
- package/src/prover/smt/solver/lp/pdd-interval.ts +6 -2
- package/src/prover/smt/solver/lp/pdd-simplifier.ts +60 -20
- package/src/prover/smt/solver/lp/pdd-solver.ts +72 -39
- package/src/prover/smt/solver/lp/pdd.ts +725 -290
- package/src/prover/smt/solver/lp/union-find.ts +1 -1
- package/src/prover/smt/solver/mam-compiler.ts +1 -1
- package/src/prover/smt/solver/model-based-opt.ts +1 -1
- package/src/prover/smt/solver/model-generator.ts +3 -1
- package/src/prover/smt/solver/mpf.ts +2 -4
- package/src/prover/smt/solver/mus.ts +2 -3
- package/src/prover/smt/solver/muz/dl-context.ts +10 -4
- package/src/prover/smt/solver/muz/dl-mk-slice.ts +3 -3
- package/src/prover/smt/solver/muz/dl-rule.ts +2 -2
- package/src/prover/smt/solver/muz/horn-subsume-model-converter.ts +1 -1
- package/src/prover/smt/solver/muz/horn-tactic.ts +1 -1
- package/src/prover/smt/solver/muz/spacer-context.ts +2 -4
- package/src/prover/smt/solver/muz/spacer-pdr.ts +1 -0
- package/src/prover/smt/solver/nlqsat.ts +1 -1
- package/src/prover/smt/solver/nlsat/algebraic.ts +196 -92
- package/src/prover/smt/solver/nlsat/atoms.ts +52 -33
- package/src/prover/smt/solver/nlsat/explain.ts +375 -217
- package/src/prover/smt/solver/nlsat/levelwise.ts +460 -240
- package/src/prover/smt/solver/nlsat/polynomial.ts +2366 -681
- package/src/prover/smt/solver/nlsat/solver.ts +74 -64
- package/src/prover/smt/solver/nlsat/transcendentals.ts +41 -17
- package/src/prover/smt/solver/nlsat/upolynomial-factorization.ts +8 -4
- package/src/prover/smt/solver/nlsat/upolynomial.ts +41 -18
- package/src/prover/smt/solver/nlsat-tactic.ts +1 -1
- package/src/prover/smt/solver/nnf.ts +6 -2
- package/src/prover/smt/solver/opt-context.ts +9 -3
- package/src/prover/smt/solver/opt-nlsat.ts +29 -18
- package/src/prover/smt/solver/opt-preprocess.ts +1 -1
- package/src/prover/smt/solver/opt-solver.ts +6 -3
- package/src/prover/smt/solver/optsmt.ts +1 -1
- package/src/prover/smt/solver/pb-rewriter.ts +1 -4
- package/src/prover/smt/solver/poly-rewriter.ts +74 -18
- package/src/prover/smt/solver/probes.ts +88 -23
- package/src/prover/smt/solver/proto-model.ts +4 -6
- package/src/prover/smt/solver/qe-arith-plugin.ts +2 -4
- package/src/prover/smt/solver/qe-lite.ts +2 -2
- package/src/prover/smt/solver/qe.ts +3 -2
- package/src/prover/smt/solver/quantifier-manager.ts +14 -9
- package/src/prover/smt/solver/recfun-decl-plugin.ts +2 -1
- package/src/prover/smt/solver/rlimit.ts +4 -0
- package/src/prover/smt/solver/sat/config.ts +1 -1
- package/src/prover/smt/solver/sat/inc-sat-solver.ts +26 -1
- package/src/prover/smt/solver/sat/model-converter.ts +1 -1
- package/src/prover/smt/solver/sat/pb-solver.ts +1 -1
- package/src/prover/smt/solver/sat/sat-tactic.ts +4 -3
- package/src/prover/smt/solver/sat/simplifier.ts +1 -1
- package/src/prover/smt/solver/sat/solver.ts +25 -47
- package/src/prover/smt/solver/seq-axioms.ts +20 -35
- package/src/prover/smt/solver/seq-decl-plugin.ts +1 -1
- package/src/prover/smt/solver/seq-derive.ts +4 -7
- package/src/prover/smt/solver/seq-eq-solver.ts +2 -2
- package/src/prover/smt/solver/seq-monadic.ts +7 -5
- package/src/prover/smt/solver/seq-re-rewriter.ts +2 -1
- package/src/prover/smt/solver/seq-re-util.ts +1 -1
- package/src/prover/smt/solver/seq-regex-bisim.ts +1 -1
- package/src/prover/smt/solver/seq-regex-live.ts +2 -2
- package/src/prover/smt/solver/seq-rewriter.ts +31 -29
- package/src/prover/smt/solver/seq-skolem.ts +0 -23
- package/src/prover/smt/solver/seq-view-witness.ts +4 -4
- package/src/prover/smt/solver/smt-kernel.ts +9 -3
- package/src/prover/smt/solver/smt-setup.ts +68 -6
- package/src/prover/smt/solver/smtlib-parser.ts +558 -220
- package/src/prover/smt/solver/smtlib-script.ts +495 -153
- package/src/prover/smt/solver/solve-eqs.ts +13 -21
- package/src/prover/smt/solver/tactic.ts +219 -130
- package/src/prover/smt/solver/theory-bv.ts +2 -2
- package/src/prover/smt/solver/theory-lra-final-check.ts +1 -1
- package/src/prover/smt/solver/theory-lra-internalize.ts +1 -0
- package/src/prover/smt/solver/theory-lra-propagate.ts +6 -4
- package/src/prover/smt/solver/theory-lra.ts +0 -1
- package/src/prover/smt/solver/theory-pb.ts +24 -7
- package/src/prover/smt/solver/theory-seq-solve.ts +1 -1
- package/src/prover/smt/solver/theory-seq-state.ts +2 -21
- package/src/prover/tlapm/cache.ts +8 -8
- package/src/prover/zenon/equality-rules.ts +24 -0
- package/src/prover/zenon/expr.ts +21 -0
- package/src/prover/zenon/index-table.ts +7 -2
- package/src/prover/zenon/isar-case.ts +1 -1
- package/src/prover/zenon/isar.ts +2 -2
- package/src/prover/zenon/phrase.ts +1 -1
- package/src/prover/zenon/rules.ts +2 -1
- package/src/resolve.ts +779 -225
- package/src/runtime.ts +3 -1
- package/src/sany/builtins.ts +10 -10
- package/src/sany/generation.ts +2 -13
- package/src/sany/generator-definitions.ts +3 -1
- package/src/sany/generator-expressions.ts +36 -30
- package/src/sany/generator-proofs.ts +5 -3
- package/src/sany/generator.ts +2 -1
- package/src/sany/lexer.ts +3 -3
- package/src/sany/modules.ts +4 -2
- package/src/sany/nodes.ts +1 -1
- package/src/sany/selectors.ts +11 -6
- package/src/sany/xml.ts +2 -3
- package/src/search.ts +51 -22
- package/src/spec-description.ts +2 -2
- package/src/subexpressions.ts +337 -102
- package/src/successors.ts +1 -0
- package/src/symmetry.ts +1 -1
- package/src/tlc/jar-data.ts +10 -0
- package/src/tlc/messages.ts +3 -3
- package/src/tlc/order.ts +14 -3
- package/src/tlc/tlc-operators.ts +3 -1
- package/src/tlc/tlcext-operators.ts +18 -5
- package/src/tlc/trace-spec.ts +5 -5
- package/src/typed-tier.ts +29 -23
- package/src/typescript/types.ts +2 -2
- package/src/values.ts +46 -27
package/src/tlc/order.ts
CHANGED
|
@@ -444,7 +444,11 @@ const createContexts = (getParsed: ModuleSet) => {
|
|
|
444
444
|
};
|
|
445
445
|
};
|
|
446
446
|
|
|
447
|
-
const getStringOrder = (
|
|
447
|
+
const getStringOrder = (
|
|
448
|
+
getParsed: ModuleSet,
|
|
449
|
+
config: ModelConfig,
|
|
450
|
+
runtimeModules: string[],
|
|
451
|
+
): string[] => {
|
|
448
452
|
const order = new Set<string>();
|
|
449
453
|
const intern = (text: string) => {
|
|
450
454
|
order.add(text);
|
|
@@ -541,12 +545,19 @@ const getStringOrder = (getParsed: ModuleSet, config: ModelConfig): string[] =>
|
|
|
541
545
|
});
|
|
542
546
|
};
|
|
543
547
|
analyze(undefined);
|
|
548
|
+
runtimeModules.forEach((name) => {
|
|
549
|
+
const tokens = getUnitTokens(name);
|
|
550
|
+
getParsedTexts(tokens).forEach(intern);
|
|
551
|
+
tokens.forEach((token) => {
|
|
552
|
+
if (token.kind === "String") intern(token.text);
|
|
553
|
+
});
|
|
554
|
+
});
|
|
544
555
|
TLC_RUNTIME_STRINGS.forEach(intern);
|
|
545
556
|
return [...order];
|
|
546
557
|
};
|
|
547
558
|
|
|
548
559
|
export interface TlcOrder {
|
|
549
|
-
getStringOrder: (config: ModelConfig) => string[];
|
|
560
|
+
getStringOrder: (config: ModelConfig, runtimeModules: string[]) => string[];
|
|
550
561
|
getDeclarationOrder: (kind: "variable" | "constant") => string[];
|
|
551
562
|
createDefinitionOrder: () => (name: string | undefined) => string[];
|
|
552
563
|
parseModule: (source: string) => Module;
|
|
@@ -558,7 +569,7 @@ export const createTlcOrder = (source: string, loadModule: ModuleLoader): TlcOrd
|
|
|
558
569
|
let contexts: ReturnType<typeof createContexts> | undefined;
|
|
559
570
|
const getContexts = () => (contexts ??= createContexts(getParsed));
|
|
560
571
|
return {
|
|
561
|
-
getStringOrder: (config) => getStringOrder(getParsed, config),
|
|
572
|
+
getStringOrder: (config, runtimeModules) => getStringOrder(getParsed, config, runtimeModules),
|
|
562
573
|
getDeclarationOrder: (kind) =>
|
|
563
574
|
getContexts()
|
|
564
575
|
.getContext(undefined)
|
package/src/tlc/tlc-operators.ts
CHANGED
|
@@ -43,7 +43,9 @@ const formatCalendarVersion = (date: Date) =>
|
|
|
43
43
|
`${date.getUTCFullYear()}.${zeroPad(date.getUTCMonth() + 1)}.${zeroPad(date.getUTCDate())}.${zeroPad(date.getUTCHours())}${zeroPad(date.getUTCMinutes())}${zeroPad(date.getUTCSeconds())}`;
|
|
44
44
|
|
|
45
45
|
const getRegisterFunction = <Key extends Value>(registers: Map<Key, Value>) =>
|
|
46
|
-
createFunction(
|
|
46
|
+
createFunction(
|
|
47
|
+
[...registers].map((entry): [Value, Value] => [entry[0], createTuple([entry[1]])]),
|
|
48
|
+
);
|
|
47
49
|
|
|
48
50
|
const createTlcRecord = (fields: [string, Value][]) =>
|
|
49
51
|
setFunctionClass(createWrittenFunction(fields), "record");
|
|
@@ -263,10 +263,13 @@ export const createTlcExtOperators = (
|
|
|
263
263
|
defineOperator("TLCNoOp", 1, (args) => getValue(args, 0, "TLCNoOp")),
|
|
264
264
|
{
|
|
265
265
|
...defineLazyOperator("PickSuccessor", 1, (args, context) => {
|
|
266
|
-
// Deviation from TLC: TLCExt#pickSuccessor fingerprints a partial successor and fails, where TLCExt.tla promises TRUE.
|
|
267
266
|
const next = context?.next ?? (context?.environment.variables ?? []).map(() => undefined);
|
|
268
|
-
|
|
269
|
-
if (
|
|
267
|
+
// A simulation remembers no states, so TLC evaluates the guard before it looks at the successor.
|
|
268
|
+
if (runtime.getSimulationValue === undefined) {
|
|
269
|
+
// Deviation from TLC: TLCExt#pickSuccessor fingerprints a partial successor and fails, where TLCExt.tla promises TRUE.
|
|
270
|
+
if (!isCompleteState(next)) return true;
|
|
271
|
+
if (context?.next && runtime.isSeen(next)) return true;
|
|
272
|
+
}
|
|
270
273
|
const guard = getOperator(args, 0, "PickSuccessor");
|
|
271
274
|
const isPicked = guard.call([]);
|
|
272
275
|
if (typeof isPicked !== "boolean") {
|
|
@@ -274,7 +277,13 @@ export const createTlcExtOperators = (
|
|
|
274
277
|
`In evaluating TLCExt!PickSuccessor, a non-boolean expression (${getKindString(isPicked)}) was used as the condition of an IF.\n${guard.expression ? describeNode(guard.expression) : ""}`,
|
|
275
278
|
);
|
|
276
279
|
}
|
|
277
|
-
if (
|
|
280
|
+
if (
|
|
281
|
+
isPicked ||
|
|
282
|
+
!context?.next ||
|
|
283
|
+
!isCompleteState(next) ||
|
|
284
|
+
!context.state ||
|
|
285
|
+
!isCompleteState(context.state)
|
|
286
|
+
) {
|
|
278
287
|
return true;
|
|
279
288
|
}
|
|
280
289
|
const state = context.state;
|
|
@@ -303,9 +312,13 @@ export const createTlcExtOperators = (
|
|
|
303
312
|
} else if (answer[0] === "d") {
|
|
304
313
|
printOverride(formatState(runtime.toRecord(next), runtime.toRecord(state)));
|
|
305
314
|
} else if (answer[0] === "e") {
|
|
315
|
+
if (runtime.markExplored) {
|
|
316
|
+
runtime.markExplored(next);
|
|
317
|
+
return true;
|
|
318
|
+
}
|
|
306
319
|
if (runtime.getSimulationValue === undefined) {
|
|
307
320
|
throw new TlaUnsupportedError(
|
|
308
|
-
"tla-ts can't mark a state explored while it
|
|
321
|
+
"tla-ts can't mark a state explored while it searches depth first.",
|
|
309
322
|
);
|
|
310
323
|
}
|
|
311
324
|
printOverride(
|
package/src/tlc/trace-spec.ts
CHANGED
|
@@ -57,7 +57,7 @@ const getConjunction = (state: [string, string][], prefix?: string) =>
|
|
|
57
57
|
indent(
|
|
58
58
|
[
|
|
59
59
|
...(prefix === undefined ? [] : [prefix]),
|
|
60
|
-
...state.map((
|
|
60
|
+
...state.map((assignment) => `${assignment[0]} = (${assignment[1]})`),
|
|
61
61
|
].join("\n/\\\n"),
|
|
62
62
|
2,
|
|
63
63
|
);
|
|
@@ -180,9 +180,8 @@ ${lassoStep}${variables
|
|
|
180
180
|
\\* IN J!JsonSerialize("${input.module}.json", _TETrace)
|
|
181
181
|
|
|
182
182
|
`;
|
|
183
|
-
|
|
184
|
-
|
|
185
|
-
const view = isViewed
|
|
183
|
+
// MCError#isLassoWithDuplicates counts the state a lasso goes back to, so TLC views every lasso.
|
|
184
|
+
const view = isLasso
|
|
186
185
|
? {
|
|
187
186
|
config: "\nVIEW\n _view\n",
|
|
188
187
|
definition: `\n_view ==\n${INDENT}<<${variables.join(", ")}, IF TLCGet("level") = ${LASSO_END} + 1 THEN ${LASSO_START} ELSE TLCGet("level")>>\n`,
|
|
@@ -191,7 +190,8 @@ ${lassoStep}${variables
|
|
|
191
190
|
const deserializedTrace = `\n${getPrimer(traceModule, getHashOrder(["IOUtils", ...constantModules, specName]))}trace == IODeserialize("${input.module}.bin", TRUE)\n\n${CLOSING_TAG}`;
|
|
192
191
|
const traceFunction = `${INDENT}<<\n${states
|
|
193
192
|
.map(
|
|
194
|
-
(state) =>
|
|
193
|
+
(state) =>
|
|
194
|
+
`${INDENT}([${state.map((assignment) => `${assignment[0]} |-> ${assignment[1]}`).join(",")}])`,
|
|
195
195
|
)
|
|
196
196
|
.join(",\n")}\n${INDENT}>>${SEPARATOR}\n`;
|
|
197
197
|
|
package/src/typed-tier.ts
CHANGED
|
@@ -959,7 +959,7 @@ const createValueReader = (type: Type, plains: Plains): ((plain: Plain) => Value
|
|
|
959
959
|
const getRecordShapes = (resolved: RecType) =>
|
|
960
960
|
resolved.shapes.map((names) => {
|
|
961
961
|
const order = names
|
|
962
|
-
.map((
|
|
962
|
+
.map((_value, index) => index)
|
|
963
963
|
.sort((left, right) => compareValues(names[left], names[right]));
|
|
964
964
|
return {
|
|
965
965
|
names: order.map((index) => names[index]),
|
|
@@ -1314,11 +1314,11 @@ const getIndexCode = (program: Program, type: FnType, code: string) => {
|
|
|
1314
1314
|
}
|
|
1315
1315
|
const rows = keys.map((key) => (Array.isArray(key) ? key : [key]));
|
|
1316
1316
|
const isBoxed = rows.every((row) => row.length === rows[0].length && row.every(Number.isInteger));
|
|
1317
|
-
const columns = rows[0].map((
|
|
1317
|
+
const columns = rows[0].map((_value, column) => {
|
|
1318
1318
|
const values = rows.map((row) => Number(row[column]));
|
|
1319
1319
|
return { low: Math.min(...values), size: Math.max(...values) - Math.min(...values) + 1 };
|
|
1320
1320
|
});
|
|
1321
|
-
const strides = columns.map((
|
|
1321
|
+
const strides = columns.map((_value, column) =>
|
|
1322
1322
|
columns.slice(column + 1).reduce((product, next) => product * next.size, 1),
|
|
1323
1323
|
);
|
|
1324
1324
|
if (!isBoxed || strides[0] * columns[0].size > MAXIMUM_BITMAP) {
|
|
@@ -1397,7 +1397,8 @@ interface Frame {
|
|
|
1397
1397
|
isNext: boolean;
|
|
1398
1398
|
}
|
|
1399
1399
|
|
|
1400
|
-
const getVariableCodes = (program: Program) =>
|
|
1400
|
+
const getVariableCodes = (program: Program) =>
|
|
1401
|
+
program.variableTypes.map((_value, index) => `v${index}`);
|
|
1401
1402
|
|
|
1402
1403
|
// An expression primed as a whole reads every variable in the next state, where priming again is an
|
|
1403
1404
|
// error. A variable the action hasn't assigned yet has no value there, and TLC fails on it.
|
|
@@ -1580,7 +1581,7 @@ const getOperatorArgument = (
|
|
|
1580
1581
|
): OperatorBinding => {
|
|
1581
1582
|
// An operator such as \cap applies as an expression that applies it, so a builtin compiles as one.
|
|
1582
1583
|
if (arg.kind === "OperatorReference") {
|
|
1583
|
-
const names = Array.from({ length: arity }, (
|
|
1584
|
+
const names = Array.from({ length: arity }, (_value, index) => `#${index}`);
|
|
1584
1585
|
return {
|
|
1585
1586
|
kind: "Operator",
|
|
1586
1587
|
definition: {
|
|
@@ -4611,7 +4612,9 @@ const getSelections = (count: number) => {
|
|
|
4611
4612
|
};
|
|
4612
4613
|
|
|
4613
4614
|
const getBits = (mask: number) =>
|
|
4614
|
-
Array.from({ length: MASK_BITS }, (
|
|
4615
|
+
Array.from({ length: MASK_BITS }, (_value, bit) => bit).filter(
|
|
4616
|
+
(bit) => (mask & (1 << bit)) !== 0,
|
|
4617
|
+
);
|
|
4615
4618
|
|
|
4616
4619
|
const advanceOdometer = (positions: number[], base: number) => {
|
|
4617
4620
|
for (let index = positions.length - 1; index >= 0; index--) {
|
|
@@ -4730,7 +4733,7 @@ const HELPERS = {
|
|
|
4730
4733
|
sortMap: (compare: Comparer, keys: Plain[], values: Plain[]) => {
|
|
4731
4734
|
if (keys.length > MAXIMUM_INSERTION_SORT) {
|
|
4732
4735
|
const order = keys
|
|
4733
|
-
.map((
|
|
4736
|
+
.map((_value, index) => index)
|
|
4734
4737
|
.sort((left, right) => compare(keys[left], keys[right]));
|
|
4735
4738
|
return [order.map((index) => keys[index]), order.map((index) => values[index])];
|
|
4736
4739
|
}
|
|
@@ -4822,7 +4825,7 @@ const HELPERS = {
|
|
|
4822
4825
|
interval: (low: number, high: number) =>
|
|
4823
4826
|
high - low + 1 > getMaximumSetSize()
|
|
4824
4827
|
? deopt()
|
|
4825
|
-
: Array.from({ length: Math.max(0, high - low + 1) }, (
|
|
4828
|
+
: Array.from({ length: Math.max(0, high - low + 1) }, (_value, index) => low + index),
|
|
4826
4829
|
index: (index: Int32Array, offset: number) =>
|
|
4827
4830
|
offset >= 0 && offset < index.length ? index[offset] : -1,
|
|
4828
4831
|
has: (mask: number, element: number) =>
|
|
@@ -4893,7 +4896,7 @@ const HELPERS = {
|
|
|
4893
4896
|
map[0].every((key, index) => key === index + 1) ? map[1] : deopt(),
|
|
4894
4897
|
toSequenceMask: (map: [number, Plain[]]) =>
|
|
4895
4898
|
map[0] === HELPERS.range(1, map[1].length) ? map[1] : deopt(),
|
|
4896
|
-
fromSequence: (values: Plain[]) => [values.map((
|
|
4899
|
+
fromSequence: (values: Plain[]) => [values.map((_value, index) => index + 1), values],
|
|
4897
4900
|
fromSequenceMask: (values: Plain[]) => [HELPERS.range(1, values.length), values],
|
|
4898
4901
|
lookupScanned: (compare: Comparer, map: Plain[][], key: Plain) => {
|
|
4899
4902
|
const index = findScannedKey(compare, map[0], key);
|
|
@@ -5259,7 +5262,7 @@ const getKeyWriter = (
|
|
|
5259
5262
|
case "Fn": {
|
|
5260
5263
|
const positions = isPermuted && getMovedPositions(images, resolved.domain);
|
|
5261
5264
|
if (!positions) {
|
|
5262
|
-
return `{ const ${name} = ${code}; ${resolved.domain.map((
|
|
5265
|
+
return `{ const ${name} = ${code}; ${resolved.domain.map((_value, index) => getInner(resolved.range, `${name}[${index}]`)).join(" ")} }`;
|
|
5263
5266
|
}
|
|
5264
5267
|
const base = program.indexes.length;
|
|
5265
5268
|
program.indexes.push(
|
|
@@ -5272,7 +5275,7 @@ const getKeyWriter = (
|
|
|
5272
5275
|
}),
|
|
5273
5276
|
);
|
|
5274
5277
|
const sources = getName(program, "s");
|
|
5275
|
-
return `{ const ${name} = ${code}; const ${sources} = D[${base} + G]; ${resolved.domain.map((
|
|
5278
|
+
return `{ const ${name} = ${code}; const ${sources} = D[${base} + G]; ${resolved.domain.map((_value, index) => getInner(resolved.range, `${name}[${sources}[${index}]]`)).join(" ")} }`;
|
|
5276
5279
|
}
|
|
5277
5280
|
case "Tup":
|
|
5278
5281
|
return `{ const ${name} = ${code}; ${getParts(resolved)
|
|
@@ -5590,21 +5593,21 @@ const getSignatureCode = (
|
|
|
5590
5593
|
return `{ const ${record} = ${code}; switch (${record}[0]) { ${cases.join(" ")} } }`;
|
|
5591
5594
|
}
|
|
5592
5595
|
case "Fn": {
|
|
5593
|
-
const
|
|
5596
|
+
const functionValue = getName(program, "f");
|
|
5594
5597
|
const weight = getWeight();
|
|
5595
5598
|
const keys = resolved.domain.flatMap((key, position) => {
|
|
5596
5599
|
const id =
|
|
5597
5600
|
typeof key === "object" && key.kind === "ModelValue"
|
|
5598
5601
|
? program.plains.ids.get(key)
|
|
5599
5602
|
: undefined;
|
|
5600
|
-
const value = getScalarCode(resolved.range, `${
|
|
5603
|
+
const value = getScalarCode(resolved.range, `${functionValue}[${position}]`);
|
|
5601
5604
|
return id === undefined || value === undefined
|
|
5602
5605
|
? []
|
|
5603
5606
|
: [`Z[${id}] += Math.imul(Math.imul(${weight}, ${scale}), ${value});`];
|
|
5604
5607
|
});
|
|
5605
|
-
const values = getLoop(resolved.range,
|
|
5608
|
+
const values = getLoop(resolved.range, functionValue);
|
|
5606
5609
|
if (keys.length === 0 && values === undefined) return undefined;
|
|
5607
|
-
return `{ const ${
|
|
5610
|
+
return `{ const ${functionValue} = ${code}; ${keys.join(" ")} ${values ?? ""} }`;
|
|
5608
5611
|
}
|
|
5609
5612
|
case "Map": {
|
|
5610
5613
|
const parts = [
|
|
@@ -5738,7 +5741,7 @@ const compileSpec = (
|
|
|
5738
5741
|
return () => (unchanged ? `!(${unchanged.emit()}) && (${action.emit()})` : action.emit());
|
|
5739
5742
|
});
|
|
5740
5743
|
program.variableTypes.forEach((type) => closeType(type));
|
|
5741
|
-
const parameters = program.variableTypes.map((
|
|
5744
|
+
const parameters = program.variableTypes.map((_value, index) => `v${index}`).join(", ");
|
|
5742
5745
|
const unpack = `const [${parameters}] = state;`;
|
|
5743
5746
|
// A state predicate reads the state through the variables it unpacks, so it holds of a successor
|
|
5744
5747
|
// with its parent's values of those.
|
|
@@ -5786,7 +5789,7 @@ const compileSpec = (
|
|
|
5786
5789
|
const keyOrder = check.view
|
|
5787
5790
|
? [...new Set(getProjectedVariables(program, check.view, new Map()))]
|
|
5788
5791
|
: program.variableTypes
|
|
5789
|
-
.map((
|
|
5792
|
+
.map((_value, index) => index)
|
|
5790
5793
|
.sort((left, right) => getKeyCost(left) - getKeyCost(right));
|
|
5791
5794
|
const getKeyWriters = (isPermuted: boolean) =>
|
|
5792
5795
|
keyOrder.map((index) =>
|
|
@@ -5840,7 +5843,7 @@ const compileSpec = (
|
|
|
5840
5843
|
let c = 0;
|
|
5841
5844
|
let k = -1;
|
|
5842
5845
|
compare: { ${imageComparisons.map((item, position) => `${item.build} c = ${item.comparison}; if (c > 0) continue images; if (c < 0) { k = ${position}; ${item.choose} break compare; }`).join(" ")} }
|
|
5843
|
-
switch (k) { ${imageComparisons.map((
|
|
5846
|
+
switch (k) { ${imageComparisons.map((_value, position) => `case ${position}: ${imageComparisons[position + 1]?.note ?? ""}`).join(" ")} }
|
|
5844
5847
|
}
|
|
5845
5848
|
${imageComparisons.map((item) => item.build).join(" ")}`;
|
|
5846
5849
|
const viewKeyCode = `${smallestCode} ${viewWriters.join(" ")}`;
|
|
@@ -5885,7 +5888,7 @@ const compileSpec = (
|
|
|
5885
5888
|
const values = program.plains.values;
|
|
5886
5889
|
const ranks = new Int32Array(values.length);
|
|
5887
5890
|
values
|
|
5888
|
-
.map((
|
|
5891
|
+
.map((_value, id) => id)
|
|
5889
5892
|
.sort((left, right) => compareAtoms(values[left], values[right]))
|
|
5890
5893
|
.forEach((id, rank) => {
|
|
5891
5894
|
ranks[id] = rank;
|
|
@@ -5922,7 +5925,7 @@ const compileSpec = (
|
|
|
5922
5925
|
X[0] = i;
|
|
5923
5926
|
${readers.map((reader, index) => `const value${index} = ${reader}; X[${index + 1}] = i;`).join(" ")}
|
|
5924
5927
|
cursor.position = (i + 3) & ~3;
|
|
5925
|
-
E = [${readers.map((
|
|
5928
|
+
E = [${readers.map((_value, index) => `value${index}`).join(", ")}];
|
|
5926
5929
|
return E;
|
|
5927
5930
|
},
|
|
5928
5931
|
writeKey: (state, arena) => {
|
|
@@ -5951,7 +5954,9 @@ const compileSpec = (
|
|
|
5951
5954
|
// A key is the smallest image among those whose sums of moved atoms, in a fixed order of the
|
|
5952
5955
|
// atoms, are smallest. Which images those are depends only on the state, so its orbit shares it.
|
|
5953
5956
|
const moved = Int32Array.from(
|
|
5954
|
-
program.plains.values.flatMap((
|
|
5957
|
+
program.plains.values.flatMap((_value, id) =>
|
|
5958
|
+
atoms.some((table) => table[id] !== id) ? [id] : [],
|
|
5959
|
+
),
|
|
5955
5960
|
);
|
|
5956
5961
|
const preimages = [
|
|
5957
5962
|
moved,
|
|
@@ -6048,7 +6053,7 @@ const MINIMUM_SORTED_IMAGES = 24;
|
|
|
6048
6053
|
const getFullOrbits = (preimages: Int32Array[]): Orbits | undefined => {
|
|
6049
6054
|
if (preimages.length < MINIMUM_SORTED_IMAGES) return undefined;
|
|
6050
6055
|
const moved = preimages[0];
|
|
6051
|
-
const roots = Int32Array.from({ length: Math.max(0, ...moved) + 1 }, (
|
|
6056
|
+
const roots = Int32Array.from({ length: Math.max(0, ...moved) + 1 }, (_value, atom) => atom);
|
|
6052
6057
|
const findRoot = (atom: number): number =>
|
|
6053
6058
|
roots[atom] === atom ? atom : (roots[atom] = findRoot(roots[atom]));
|
|
6054
6059
|
preimages.forEach((preimage) =>
|
|
@@ -6063,7 +6068,8 @@ const getFullOrbits = (preimages: Int32Array[]): Orbits | undefined => {
|
|
|
6063
6068
|
starts[index + 1] = starts[index] + orbit.length;
|
|
6064
6069
|
});
|
|
6065
6070
|
const count = orbits.reduce(
|
|
6066
|
-
(product, orbit) =>
|
|
6071
|
+
(product, orbit) =>
|
|
6072
|
+
orbit.reduce((factorial, _value, index) => factorial * (index + 1), product),
|
|
6067
6073
|
1,
|
|
6068
6074
|
);
|
|
6069
6075
|
if (count !== preimages.length) return undefined;
|
package/src/typescript/types.ts
CHANGED
|
@@ -81,7 +81,7 @@ export const findDomain = (type: ts.Type, context: Context): string | Infinite =
|
|
|
81
81
|
if (type.isUnion()) {
|
|
82
82
|
const literals = type.types.map((member) => getLiteral(member, context));
|
|
83
83
|
const others = findDomains(
|
|
84
|
-
type.types.filter((
|
|
84
|
+
type.types.filter((_value, index) => literals[index] === undefined),
|
|
85
85
|
context,
|
|
86
86
|
);
|
|
87
87
|
if (!Array.isArray(others)) return others;
|
|
@@ -91,7 +91,7 @@ export const findDomain = (type: ts.Type, context: Context): string | Infinite =
|
|
|
91
91
|
isNumericKey(left) && isNumericKey(right) ? Number(left) - Number(right) : 0,
|
|
92
92
|
);
|
|
93
93
|
return [...(enumerated.length > 0 ? [`{${enumerated.join(", ")}}`] : []), ...others]
|
|
94
|
-
.map((domain,
|
|
94
|
+
.map((domain, _index, domains) => (domains.length > 1 ? wrap(domain) : domain))
|
|
95
95
|
.join(" \\cup ");
|
|
96
96
|
}
|
|
97
97
|
const literal = getLiteral(type, context);
|
package/src/values.ts
CHANGED
|
@@ -231,7 +231,7 @@ export const isModelValue = (value: Value): value is ModelValue =>
|
|
|
231
231
|
export const isEnumeratedSet = (value: Value): value is SetValue | MixedSetValue =>
|
|
232
232
|
typeof value === "object" && (value.kind === "Set" || value.kind === "MixedSet");
|
|
233
233
|
|
|
234
|
-
|
|
234
|
+
const describeKind = (value: Value) => {
|
|
235
235
|
if (typeof value === "boolean") return "boolean";
|
|
236
236
|
if (typeof value === "number") return "integer";
|
|
237
237
|
if (typeof value === "string") return "string";
|
|
@@ -266,8 +266,19 @@ export const getPrintedPairs = (functionValue: FunctionValue): [Value, Value][]
|
|
|
266
266
|
? functionValue.domain.map((key, index) => [key, functionValue.range[index]])
|
|
267
267
|
: getWrittenPairs(functionValue);
|
|
268
268
|
|
|
269
|
-
export const createWrittenRecord = (
|
|
270
|
-
|
|
269
|
+
export const createWrittenRecord = (
|
|
270
|
+
names: Value[],
|
|
271
|
+
writtenIndexes: number[],
|
|
272
|
+
writtenRange: Value[],
|
|
273
|
+
writtenNames: Value[],
|
|
274
|
+
) =>
|
|
275
|
+
setWrittenOrder(
|
|
276
|
+
createSortedRecord(
|
|
277
|
+
names,
|
|
278
|
+
writtenIndexes.map((index) => writtenRange[index]),
|
|
279
|
+
),
|
|
280
|
+
writtenNames,
|
|
281
|
+
);
|
|
271
282
|
|
|
272
283
|
const forgetWrittenOrder = (value: Value): void => {
|
|
273
284
|
if (typeof value !== "object" || (value.kind !== "Function" && value.kind !== "Set")) return;
|
|
@@ -2311,12 +2322,9 @@ export const toFiniteFunction = (value: Value): FunctionValue => {
|
|
|
2311
2322
|
throw new TlaEvaluationError("The domains of formal parameters must be enumerable.");
|
|
2312
2323
|
}
|
|
2313
2324
|
const domain = getFunctionDomain(value.domain);
|
|
2314
|
-
value.enumerated =
|
|
2315
|
-
|
|
2316
|
-
|
|
2317
|
-
domain.map((key) => value.apply(key)),
|
|
2318
|
-
),
|
|
2319
|
-
getFunctionClass(value),
|
|
2325
|
+
value.enumerated = createSortedFunction(
|
|
2326
|
+
domain,
|
|
2327
|
+
domain.map((key) => value.apply(key)),
|
|
2320
2328
|
);
|
|
2321
2329
|
return value.enumerated;
|
|
2322
2330
|
}
|
|
@@ -2897,56 +2905,67 @@ const toPrintedFunction = (value: LazyFunctionValue) => {
|
|
|
2897
2905
|
|
|
2898
2906
|
export const formatNormalizedCopies = (values: Value[]) => {
|
|
2899
2907
|
const markedSets: SetValue[] = [];
|
|
2900
|
-
const
|
|
2908
|
+
const writtenFunctions: [FunctionValue, Value[]][] = [];
|
|
2909
|
+
const normalize = (value: Value, isWrittenOrderKept: boolean): void => {
|
|
2901
2910
|
if (typeof value !== "object") return;
|
|
2911
|
+
const normalizeInner = (inner: Value) => normalize(inner, isWrittenOrderKept);
|
|
2902
2912
|
switch (value.kind) {
|
|
2903
2913
|
case "Set":
|
|
2904
|
-
value.elements.forEach(
|
|
2914
|
+
value.elements.forEach(normalizeInner);
|
|
2905
2915
|
if (value.isNormalized) return;
|
|
2906
2916
|
value.isNormalized = true;
|
|
2907
2917
|
markedSets.push(value);
|
|
2908
2918
|
return;
|
|
2909
2919
|
case "MixedSet":
|
|
2910
|
-
value.elements.forEach(
|
|
2920
|
+
value.elements.forEach(normalizeInner);
|
|
2911
2921
|
toFiniteSet(value);
|
|
2912
2922
|
return;
|
|
2913
|
-
case "Function":
|
|
2914
|
-
value
|
|
2923
|
+
case "Function": {
|
|
2924
|
+
const isRangeWrittenOrderKept = isWrittenOrderKept || getFunctionClass(value) === "lambda";
|
|
2925
|
+
value.range.forEach((inner) => normalize(inner, isRangeWrittenOrderKept));
|
|
2926
|
+
if (isWrittenOrderKept || value.writtenKeys === undefined) return;
|
|
2927
|
+
writtenFunctions.push([value, value.writtenKeys]);
|
|
2928
|
+
value.writtenKeys = undefined;
|
|
2915
2929
|
return;
|
|
2930
|
+
}
|
|
2916
2931
|
case "LazyFunction":
|
|
2917
|
-
|
|
2932
|
+
if (value.enumerated) normalize(value.enumerated, true);
|
|
2933
|
+
else normalizeInner(value.domain);
|
|
2918
2934
|
return;
|
|
2919
2935
|
case "SetOperation":
|
|
2920
|
-
|
|
2921
|
-
|
|
2936
|
+
normalizeInner(value.left);
|
|
2937
|
+
normalizeInner(value.right);
|
|
2922
2938
|
return;
|
|
2923
2939
|
case "FunctionSet":
|
|
2924
|
-
|
|
2925
|
-
|
|
2940
|
+
normalizeInner(value.domain);
|
|
2941
|
+
normalizeInner(value.range);
|
|
2926
2942
|
return;
|
|
2927
2943
|
case "RecordSet":
|
|
2928
|
-
value.sets.forEach(
|
|
2944
|
+
value.sets.forEach(normalizeInner);
|
|
2929
2945
|
return;
|
|
2930
2946
|
case "ProductSet":
|
|
2931
|
-
value.factors.forEach(
|
|
2947
|
+
value.factors.forEach(normalizeInner);
|
|
2932
2948
|
return;
|
|
2933
2949
|
case "Subset":
|
|
2934
2950
|
case "Union":
|
|
2935
2951
|
case "FilteredSet":
|
|
2936
2952
|
case "SequenceSet":
|
|
2937
|
-
|
|
2953
|
+
normalizeInner(value.base);
|
|
2938
2954
|
return;
|
|
2939
2955
|
default:
|
|
2940
2956
|
return;
|
|
2941
2957
|
}
|
|
2942
2958
|
};
|
|
2943
2959
|
try {
|
|
2944
|
-
values.forEach(normalize);
|
|
2960
|
+
values.forEach((value) => normalize(value, false));
|
|
2945
2961
|
return values.map((value) => formatValue(value, true, true));
|
|
2946
2962
|
} finally {
|
|
2947
2963
|
markedSets.forEach((set) => {
|
|
2948
2964
|
set.isNormalized = false;
|
|
2949
2965
|
});
|
|
2966
|
+
writtenFunctions.forEach((entry) => {
|
|
2967
|
+
entry[0].writtenKeys = entry[1];
|
|
2968
|
+
});
|
|
2950
2969
|
}
|
|
2951
2970
|
};
|
|
2952
2971
|
|
|
@@ -3092,10 +3111,10 @@ export const formatState = (state: Record<string, Value>, previous?: Record<stri
|
|
|
3092
3111
|
);
|
|
3093
3112
|
}
|
|
3094
3113
|
return entries
|
|
3095
|
-
.filter((
|
|
3096
|
-
.filter((
|
|
3097
|
-
.map((
|
|
3098
|
-
const text = formatJava(format, [
|
|
3114
|
+
.filter((entry) => !(isFormatted && entry[0] === "_format"))
|
|
3115
|
+
.filter((entry) => !previous || !isUnchanged(previous[entry[0]], entry[1]))
|
|
3116
|
+
.map((entry) => {
|
|
3117
|
+
const text = formatJava(format, [entry[0], prettyPrint(formatValue(entry[1]))]);
|
|
3099
3118
|
if (text === undefined) {
|
|
3100
3119
|
throw new TlaAliasFormatError(
|
|
3101
3120
|
`The _format field of the ALIAS ${alias} is ${formatValue(format)}, but it must format two strings, the name and the value of a field.`,
|