tla-ts 0.0.10-dev.09e53c2a6 → 0.0.10-dev.1ebc153bd
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 +624 -187
- 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 +265 -94
- 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/dependencies.ts
CHANGED
|
@@ -29,6 +29,7 @@ const VARIABLE_LEVEL_FLAGS = 32;
|
|
|
29
29
|
const ACTION_LEVEL_FLAGS = VARIABLE_LEVEL_FLAGS | 64;
|
|
30
30
|
const TEMPORAL_LEVEL_FLAGS = ACTION_LEVEL_FLAGS | 128;
|
|
31
31
|
const RANDOM = 256;
|
|
32
|
+
const ABOVE_CONSTANT_BOUND = 512;
|
|
32
33
|
|
|
33
34
|
const ACTION_KINDS = new Set<Expression["kind"]>([
|
|
34
35
|
"Prime",
|
|
@@ -80,6 +81,7 @@ interface Edge {
|
|
|
80
81
|
callee: Definition;
|
|
81
82
|
isOverridden: boolean;
|
|
82
83
|
isLevelCounted: boolean;
|
|
84
|
+
isOperatorArgument: boolean;
|
|
83
85
|
}
|
|
84
86
|
|
|
85
87
|
const collectLocalFacts = (
|
|
@@ -104,20 +106,27 @@ const collectLocalFacts = (
|
|
|
104
106
|
}
|
|
105
107
|
return undefined;
|
|
106
108
|
};
|
|
107
|
-
const visit = (node: Expression, isLevelCounted: boolean) => {
|
|
109
|
+
const visit = (node: Expression, isLevelCounted: boolean, isOperatorArgument: boolean) => {
|
|
108
110
|
const kind = node.kind;
|
|
111
|
+
// TLC's getLevelBound takes an operator argument for a constant.
|
|
112
|
+
const nonconstantFlags = isOperatorArgument ? NONCONSTANT : NONCONSTANT | ABOVE_CONSTANT_BOUND;
|
|
109
113
|
if (
|
|
110
114
|
NONCONSTANT_KINDS.has(kind) ||
|
|
111
115
|
(kind === "UnboundedQuantifier" && node.isTemporal === true) ||
|
|
112
116
|
(kind === "Apply" && NONCONSTANT_OPERATORS.has(node.operator))
|
|
113
117
|
) {
|
|
114
|
-
row[0] |=
|
|
118
|
+
row[0] |= nonconstantFlags;
|
|
115
119
|
}
|
|
116
120
|
if (NONCONSTANT_KINDS.has(kind)) row[0] |= READS_IMPURE;
|
|
117
121
|
const ownLevelFlags = getOwnLevelFlags(node);
|
|
118
122
|
if (isLevelCounted && ownLevelFlags !== undefined) row[0] |= ownLevelFlags;
|
|
119
123
|
const isInnerLevelCounted = isLevelCounted && ownLevelFlags === undefined;
|
|
120
124
|
const name = getReferencedName(node);
|
|
125
|
+
// TLC's getLevelBound takes a parameter named like a variable for that variable.
|
|
126
|
+
if (name !== undefined && isLocallyResolved(node) && environment.variableIndex.has(name)) {
|
|
127
|
+
if (!isOperatorArgument) row[0] |= ABOVE_CONSTANT_BOUND;
|
|
128
|
+
if (isInnerLevelCounted) row[0] |= VARIABLE_LEVEL_FLAGS;
|
|
129
|
+
}
|
|
121
130
|
if (name !== undefined && !isLocallyResolved(node)) {
|
|
122
131
|
const target = environment.substitutions.get(name) ?? name;
|
|
123
132
|
const definition = environment.definitions.get(target);
|
|
@@ -128,14 +137,24 @@ const collectLocalFacts = (
|
|
|
128
137
|
environment.builtins.get(name)?.isStateLevel ||
|
|
129
138
|
(definition && environment.variableIndex.has(definition.name))
|
|
130
139
|
) {
|
|
131
|
-
row[0] |=
|
|
140
|
+
row[0] |= nonconstantFlags;
|
|
132
141
|
}
|
|
133
142
|
if (variableIndex !== undefined) {
|
|
134
143
|
if (isInnerLevelCounted) row[0] |= VARIABLE_LEVEL_FLAGS;
|
|
135
144
|
if (!isOverridden) row[1 + (variableIndex >>> 5)] |= 1 << (variableIndex & 31);
|
|
136
145
|
}
|
|
137
146
|
if (definition) {
|
|
138
|
-
edges.push({
|
|
147
|
+
edges.push({
|
|
148
|
+
callee: definition,
|
|
149
|
+
isOverridden,
|
|
150
|
+
isLevelCounted: isInnerLevelCounted,
|
|
151
|
+
isOperatorArgument:
|
|
152
|
+
isOperatorArgument ||
|
|
153
|
+
kind === "OperatorReference" ||
|
|
154
|
+
(kind === "Identifier" &&
|
|
155
|
+
definition.kind === "Operator" &&
|
|
156
|
+
definition.params.length > 0),
|
|
157
|
+
});
|
|
139
158
|
} else {
|
|
140
159
|
if (isImpureBuiltin(name, environment)) {
|
|
141
160
|
row[0] |= IMPURE | (name === "Assert" ? 0 : REPEATED_EFFECT);
|
|
@@ -155,9 +174,11 @@ const collectLocalFacts = (
|
|
|
155
174
|
}
|
|
156
175
|
}
|
|
157
176
|
}
|
|
158
|
-
getChildren(node).forEach((child) =>
|
|
177
|
+
getChildren(node).forEach((child) =>
|
|
178
|
+
visit(child, isInnerLevelCounted, isOperatorArgument || kind === "Lambda"),
|
|
179
|
+
);
|
|
159
180
|
};
|
|
160
|
-
expressions.forEach((expression) => visit(expression, true));
|
|
181
|
+
expressions.forEach((expression) => visit(expression, true, false));
|
|
161
182
|
return { row, edges };
|
|
162
183
|
};
|
|
163
184
|
|
|
@@ -230,9 +251,10 @@ const closeRows = (local: Uint32Array, words: number, edges: Int32Array[], mask:
|
|
|
230
251
|
|
|
231
252
|
const PURITY_MASK = IMPURE | REPEATED_EFFECT | STREAMED | RANDOM;
|
|
232
253
|
const READ_MASK = NONCONSTANT | READS_IMPURE;
|
|
254
|
+
const STARTUP_MASK = NONCONSTANT | ABOVE_CONSTANT_BOUND;
|
|
233
255
|
|
|
234
256
|
const isEvaluatedOnce = (definition: Definition, flags: number) =>
|
|
235
|
-
definition.kind === "Operator" && definition.params.length === 0 && (flags &
|
|
257
|
+
definition.kind === "Operator" && definition.params.length === 0 && (flags & STARTUP_MASK) === 0;
|
|
236
258
|
|
|
237
259
|
export const createDefinitionFacts = (environment: DefinitionNames): DefinitionFacts => {
|
|
238
260
|
const definitions = [...new Set(environment.definitions.values())];
|
|
@@ -256,18 +278,32 @@ export const createDefinitionFacts = (environment: DefinitionNames): DefinitionF
|
|
|
256
278
|
new Int32Array(own.filter((edge) => !edge.isOverridden && edge.isLevelCounted).map(getId)),
|
|
257
279
|
);
|
|
258
280
|
const levels = closeRows(local, words, levelEdges, TEMPORAL_LEVEL_FLAGS);
|
|
281
|
+
const startupEdges = edges.map(
|
|
282
|
+
(own) =>
|
|
283
|
+
new Int32Array(
|
|
284
|
+
own.filter((edge) => !edge.isOverridden && !edge.isOperatorArgument).map(getId),
|
|
285
|
+
),
|
|
286
|
+
);
|
|
287
|
+
const startup = closeRows(local, words, startupEdges, ABOVE_CONSTANT_BOUND);
|
|
259
288
|
const purityEdges = edges.map(
|
|
260
289
|
(own) =>
|
|
261
290
|
new Int32Array(
|
|
262
291
|
own
|
|
263
292
|
.map(getId)
|
|
264
|
-
.filter(
|
|
293
|
+
.filter(
|
|
294
|
+
(callee) =>
|
|
295
|
+
!isEvaluatedOnce(
|
|
296
|
+
definitions[callee],
|
|
297
|
+
reads[callee * words] | startup[callee * words],
|
|
298
|
+
),
|
|
299
|
+
),
|
|
265
300
|
),
|
|
266
301
|
);
|
|
267
302
|
const purity = closeRows(localImpurity, words, purityEdges, PURITY_MASK);
|
|
268
303
|
const rows = reads.map((word, position) =>
|
|
269
304
|
position % words === 0
|
|
270
305
|
? (word & READ_MASK) |
|
|
306
|
+
(startup[position] & ABOVE_CONSTANT_BOUND) |
|
|
271
307
|
(levels[position] & TEMPORAL_LEVEL_FLAGS) |
|
|
272
308
|
(purity[position] & PURITY_MASK)
|
|
273
309
|
: word,
|
|
@@ -291,6 +327,7 @@ const getExpressionsRow = (expressions: Expression[], environment: Environment)
|
|
|
291
327
|
const callee = getRow(edge.callee, environment);
|
|
292
328
|
if (!edge.isOverridden) {
|
|
293
329
|
row[0] |= callee[0] & READ_MASK;
|
|
330
|
+
if (!edge.isOperatorArgument) row[0] |= callee[0] & ABOVE_CONSTANT_BOUND;
|
|
294
331
|
if (edge.isLevelCounted) row[0] |= callee[0] & TEMPORAL_LEVEL_FLAGS;
|
|
295
332
|
for (let word = 1; word < words; word++) row[word] |= callee[word];
|
|
296
333
|
}
|
|
@@ -300,7 +337,10 @@ const getExpressionsRow = (expressions: Expression[], environment: Environment)
|
|
|
300
337
|
};
|
|
301
338
|
|
|
302
339
|
export const isConstantLevel = (definition: Definition, environment: Environment) =>
|
|
303
|
-
(getRow(definition, environment)[0] &
|
|
340
|
+
(getRow(definition, environment)[0] & STARTUP_MASK) === 0;
|
|
341
|
+
|
|
342
|
+
export const isEvaluatedAtStartup = (definition: Definition, environment: Environment) =>
|
|
343
|
+
(getRow(definition, environment)[0] & ABOVE_CONSTANT_BOUND) === 0;
|
|
304
344
|
|
|
305
345
|
const EFFECT_FLAGS = {
|
|
306
346
|
any: IMPURE,
|
package/src/dfid.ts
CHANGED
|
@@ -15,7 +15,7 @@ import { EXIT_STATUS, getMessageExitStatus, withLivenessExitCode } from "./exit-
|
|
|
15
15
|
import { createLivenessChecker } from "./liveness-checker";
|
|
16
16
|
import { getIncompleteSuccessorMessage, prepareSearch, reportAssumptionViolation } from "./search";
|
|
17
17
|
import type { SpecAction } from "./spec-description";
|
|
18
|
-
import { forEachInitialState, forEachSuccessor } from "./successors";
|
|
18
|
+
import { forEachInitialState, forEachSuccessor, getSuccessors } from "./successors";
|
|
19
19
|
import {
|
|
20
20
|
formatNestedMessage,
|
|
21
21
|
formatTlcDate,
|
|
@@ -28,7 +28,7 @@ import {
|
|
|
28
28
|
import { getTlcFingerprint } from "./tlc/fingerprint";
|
|
29
29
|
import { replaySuccessors } from "./tlc/replay";
|
|
30
30
|
import { getOptimisticProbability, getActualProbability } from "./tlc/summary";
|
|
31
|
-
import { createModelValue, formatState, getSetBound, type Value } from "./values";
|
|
31
|
+
import { createModelValue, formatState, getSetBound, isSameValue, type Value } from "./values";
|
|
32
32
|
|
|
33
33
|
export interface DepthFirstOptions extends CheckOptions {
|
|
34
34
|
maxDepth: number;
|
|
@@ -165,6 +165,13 @@ export const checkDepthFirst = (options: DepthFirstOptions): number => {
|
|
|
165
165
|
if (assumptionStatus !== undefined) return assumptionStatus;
|
|
166
166
|
|
|
167
167
|
const nextActions = prepared.getDescription().actions;
|
|
168
|
+
// Deviation from TLC: TLCExt#pickSuccessor casts the DFID checker to ModelChecker and fails, so tla-ts asks as model checking does.
|
|
169
|
+
runtime.getSuccessorAction = (state, next) =>
|
|
170
|
+
nextActions.find((action) =>
|
|
171
|
+
getSuccessors(action.expression, state, environment, action.scope).some((successor) =>
|
|
172
|
+
successor.state.every((value, index) => isSameValue(value, next[index])),
|
|
173
|
+
),
|
|
174
|
+
);
|
|
168
175
|
const statuses = new Map<bigint, number>();
|
|
169
176
|
const fingerprintSet = { level: 1, leveled: 0, buckets: INITIAL_BUCKETS };
|
|
170
177
|
const setStatus = (fingerprint: bigint, status: number) => {
|
package/src/environment.ts
CHANGED
|
@@ -100,6 +100,12 @@ interface EnvironmentOptions {
|
|
|
100
100
|
version?: TlcVersion;
|
|
101
101
|
moduleOperators?: ModuleOperator[];
|
|
102
102
|
readLine?: () => string | undefined;
|
|
103
|
+
runtimeInvariants?: RuntimeInvariant[];
|
|
104
|
+
}
|
|
105
|
+
|
|
106
|
+
export interface RuntimeInvariant {
|
|
107
|
+
name: string;
|
|
108
|
+
module: string | undefined;
|
|
103
109
|
}
|
|
104
110
|
|
|
105
111
|
export interface ResolvedModuleOperator extends ModuleOperator {
|
|
@@ -114,6 +120,7 @@ export interface Specification {
|
|
|
114
120
|
startupDefinitions: Definition[];
|
|
115
121
|
javaOverrides: JavaOverride[];
|
|
116
122
|
moduleOperators: ResolvedModuleOperator[];
|
|
123
|
+
runtimeInvariants: RuntimeInvariant[];
|
|
117
124
|
rootName: string;
|
|
118
125
|
}
|
|
119
126
|
|
|
@@ -498,7 +505,7 @@ export const createEnvironment = (
|
|
|
498
505
|
const instantiation = createInstantiation({
|
|
499
506
|
params,
|
|
500
507
|
substitutions: new Map(
|
|
501
|
-
[...substitutions].map((
|
|
508
|
+
[...substitutions].map((entry) => [entry[0], renameLocals(entry[1], renamed)]),
|
|
502
509
|
),
|
|
503
510
|
variables: new Set(linked.variables),
|
|
504
511
|
getDefinition: (key) => definitions.get(key),
|
|
@@ -541,9 +548,14 @@ export const createEnvironment = (
|
|
|
541
548
|
instance.name === undefined
|
|
542
549
|
? standardSymbols
|
|
543
550
|
: new Map(
|
|
544
|
-
[...standardSymbols].map((
|
|
545
|
-
`${instance.name}!${
|
|
546
|
-
{
|
|
551
|
+
[...standardSymbols].map((entry) => [
|
|
552
|
+
`${instance.name}!${entry[0]}`,
|
|
553
|
+
{
|
|
554
|
+
key: entry[1].key,
|
|
555
|
+
arity: entry[1].arity,
|
|
556
|
+
params: entry[1].params,
|
|
557
|
+
kind: entry[1].kind,
|
|
558
|
+
},
|
|
547
559
|
]),
|
|
548
560
|
);
|
|
549
561
|
|
|
@@ -556,32 +568,34 @@ export const createEnvironment = (
|
|
|
556
568
|
const declared = new Set(declarations.map((declaration) => declaration.name));
|
|
557
569
|
return new Map(
|
|
558
570
|
[...exported]
|
|
559
|
-
.filter((
|
|
560
|
-
.map((
|
|
571
|
+
.filter((entry) => !declared.has(entry[0]))
|
|
572
|
+
.map((entry): [string, ModuleSymbol] => {
|
|
561
573
|
if (instance.name === undefined) {
|
|
562
574
|
return [
|
|
563
|
-
|
|
575
|
+
entry[0],
|
|
564
576
|
{
|
|
565
|
-
key: getKey(
|
|
566
|
-
arity:
|
|
567
|
-
params:
|
|
568
|
-
kind:
|
|
577
|
+
key: getKey(entry[1].key, entry[0]),
|
|
578
|
+
arity: entry[1].arity,
|
|
579
|
+
params: entry[1].params,
|
|
580
|
+
kind: entry[1].kind,
|
|
569
581
|
range:
|
|
570
|
-
parameterized.get(
|
|
582
|
+
parameterized.get(entry[1].key) === true
|
|
583
|
+
? instance.location.range
|
|
584
|
+
: entry[1].range,
|
|
571
585
|
},
|
|
572
586
|
];
|
|
573
587
|
}
|
|
574
|
-
const qualified = `${instance.name}!${
|
|
588
|
+
const qualified = `${instance.name}!${entry[0]}`;
|
|
575
589
|
return [
|
|
576
590
|
qualified,
|
|
577
591
|
{
|
|
578
|
-
key: getKey(
|
|
579
|
-
arity:
|
|
580
|
-
params:
|
|
592
|
+
key: getKey(entry[1].key, qualified),
|
|
593
|
+
arity: entry[1].arity + instance.params.length,
|
|
594
|
+
params: entry[1].params && [
|
|
581
595
|
...instance.params.map((param) => param.arity),
|
|
582
|
-
...
|
|
596
|
+
...entry[1].params,
|
|
583
597
|
],
|
|
584
|
-
kind:
|
|
598
|
+
kind: entry[1].kind,
|
|
585
599
|
},
|
|
586
600
|
];
|
|
587
601
|
}),
|
|
@@ -629,11 +643,11 @@ export const createEnvironment = (
|
|
|
629
643
|
const standardSymbols = nested ? undefined : getStandardSymbols(instance.module);
|
|
630
644
|
if (standardSymbols) {
|
|
631
645
|
if (instance.name === undefined) return [];
|
|
632
|
-
return [...standardSymbols].map((
|
|
633
|
-
const forwarded = createArgumentParams(
|
|
646
|
+
return [...standardSymbols].map((entry) => {
|
|
647
|
+
const forwarded = createArgumentParams(entry[1].arity, entry[1].params);
|
|
634
648
|
return createLocalAlias(
|
|
635
|
-
`${instance.name}!${
|
|
636
|
-
|
|
649
|
+
`${instance.name}!${entry[0]}`,
|
|
650
|
+
entry[1].key,
|
|
637
651
|
[...instance.params, ...forwarded],
|
|
638
652
|
forwarded,
|
|
639
653
|
location,
|
|
@@ -714,16 +728,16 @@ export const createEnvironment = (
|
|
|
714
728
|
});
|
|
715
729
|
const declared = new Set(declarations.map((declaration) => declaration.name));
|
|
716
730
|
const aliases = [...linked.exported]
|
|
717
|
-
.filter((
|
|
718
|
-
.map((
|
|
719
|
-
const key = instantiation.getKey(
|
|
720
|
-
const ownParams = createArgumentParams(
|
|
731
|
+
.filter((entry) => !declared.has(entry[0]))
|
|
732
|
+
.map((entry) => {
|
|
733
|
+
const key = instantiation.getKey(entry[1].key);
|
|
734
|
+
const ownParams = createArgumentParams(entry[1].arity, entry[1].params);
|
|
721
735
|
const params = [...instance.params, ...ownParams];
|
|
722
736
|
return createLocalAlias(
|
|
723
|
-
instance.name === undefined ?
|
|
737
|
+
instance.name === undefined ? entry[0] : `${instance.name}!${entry[0]}`,
|
|
724
738
|
key,
|
|
725
739
|
params,
|
|
726
|
-
key ===
|
|
740
|
+
key === entry[1].key ? ownParams : params,
|
|
727
741
|
location,
|
|
728
742
|
);
|
|
729
743
|
});
|
|
@@ -731,9 +745,9 @@ export const createEnvironment = (
|
|
|
731
745
|
};
|
|
732
746
|
|
|
733
747
|
const getAvailableDefinitions = (visible: Symbols) =>
|
|
734
|
-
[...visible].flatMap((
|
|
735
|
-
const definition = definitions.get(
|
|
736
|
-
return definition ? [{ ...definition, name }] : [];
|
|
748
|
+
[...visible].flatMap((entry) => {
|
|
749
|
+
const definition = definitions.get(entry[1].key);
|
|
750
|
+
return definition ? [{ ...definition, name: entry[0] }] : [];
|
|
737
751
|
});
|
|
738
752
|
|
|
739
753
|
const javaOverrides = new Map<string, JavaOverride[]>();
|
|
@@ -902,7 +916,7 @@ export const createEnvironment = (
|
|
|
902
916
|
getDefinitionSymbol(definition),
|
|
903
917
|
]),
|
|
904
918
|
].reduce(
|
|
905
|
-
(symbols,
|
|
919
|
+
(symbols, entry) => (symbols.has(entry[0]) ? symbols : symbols.set(entry[0], entry[1])),
|
|
906
920
|
new Map(visible),
|
|
907
921
|
);
|
|
908
922
|
const linkNested = (nested: Module) => {
|
|
@@ -1031,6 +1045,15 @@ export const createEnvironment = (
|
|
|
1031
1045
|
);
|
|
1032
1046
|
linkOrder.push(...linkOrder.splice(linkOrder.indexOf(linkedRoot), 1));
|
|
1033
1047
|
if (warnings.length > 0 && !options.isSanyReported) options.print(formatSanyWarnings(warnings));
|
|
1048
|
+
const runtimeInvariants = options.runtimeInvariants ?? [];
|
|
1049
|
+
runtimeInvariants.forEach((invariant) => {
|
|
1050
|
+
if (invariant.module === undefined) return;
|
|
1051
|
+
linkedModules.set(root.name, linkedRoot);
|
|
1052
|
+
const linked = getLinkedModule(invariant.module, root.name);
|
|
1053
|
+
linkOrder.splice(linkOrder.indexOf(linked), 1);
|
|
1054
|
+
const definition = definitions.get(linked.visible.get(invariant.name)?.key ?? invariant.name);
|
|
1055
|
+
if (definition) definitions.set(invariant.name, definition);
|
|
1056
|
+
});
|
|
1034
1057
|
linkedRoot.visible.forEach((symbol, name) => {
|
|
1035
1058
|
const definition = definitions.get(symbol.key);
|
|
1036
1059
|
if (definition && symbol.key !== name) definitions.set(name, definition);
|
|
@@ -1057,7 +1080,7 @@ export const createEnvironment = (
|
|
|
1057
1080
|
root: linkedRoot,
|
|
1058
1081
|
moduleSymbols: new Map([
|
|
1059
1082
|
...standardExports,
|
|
1060
|
-
...[...linkedModules].map((
|
|
1083
|
+
...[...linkedModules].map((entry): [string, Symbols] => [entry[0], entry[1].visible]),
|
|
1061
1084
|
[root.name, linkedRoot.visible],
|
|
1062
1085
|
]),
|
|
1063
1086
|
definitions,
|
|
@@ -1171,6 +1194,7 @@ export const createEnvironment = (
|
|
|
1171
1194
|
),
|
|
1172
1195
|
javaOverrides: linkOrder.flatMap((linked) => javaOverrides.get(linked.module.name) ?? []),
|
|
1173
1196
|
moduleOperators,
|
|
1197
|
+
runtimeInvariants,
|
|
1174
1198
|
rootName: root.name,
|
|
1175
1199
|
};
|
|
1176
1200
|
};
|
package/src/errors.ts
CHANGED
|
@@ -320,6 +320,13 @@ export class SmtTacticError extends TlaError {
|
|
|
320
320
|
}
|
|
321
321
|
}
|
|
322
322
|
|
|
323
|
+
export class SmtDefaultError extends TlaError {
|
|
324
|
+
constructor(message: string) {
|
|
325
|
+
super(message);
|
|
326
|
+
this.name = "SmtDefaultError";
|
|
327
|
+
}
|
|
328
|
+
}
|
|
329
|
+
|
|
323
330
|
export class SmtInvariantError extends TlaError {
|
|
324
331
|
constructor(message: string) {
|
|
325
332
|
super(message);
|
package/src/evaluate.ts
CHANGED
|
@@ -26,7 +26,7 @@ import { countCoverage, getCoverageNode, runAtCoverageNode, type Coverage } from
|
|
|
26
26
|
import { MESSAGE_CODE } from "./tlc/messages";
|
|
27
27
|
import type { CheckerRuntime } from "./runtime";
|
|
28
28
|
import {
|
|
29
|
-
|
|
29
|
+
isEvaluatedAtStartup,
|
|
30
30
|
isImpureDefinition,
|
|
31
31
|
isNonconstant,
|
|
32
32
|
type DefinitionFacts,
|
|
@@ -615,12 +615,16 @@ export const bindLazyArguments = (
|
|
|
615
615
|
typeof value.domain === "object" && value.domain.kind === "ProductSet"
|
|
616
616
|
? value.domain.factors
|
|
617
617
|
: [];
|
|
618
|
-
|
|
618
|
+
if (elements === undefined) {
|
|
619
|
+
throw new TlaEvaluationError(
|
|
620
|
+
`Attempted to apply a function to an argument not in its domain.\n${describeRange(expression.function)}`,
|
|
621
|
+
);
|
|
622
|
+
}
|
|
623
|
+
// Deviation from TLC: Tool#getFcnContext indexes past an argument tuple shorter than the bounds and ignores a longer one.
|
|
619
624
|
const createListError = () =>
|
|
620
625
|
new TlaEvaluationError(
|
|
621
626
|
`In applying the function\n${prettyPrint(formatValue(value))},\nthe argument list is:\n${prettyPrint(formatValue(argument))}\nwhich does not match its formal parameter.\n`,
|
|
622
627
|
);
|
|
623
|
-
if (elements === undefined) throw createListError();
|
|
624
628
|
bounds.forEach((bound, index) => {
|
|
625
629
|
if (index >= elements.length) throw createListError();
|
|
626
630
|
const element = elements[index];
|
|
@@ -669,7 +673,7 @@ const getLazyFunctionTemplate = (bounds: Bound[], body: Expression) => {
|
|
|
669
673
|
},
|
|
670
674
|
],
|
|
671
675
|
),
|
|
672
|
-
body:
|
|
676
|
+
body: describeNode(body),
|
|
673
677
|
};
|
|
674
678
|
};
|
|
675
679
|
|
|
@@ -817,7 +821,7 @@ export const evaluateStartupDefinitions = (definitions: Definition[], environmen
|
|
|
817
821
|
if (definition.kind === "Operator" && definition.params.length > 0) return;
|
|
818
822
|
const name = definition.name;
|
|
819
823
|
if (environment.constants.has(name) || environment.substitutions.has(name)) return;
|
|
820
|
-
if (!
|
|
824
|
+
if (!isEvaluatedAtStartup(definition, environment)) return;
|
|
821
825
|
const definitionId = environment.facts.ids.get(definition);
|
|
822
826
|
if (definitionId === undefined || environment.startupValues[definitionId] !== undefined) return;
|
|
823
827
|
const context = { environment, scope: undefined, state: undefined, next: undefined };
|
|
@@ -969,6 +973,7 @@ const isOperatorArgument = (expression: Expression, context: Context) => {
|
|
|
969
973
|
return operator !== undefined && getArity(operator) > 0;
|
|
970
974
|
};
|
|
971
975
|
|
|
976
|
+
// Deviation from TLC: SymbolNodeValueLookupProvider#lookup takes an operator whose body is a literal for that literal, so a Java override rejects it as an argument.
|
|
972
977
|
const evaluateBuiltinArguments = (args: Expression[], context: Context) =>
|
|
973
978
|
args.map((arg) =>
|
|
974
979
|
isOperatorArgument(arg, context)
|
|
@@ -1177,7 +1182,9 @@ const evaluateLocalIdentifier = (name: string, expression: Expression, context:
|
|
|
1177
1182
|
}
|
|
1178
1183
|
const builtin = context.environment.builtins.get(name);
|
|
1179
1184
|
if (builtin?.arity === 0) return builtin.evaluate([], context);
|
|
1180
|
-
throw new TlaEvaluationError(
|
|
1185
|
+
throw new TlaEvaluationError(
|
|
1186
|
+
`In evaluation, the identifier ${name} is either undefined or not an operator.\n${describeRange(expression)}`,
|
|
1187
|
+
);
|
|
1181
1188
|
};
|
|
1182
1189
|
|
|
1183
1190
|
export const getReevaluatedDefinitions = (
|
|
@@ -1329,6 +1336,41 @@ export const createTracingEnvironment = (environment: Environment): Environment
|
|
|
1329
1336
|
},
|
|
1330
1337
|
});
|
|
1331
1338
|
|
|
1339
|
+
// TLC evaluates `a /\ b /\ c` as `(a /\ b) /\ c`, so its call stack holds each prefix.
|
|
1340
|
+
const compileTracedJunction = (
|
|
1341
|
+
expression: Expression & { kind: "And" | "Or" },
|
|
1342
|
+
operands: Evaluator[],
|
|
1343
|
+
callStack: CallStack | undefined,
|
|
1344
|
+
): Evaluator | undefined => {
|
|
1345
|
+
const range = expression.location.range;
|
|
1346
|
+
const prefixEnds = expression.prefixEnds;
|
|
1347
|
+
if (!callStack || expression.isBulleted || !range || !prefixEnds || operands.length < 3) {
|
|
1348
|
+
return undefined;
|
|
1349
|
+
}
|
|
1350
|
+
const prefixes = prefixEnds
|
|
1351
|
+
.slice(0, operands.length - 2)
|
|
1352
|
+
.map((end) => ({
|
|
1353
|
+
...expression,
|
|
1354
|
+
location: { ...expression.location, range: { ...range, end } },
|
|
1355
|
+
}))
|
|
1356
|
+
.reverse();
|
|
1357
|
+
const isAnd = expression.kind === "And";
|
|
1358
|
+
return (context) => {
|
|
1359
|
+
callStack.expressions.push(...prefixes);
|
|
1360
|
+
for (let index = 0; index < operands.length; index++) {
|
|
1361
|
+
if (index >= 2 && !callStack.isFrozen) callStack.expressions.pop();
|
|
1362
|
+
const value = operands[index](context);
|
|
1363
|
+
if (typeof value !== "boolean") throw createJunctionError(expression, index, value);
|
|
1364
|
+
if (value !== isAnd) {
|
|
1365
|
+
if (!callStack.isFrozen)
|
|
1366
|
+
callStack.expressions.length -= prefixes.length - Math.max(index - 1, 0);
|
|
1367
|
+
return value;
|
|
1368
|
+
}
|
|
1369
|
+
}
|
|
1370
|
+
return isAnd;
|
|
1371
|
+
};
|
|
1372
|
+
};
|
|
1373
|
+
|
|
1332
1374
|
const traceFrames =
|
|
1333
1375
|
(
|
|
1334
1376
|
expression: Expression,
|
|
@@ -1547,6 +1589,7 @@ const compileApply = (
|
|
|
1547
1589
|
return (context) => domain(operand(context));
|
|
1548
1590
|
}
|
|
1549
1591
|
if (global?.kind === "Builtin" && global.name === "TLCEval" && args.length === 1) {
|
|
1592
|
+
// Deviation from TLC: TLCEval#tlcEval evaluates an argument SANY takes for constant, such as Print(v, TRUE), in an empty state.
|
|
1550
1593
|
const isCached =
|
|
1551
1594
|
!contextualApplications.has(expression) && !isNonconstant(args[0], environment);
|
|
1552
1595
|
return (context) =>
|
|
@@ -1864,12 +1907,11 @@ export const getLazyFilter = (
|
|
|
1864
1907
|
) => {
|
|
1865
1908
|
const predicate = getEvaluator(expression.predicate, environment);
|
|
1866
1909
|
const pattern = expression.bound.pattern;
|
|
1867
|
-
const
|
|
1868
|
-
const source = range && {
|
|
1910
|
+
const predicateNode = describeNode(expression.predicate);
|
|
1911
|
+
const source = expression.predicate.location.range && {
|
|
1869
1912
|
names: pattern.kind === "Name" ? pattern.name : pattern.names.join(", "),
|
|
1870
|
-
predicate:
|
|
1913
|
+
predicate: predicateNode,
|
|
1871
1914
|
};
|
|
1872
|
-
const predicateNode = describeNode(expression.predicate);
|
|
1873
1915
|
const coverage = environment.coverage;
|
|
1874
1916
|
const testCovered = (node: number, isMember: boolean, test: () => Value) => {
|
|
1875
1917
|
if (!coverage || node === -1) return test();
|
|
@@ -2035,20 +2077,21 @@ export const hasDuplicateFields = (sortedFields: RecordField[]) =>
|
|
|
2035
2077
|
|
|
2036
2078
|
const compileRecord = (recordFields: RecordField[], environment: Environment): Evaluator => {
|
|
2037
2079
|
const fields = getSortedFields(recordFields);
|
|
2038
|
-
const
|
|
2039
|
-
|
|
2040
|
-
if (hasDuplicates) {
|
|
2080
|
+
const values = recordFields.map((field) => getEvaluator(field.value, environment));
|
|
2081
|
+
if (hasDuplicateFields(fields)) {
|
|
2041
2082
|
return (context) =>
|
|
2042
2083
|
createRecord(
|
|
2043
|
-
|
|
2084
|
+
recordFields.map((field, index): [string, Value] => [field.name, values[index](context)]),
|
|
2044
2085
|
);
|
|
2045
2086
|
}
|
|
2046
2087
|
const names = fields.map((field) => field.name);
|
|
2047
2088
|
const writtenNames = recordFields.map((field) => field.name);
|
|
2048
2089
|
if (writtenNames.some((name, index) => name !== names[index])) {
|
|
2090
|
+
const writtenIndexes = fields.map((field) => recordFields.indexOf(field));
|
|
2049
2091
|
return (context) =>
|
|
2050
2092
|
createWrittenRecord(
|
|
2051
2093
|
names,
|
|
2094
|
+
writtenIndexes,
|
|
2052
2095
|
values.map((value) => value(context)),
|
|
2053
2096
|
writtenNames,
|
|
2054
2097
|
);
|
|
@@ -2098,25 +2141,31 @@ const compile = (expression: Expression, environment: Environment): Evaluator =>
|
|
|
2098
2141
|
};
|
|
2099
2142
|
case "And": {
|
|
2100
2143
|
const operands = expression.operands.map(getChildEvaluator);
|
|
2101
|
-
return (
|
|
2102
|
-
|
|
2103
|
-
|
|
2104
|
-
|
|
2105
|
-
|
|
2106
|
-
|
|
2107
|
-
|
|
2108
|
-
|
|
2144
|
+
return (
|
|
2145
|
+
compileTracedJunction(expression, operands, environment.callStack) ??
|
|
2146
|
+
((context) => {
|
|
2147
|
+
for (let index = 0; index < operands.length; index++) {
|
|
2148
|
+
const value = operands[index](context);
|
|
2149
|
+
if (typeof value !== "boolean") throw createJunctionError(expression, index, value);
|
|
2150
|
+
if (!value) return false;
|
|
2151
|
+
}
|
|
2152
|
+
return true;
|
|
2153
|
+
})
|
|
2154
|
+
);
|
|
2109
2155
|
}
|
|
2110
2156
|
case "Or": {
|
|
2111
2157
|
const operands = expression.operands.map(getChildEvaluator);
|
|
2112
|
-
return (
|
|
2113
|
-
|
|
2114
|
-
|
|
2115
|
-
|
|
2116
|
-
|
|
2117
|
-
|
|
2118
|
-
|
|
2119
|
-
|
|
2158
|
+
return (
|
|
2159
|
+
compileTracedJunction(expression, operands, environment.callStack) ??
|
|
2160
|
+
((context) => {
|
|
2161
|
+
for (let index = 0; index < operands.length; index++) {
|
|
2162
|
+
const value = operands[index](context);
|
|
2163
|
+
if (typeof value !== "boolean") throw createJunctionError(expression, index, value);
|
|
2164
|
+
if (value) return true;
|
|
2165
|
+
}
|
|
2166
|
+
return false;
|
|
2167
|
+
})
|
|
2168
|
+
);
|
|
2120
2169
|
}
|
|
2121
2170
|
case "Prime": {
|
|
2122
2171
|
const inner = getChildEvaluator(expression.expression);
|
|
@@ -2202,8 +2251,19 @@ const compile = (expression: Expression, environment: Environment): Evaluator =>
|
|
|
2202
2251
|
case "RecordSet": {
|
|
2203
2252
|
const fields = getSortedFields(expression.fields);
|
|
2204
2253
|
const names = fields.map((field) => field.name);
|
|
2205
|
-
const
|
|
2206
|
-
|
|
2254
|
+
const writtenIndexes = fields.map((field) => expression.fields.indexOf(field));
|
|
2255
|
+
const sets = expression.fields.map((field) => getChildEvaluator(field.value));
|
|
2256
|
+
if (writtenIndexes.every((writtenIndex, index) => writtenIndex === index)) {
|
|
2257
|
+
return (context) => ({ kind: "RecordSet", names, sets: sets.map((set) => set(context)) });
|
|
2258
|
+
}
|
|
2259
|
+
return (context) => {
|
|
2260
|
+
const writtenSets = sets.map((set) => set(context));
|
|
2261
|
+
return {
|
|
2262
|
+
kind: "RecordSet",
|
|
2263
|
+
names,
|
|
2264
|
+
sets: writtenIndexes.map((index) => writtenSets[index]),
|
|
2265
|
+
};
|
|
2266
|
+
};
|
|
2207
2267
|
}
|
|
2208
2268
|
case "Except":
|
|
2209
2269
|
return compileExcept(expression, environment);
|
package/src/exit-codes.ts
CHANGED
|
@@ -17,13 +17,13 @@ export const EXIT_STATUS = {
|
|
|
17
17
|
|
|
18
18
|
const MESSAGE_EXIT_STATUSES = new Map<number, number>([
|
|
19
19
|
...[
|
|
20
|
-
...Array.from({ length: 24 }, (
|
|
20
|
+
...Array.from({ length: 24 }, (_value, index) => 2222 + index),
|
|
21
21
|
2272,
|
|
22
22
|
2273,
|
|
23
23
|
2274,
|
|
24
24
|
2280,
|
|
25
25
|
2281,
|
|
26
|
-
...Array.from({ length: 7 }, (
|
|
26
|
+
...Array.from({ length: 7 }, (_value, index) => 5001 + index),
|
|
27
27
|
].map((code): [number, number] => [code, EXIT_STATUS.configParseError]),
|
|
28
28
|
[2253, EXIT_STATUS.livenessEvaluationFailure],
|
|
29
29
|
[2109, EXIT_STATUS.specEvaluationFailure],
|
|
@@ -81,6 +81,8 @@ export const withLivenessExitCode = (
|
|
|
81
81
|
withErrorExitCode(() => checker.addInitialState(index, state, tracing)),
|
|
82
82
|
addState: (index, state, successors, tracing) =>
|
|
83
83
|
withErrorExitCode(() => checker.addState(index, state, successors, tracing)),
|
|
84
|
+
storeState: checker.storeState,
|
|
85
|
+
getStateCounts: checker.getStateCounts,
|
|
84
86
|
findViolation: () => withErrorExitCode(() => checker.findViolation()),
|
|
85
87
|
getViolatedProperties: (path, cycleStart) =>
|
|
86
88
|
withErrorExitCode(() => checker.getViolatedProperties(path, cycleStart)),
|
package/src/instances.ts
CHANGED
|
@@ -522,7 +522,7 @@ const getInstanceOperator = (
|
|
|
522
522
|
arity: number,
|
|
523
523
|
location: SourceLocation,
|
|
524
524
|
): Expression => {
|
|
525
|
-
const names = Array.from({ length: arity }, (
|
|
525
|
+
const names = Array.from({ length: arity }, (_value, index) => `argument${index}`);
|
|
526
526
|
return {
|
|
527
527
|
kind: "Lambda",
|
|
528
528
|
params: names,
|
|
@@ -744,14 +744,14 @@ const copyDefinition = (rewrite: Rewrite, key: string): string => {
|
|
|
744
744
|
? mapped.body
|
|
745
745
|
: {
|
|
746
746
|
kind: "Let",
|
|
747
|
-
definitions: [...bindings].map((
|
|
747
|
+
definitions: [...bindings].map((entry): Definition => ({
|
|
748
748
|
kind: "Operator",
|
|
749
|
-
name,
|
|
749
|
+
name: entry[0],
|
|
750
750
|
params: [],
|
|
751
|
-
body:
|
|
751
|
+
body: entry[1],
|
|
752
752
|
isLocal: true,
|
|
753
753
|
isRecursive: false,
|
|
754
|
-
location:
|
|
754
|
+
location: entry[1].location,
|
|
755
755
|
})),
|
|
756
756
|
body: mapped.body,
|
|
757
757
|
// TLC has no such LET, so the call stack it prints has no position for it.
|