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/subexpressions.ts
CHANGED
|
@@ -2,6 +2,7 @@ import {
|
|
|
2
2
|
getChildren,
|
|
3
3
|
type AssumeProve,
|
|
4
4
|
type Bound,
|
|
5
|
+
type Declaration,
|
|
5
6
|
type Definition,
|
|
6
7
|
type Expression,
|
|
7
8
|
type Fact,
|
|
@@ -14,17 +15,25 @@ import {
|
|
|
14
15
|
type SourceRange,
|
|
15
16
|
type StepBody,
|
|
16
17
|
} from "./ast";
|
|
17
|
-
import { formatRange, TlaSyntaxError } from "./errors";
|
|
18
|
+
import { formatRange, TlaSyntaxError, type SanyError } from "./errors";
|
|
18
19
|
import { getSourceName, mapChildren, mapDefinition } from "./instances";
|
|
20
|
+
import { resolveSynonym } from "./tlc/jar-data";
|
|
19
21
|
import {
|
|
20
22
|
getArity,
|
|
21
23
|
getBinder,
|
|
22
24
|
getNameSelectors,
|
|
23
25
|
getOperandIndex,
|
|
24
26
|
getOperands,
|
|
27
|
+
getParamArities,
|
|
28
|
+
isBefore,
|
|
25
29
|
LOCAL_RESOLUTION,
|
|
30
|
+
nullSelections,
|
|
31
|
+
operatorSelectionErrors,
|
|
26
32
|
selectionErrors,
|
|
27
33
|
selections,
|
|
34
|
+
factReferences,
|
|
35
|
+
type NullSelection,
|
|
36
|
+
type SelectionArguments,
|
|
28
37
|
} from "./resolve";
|
|
29
38
|
|
|
30
39
|
type Lookup = (name: string) => Definition | undefined;
|
|
@@ -49,6 +58,39 @@ interface SelectingName {
|
|
|
49
58
|
|
|
50
59
|
const SELECTION_NAME = "$subexpression";
|
|
51
60
|
|
|
61
|
+
const declaredArities = new WeakMap<Definition, number>();
|
|
62
|
+
|
|
63
|
+
const setDeclaredArities = (declarations: Declaration[], definitions: Definition[]) =>
|
|
64
|
+
declarations.forEach((declaration) => {
|
|
65
|
+
const definition = definitions.find(
|
|
66
|
+
(candidate) => candidate.isRecursive && candidate.name === declaration.name,
|
|
67
|
+
);
|
|
68
|
+
if (definition) declaredArities.set(definition, declaration.arity);
|
|
69
|
+
});
|
|
70
|
+
|
|
71
|
+
const getSelectorName = (selector: Selector) => {
|
|
72
|
+
switch (selector.kind) {
|
|
73
|
+
case "Name":
|
|
74
|
+
return selector.name;
|
|
75
|
+
case "Operand":
|
|
76
|
+
return typeof selector.operand === "number"
|
|
77
|
+
? `argument selector ${selector.operand}`
|
|
78
|
+
: selector.operand;
|
|
79
|
+
case "Bound":
|
|
80
|
+
return "!(...)";
|
|
81
|
+
case "At":
|
|
82
|
+
return "@";
|
|
83
|
+
case "Colon":
|
|
84
|
+
return ":";
|
|
85
|
+
}
|
|
86
|
+
};
|
|
87
|
+
|
|
88
|
+
const getExpressionArguments = (
|
|
89
|
+
operator: string,
|
|
90
|
+
range: SourceRange | undefined,
|
|
91
|
+
args: Expression[],
|
|
92
|
+
): SelectionArguments => ({ operator, range, args, params: args.map(() => 0) });
|
|
93
|
+
|
|
52
94
|
const createError = (message: string, location: SourceLocation) =>
|
|
53
95
|
new TlaSyntaxError(`${message} at line ${location.line}, column ${location.column}`);
|
|
54
96
|
|
|
@@ -152,21 +194,30 @@ const applyDefinition = (definition: Definition, selection: Selection) => {
|
|
|
152
194
|
const selectSubexpression = (
|
|
153
195
|
selectors: Selector[],
|
|
154
196
|
lookup: Lookup,
|
|
197
|
+
isGoal: (name: string) => boolean,
|
|
155
198
|
reference: Expression & SelectingName,
|
|
156
199
|
isOperator: boolean,
|
|
157
200
|
): Expression => {
|
|
158
201
|
const location = reference.location;
|
|
159
202
|
const selection: Selection = { params: [], args: [], lets: [], location };
|
|
160
203
|
let selectorIndex = 0;
|
|
161
|
-
let current
|
|
204
|
+
let current: Expression | undefined;
|
|
162
205
|
let isFailed = false;
|
|
206
|
+
const nulls: NullSelection[] = [];
|
|
207
|
+
const applications: SelectionArguments[] = [];
|
|
208
|
+
let expressionError: SanyError | undefined;
|
|
209
|
+
const deferToExpression = (range: SourceRange | undefined, message: string) => {
|
|
210
|
+
if (!expressionError && range) expressionError = { location: formatRange(range), message };
|
|
211
|
+
};
|
|
212
|
+
const checkNull = (node: Expression | undefined, message: string) => {
|
|
213
|
+
const range = reference.selectorRanges?.[selectorIndex];
|
|
214
|
+
if (node && range) nulls.push({ node, error: { location: formatRange(range), message } });
|
|
215
|
+
};
|
|
163
216
|
|
|
164
217
|
const report = (range: SourceRange | undefined, message: string) => {
|
|
165
218
|
if (!range) throw createError(message, location);
|
|
166
219
|
selectionErrors.set(reference, {
|
|
167
|
-
|
|
168
|
-
.slice(0, selectorIndex)
|
|
169
|
-
.flatMap((selector) => ("args" in selector ? selector.args : [])),
|
|
220
|
+
applications,
|
|
170
221
|
error: { location: formatRange(range), message },
|
|
171
222
|
});
|
|
172
223
|
isFailed = true;
|
|
@@ -178,6 +229,7 @@ const selectSubexpression = (
|
|
|
178
229
|
const args: Expression[] = [];
|
|
179
230
|
while (selectorIndex < selectors.length) {
|
|
180
231
|
const selector = selectors[selectorIndex];
|
|
232
|
+
if (selector.kind !== "Name" && !local) return undefined;
|
|
181
233
|
if (selector.kind !== "Name") throw createError("Expected an operator name", location);
|
|
182
234
|
names.push(selector.name);
|
|
183
235
|
args.push(...selector.args);
|
|
@@ -194,16 +246,38 @@ const selectSubexpression = (
|
|
|
194
246
|
|
|
195
247
|
const enterDefinition = (local: Definition[] | undefined) => {
|
|
196
248
|
const found = findDefinition(local);
|
|
249
|
+
if (!found) {
|
|
250
|
+
isFailed = true;
|
|
251
|
+
return undefined;
|
|
252
|
+
}
|
|
197
253
|
const definition = found.definition;
|
|
198
|
-
const arity = getArity(definition);
|
|
254
|
+
const arity = declaredArities.get(definition) ?? getArity(definition);
|
|
199
255
|
const isLast = selectorIndex === selectors.length - 1;
|
|
200
|
-
if (found.args.length !== arity
|
|
256
|
+
if (found.args.length !== arity) {
|
|
257
|
+
const range = reference.argumentRanges?.[selectorIndex] ?? location.range;
|
|
258
|
+
const message = `The operator ${resolveSynonym(found.name)} requires ${arity - found.earlier} arguments.`;
|
|
259
|
+
if (!isOperator || found.args.length !== 0) return report(range, message);
|
|
260
|
+
deferToExpression(range, message);
|
|
261
|
+
}
|
|
262
|
+
if (isLast) return { definition, args: found.args };
|
|
263
|
+
applications.push({
|
|
264
|
+
operator: found.name,
|
|
265
|
+
range: reference.selectorRanges?.[selectorIndex],
|
|
266
|
+
args: found.args,
|
|
267
|
+
params: getParamArities(definition),
|
|
268
|
+
});
|
|
269
|
+
const range = definition.location.range;
|
|
270
|
+
if (
|
|
271
|
+
definition.isRecursive &&
|
|
272
|
+
range &&
|
|
273
|
+
range.module === location.range?.module &&
|
|
274
|
+
isBefore(location, range.end)
|
|
275
|
+
) {
|
|
201
276
|
return report(
|
|
202
|
-
reference.
|
|
203
|
-
`
|
|
277
|
+
reference.selectorRanges?.[selectorIndex],
|
|
278
|
+
`Subexpression of \`${found.name}' used inside the operator's definition.`,
|
|
204
279
|
);
|
|
205
280
|
}
|
|
206
|
-
if (isLast) return { definition, args: found.args };
|
|
207
281
|
if (definition.kind !== "Operator") {
|
|
208
282
|
throw createError(`Cannot select a subexpression of ${definition.name}`, location);
|
|
209
283
|
}
|
|
@@ -222,12 +296,15 @@ const selectSubexpression = (
|
|
|
222
296
|
const found = current && findLabel(current, selector.name, []);
|
|
223
297
|
if (!found) return report(range, `Cannot find label \`${selector.name}'.`);
|
|
224
298
|
const params = found.label.params;
|
|
225
|
-
if (
|
|
226
|
-
|
|
299
|
+
if (selector.args.length !== params.length) {
|
|
300
|
+
const message = `Label \`${selector.name}' used with wrong number of arguments.`;
|
|
301
|
+
if (!isOperator) return report(range, message);
|
|
302
|
+
deferToExpression(range, message);
|
|
227
303
|
}
|
|
228
304
|
selection.lets.push(...found.lets);
|
|
229
305
|
selection.params.push(...params.map((name) => ({ name, arity: 0 })));
|
|
230
306
|
selection.args.push(...selector.args);
|
|
307
|
+
applications.push(getExpressionArguments(selector.name, range, selector.args));
|
|
231
308
|
current = found.label.body;
|
|
232
309
|
selectorIndex++;
|
|
233
310
|
}
|
|
@@ -236,14 +313,42 @@ const selectSubexpression = (
|
|
|
236
313
|
const selectOperand = (selector: Selector) => {
|
|
237
314
|
if (!current) throw createError("Subexpression selection failed", location);
|
|
238
315
|
if (selector.kind === "Colon") return;
|
|
316
|
+
const range = reference.selectorRanges?.[selectorIndex];
|
|
317
|
+
const currentRange = current.location.range;
|
|
318
|
+
if (
|
|
319
|
+
(current.kind === "Subexpression" ||
|
|
320
|
+
(current.kind === "Identifier" && current.name.includes("!")) ||
|
|
321
|
+
(current.kind === "Apply" && current.operator.includes("!"))) &&
|
|
322
|
+
(currentRange?.module !== location.range?.module || isBefore(current.location, location))
|
|
323
|
+
) {
|
|
324
|
+
const selected = resolveSubexpressions(current, lookup, isGoal);
|
|
325
|
+
if (selectionErrors.has(selected)) {
|
|
326
|
+
report(
|
|
327
|
+
range,
|
|
328
|
+
`Choosing operand \`${getSelectorName(selector)}' of subexpression with no operands.`,
|
|
329
|
+
);
|
|
330
|
+
return;
|
|
331
|
+
}
|
|
332
|
+
if (selections.has(selected) && selected.kind !== "Lambda") {
|
|
333
|
+
current =
|
|
334
|
+
selected.kind === "Let" &&
|
|
335
|
+
selected.body.kind === "Apply" &&
|
|
336
|
+
selected.body.operator === SELECTION_NAME
|
|
337
|
+
? selected.body
|
|
338
|
+
: // SANY wraps a selection without parameters in $Nop, whose only operand is the selection.
|
|
339
|
+
{ kind: "Tuple", elements: [selected], location: selected.location };
|
|
340
|
+
}
|
|
341
|
+
}
|
|
239
342
|
if (current.kind === "Label") {
|
|
240
343
|
current = current.body;
|
|
241
344
|
selectOperand(selector);
|
|
242
345
|
return;
|
|
243
346
|
}
|
|
347
|
+
const nonexistent = `Nonexistent operand specified by \`${getSelectorName(selector)}'.`;
|
|
244
348
|
if (current.kind === "Let") {
|
|
245
349
|
if (selector.kind !== "Operand" || getOperandIndex(selector.operand, 1) !== 0) {
|
|
246
|
-
|
|
350
|
+
report(range, "A LET/IN expression has only one operand.");
|
|
351
|
+
return;
|
|
247
352
|
}
|
|
248
353
|
selection.lets.push(current.definitions);
|
|
249
354
|
current = current.body;
|
|
@@ -252,32 +357,63 @@ const selectSubexpression = (
|
|
|
252
357
|
const binder = getBinder(current);
|
|
253
358
|
if (binder && (selector.kind === "Bound" || selector.kind === "At")) {
|
|
254
359
|
selection.params.push(...binder.names.map((name) => ({ name, arity: 0 })));
|
|
255
|
-
if (selector.kind === "Bound")
|
|
360
|
+
if (selector.kind === "Bound") {
|
|
361
|
+
selection.args.push(...selector.args);
|
|
362
|
+
applications.push(getExpressionArguments("", range, selector.args));
|
|
363
|
+
}
|
|
256
364
|
current = binder.body;
|
|
257
365
|
return;
|
|
258
366
|
}
|
|
259
|
-
if (current.kind === "Case"
|
|
367
|
+
if (current.kind === "Case") {
|
|
260
368
|
const arms = [
|
|
261
369
|
...current.arms,
|
|
262
370
|
...(current.other ? [{ condition: undefined, body: current.other }] : []),
|
|
263
371
|
];
|
|
264
|
-
|
|
265
|
-
|
|
266
|
-
|
|
267
|
-
|
|
372
|
+
if (selectorIndex === selectors.length - 1) {
|
|
373
|
+
report(range, "Subexpression of CASE must have form !i!j.");
|
|
374
|
+
return;
|
|
375
|
+
}
|
|
376
|
+
const arm =
|
|
377
|
+
selector.kind === "Operand"
|
|
378
|
+
? arms[getOperandIndex(selector.operand, arms.length)]
|
|
379
|
+
: undefined;
|
|
380
|
+
if (!arm) {
|
|
381
|
+
report(range, nonexistent);
|
|
382
|
+
return;
|
|
268
383
|
}
|
|
269
384
|
selectorIndex++;
|
|
270
|
-
const
|
|
271
|
-
const
|
|
272
|
-
|
|
385
|
+
const next = selectors[selectorIndex];
|
|
386
|
+
const part = next.kind === "Operand" ? getOperandIndex(next.operand, 2) : -1;
|
|
387
|
+
const nextRange = reference.selectorRanges?.[selectorIndex];
|
|
388
|
+
if (part === -1) {
|
|
389
|
+
report(
|
|
390
|
+
nextRange,
|
|
391
|
+
"Second selector for CASE subexpression must specify one of two operands.",
|
|
392
|
+
);
|
|
393
|
+
return;
|
|
394
|
+
}
|
|
395
|
+
const chosen = part === 0 ? arm.condition : arm.body;
|
|
396
|
+
if (!chosen) {
|
|
397
|
+
report(nextRange, "Selecting OTHER in a CASE statement.");
|
|
398
|
+
return;
|
|
399
|
+
}
|
|
273
400
|
current = chosen;
|
|
274
401
|
return;
|
|
275
402
|
}
|
|
276
|
-
if (selector.kind !== "Operand")
|
|
277
|
-
throw createError("Unexpected subexpression selector", location);
|
|
278
403
|
const operands = binder ? binder.sets : getOperands(current);
|
|
404
|
+
if (!operands && current.kind !== "Identifier") {
|
|
405
|
+
report(range, "Selecting subexpression of expression that has none.");
|
|
406
|
+
return;
|
|
407
|
+
}
|
|
408
|
+
if (selector.kind !== "Operand") {
|
|
409
|
+
report(range, nonexistent);
|
|
410
|
+
return;
|
|
411
|
+
}
|
|
279
412
|
const operand = operands?.[getOperandIndex(selector.operand, operands.length)];
|
|
280
|
-
if (!operand)
|
|
413
|
+
if (!operand) {
|
|
414
|
+
report(range, nonexistent);
|
|
415
|
+
return;
|
|
416
|
+
}
|
|
281
417
|
current = operand;
|
|
282
418
|
};
|
|
283
419
|
|
|
@@ -304,12 +440,35 @@ const selectSubexpression = (
|
|
|
304
440
|
followLabels();
|
|
305
441
|
continue;
|
|
306
442
|
}
|
|
443
|
+
if (selector.kind !== "Colon") {
|
|
444
|
+
checkNull(
|
|
445
|
+
current,
|
|
446
|
+
"Subexpression selection failed, probably due to an error in the selected expression.",
|
|
447
|
+
);
|
|
448
|
+
}
|
|
307
449
|
selectOperand(selector);
|
|
450
|
+
checkNull(
|
|
451
|
+
current,
|
|
452
|
+
`An unexpected null node specified by '${getSelectorName(selectors[selectorIndex])}'.\nThis is probably due to a previous error.`,
|
|
453
|
+
);
|
|
308
454
|
selectorIndex++;
|
|
309
455
|
}
|
|
310
456
|
if (isFailed) return reference;
|
|
311
457
|
if (!current) throw createError("Subexpression selection failed", location);
|
|
312
|
-
|
|
458
|
+
const params = selection.params.length;
|
|
459
|
+
const args = selection.args.length;
|
|
460
|
+
if (params !== args) {
|
|
461
|
+
const message = `Expected ${params} arguments but found ${args}.`;
|
|
462
|
+
if (!isOperator || args > 0) {
|
|
463
|
+
report(location.range, message);
|
|
464
|
+
return reference;
|
|
465
|
+
}
|
|
466
|
+
deferToExpression(location.range, message);
|
|
467
|
+
}
|
|
468
|
+
const selected = createApplication(selection, current);
|
|
469
|
+
nullSelections.set(selected, nulls);
|
|
470
|
+
if (expressionError) operatorSelectionErrors.set(selected, expressionError);
|
|
471
|
+
return selected;
|
|
313
472
|
};
|
|
314
473
|
|
|
315
474
|
const getQualifiedSelectors = (
|
|
@@ -338,6 +497,7 @@ const resolveSubexpressions = (
|
|
|
338
497
|
): Expression => {
|
|
339
498
|
if (!containsReference(expression)) return expression;
|
|
340
499
|
if (expression.kind === "Let") {
|
|
500
|
+
if (expression.recursive) setDeclaredArities(expression.recursive, expression.definitions);
|
|
341
501
|
const local: Lookup = (name) =>
|
|
342
502
|
expression.definitions.find((definition) => definition.name === name) ?? lookup(name);
|
|
343
503
|
const mapped = mapChildren(expression, (child) => resolveSubexpressions(child, local, isGoal));
|
|
@@ -372,8 +532,22 @@ const resolveSubexpressions = (
|
|
|
372
532
|
? getQualifiedSelectors(mapped.operator, mapped.args, mapped.argumentCounts, lookup)
|
|
373
533
|
: undefined;
|
|
374
534
|
const first = selectors?.[0];
|
|
375
|
-
if (!selectors
|
|
376
|
-
const
|
|
535
|
+
if (!selectors) return mapped;
|
|
536
|
+
const nameCount = selectors.findIndex((selector) => selector.kind !== "Name");
|
|
537
|
+
const names = selectors.slice(0, nameCount === -1 ? selectors.length : nameCount);
|
|
538
|
+
const isQualified = names.some(
|
|
539
|
+
(_name, index) =>
|
|
540
|
+
index > 0 &&
|
|
541
|
+
lookup(
|
|
542
|
+
names
|
|
543
|
+
.slice(0, index + 1)
|
|
544
|
+
.map(getSelectorName)
|
|
545
|
+
.join("!"),
|
|
546
|
+
),
|
|
547
|
+
);
|
|
548
|
+
if (first?.kind === "Name" && isGoal(first.name) && !isQualified) return mapped;
|
|
549
|
+
if (first?.kind === "Name" && selectors[1].kind !== "Name" && !lookup(first.name)) return mapped;
|
|
550
|
+
const selected = selectSubexpression(selectors, lookup, isGoal, mapped, isOperator);
|
|
377
551
|
if (selected !== mapped) selections.add(selected);
|
|
378
552
|
return selected;
|
|
379
553
|
};
|
|
@@ -427,89 +601,148 @@ export const resolveModuleSubexpressions = (module: Module, available: Definitio
|
|
|
427
601
|
},
|
|
428
602
|
];
|
|
429
603
|
});
|
|
430
|
-
const
|
|
604
|
+
const own = new Set([...module.definitions, ...clauses]);
|
|
605
|
+
setDeclaredArities(
|
|
606
|
+
module.units.flatMap((unit) => (unit.kind === "Recursive" ? unit.declarations : [])),
|
|
607
|
+
module.definitions,
|
|
608
|
+
);
|
|
609
|
+
const recursive = new Map(
|
|
610
|
+
module.units.flatMap((unit): [string, SourceLocation][] =>
|
|
611
|
+
unit.kind === "Recursive"
|
|
612
|
+
? unit.declarations.map((declaration) => [declaration.name, declaration.location])
|
|
613
|
+
: [],
|
|
614
|
+
),
|
|
615
|
+
);
|
|
616
|
+
const isDeclaredBefore = (definition: Definition, location: SourceLocation) => {
|
|
617
|
+
const declared = recursive.get(definition.name);
|
|
618
|
+
return (
|
|
619
|
+
isBefore(definition.location, location) ||
|
|
620
|
+
(definition.isRecursive && declared !== undefined && isBefore(declared, location))
|
|
621
|
+
);
|
|
622
|
+
};
|
|
623
|
+
const getVisibleLookup =
|
|
624
|
+
(lookup: Lookup, location: SourceLocation): Lookup =>
|
|
625
|
+
(name) => {
|
|
626
|
+
const definition = lookup(name);
|
|
627
|
+
return definition && (!own.has(definition) || isDeclaredBefore(definition, location))
|
|
628
|
+
? definition
|
|
629
|
+
: undefined;
|
|
630
|
+
};
|
|
631
|
+
const proofLookup = createLookup([...available, ...module.definitions]);
|
|
431
632
|
const isGoal = (name: string) => goals.has(name);
|
|
432
633
|
const definitionLookup = createLookup([...available, ...module.definitions, ...clauses]);
|
|
433
|
-
const resolve = (expression: Expression) =>
|
|
634
|
+
const resolve = (expression: Expression, location: SourceLocation) =>
|
|
434
635
|
resolveSubexpressions(
|
|
435
636
|
expression,
|
|
436
|
-
definitionLookup,
|
|
637
|
+
getVisibleLookup(definitionLookup, location),
|
|
437
638
|
(name) => isGoal(name) && clauses.every((clause) => clause.name !== name),
|
|
438
639
|
);
|
|
439
|
-
const
|
|
440
|
-
|
|
441
|
-
|
|
442
|
-
|
|
443
|
-
|
|
444
|
-
|
|
445
|
-
|
|
446
|
-
|
|
447
|
-
|
|
448
|
-
|
|
449
|
-
|
|
450
|
-
|
|
451
|
-
|
|
452
|
-
|
|
453
|
-
|
|
454
|
-
),
|
|
455
|
-
conclusion: resolveInProof(statement.conclusion),
|
|
456
|
-
}
|
|
457
|
-
: resolveInProof(statement);
|
|
458
|
-
const resolveStep = (body: StepBody): StepBody => {
|
|
459
|
-
switch (body.kind) {
|
|
460
|
-
case "Use":
|
|
461
|
-
case "Hide":
|
|
462
|
-
return { ...body, facts: resolveFacts(body.facts) };
|
|
463
|
-
case "Instance":
|
|
464
|
-
return resolveInstance(body, lookup, isProofGoal);
|
|
465
|
-
case "Define":
|
|
466
|
-
return {
|
|
467
|
-
...body,
|
|
468
|
-
definitions: body.definitions.map((definition) =>
|
|
469
|
-
definition.kind === "Instance"
|
|
470
|
-
? resolveInstance(definition, lookup, isProofGoal)
|
|
471
|
-
: mapDefinition(definition, resolveInProof),
|
|
472
|
-
),
|
|
473
|
-
};
|
|
474
|
-
case "Have":
|
|
475
|
-
case "Case":
|
|
476
|
-
return { ...body, expression: resolveInProof(body.expression) };
|
|
477
|
-
case "Witness":
|
|
478
|
-
return { ...body, expressions: body.expressions.map(resolveInProof) };
|
|
479
|
-
case "Take":
|
|
480
|
-
return { ...body, bounds: resolveBounds(body.bounds) };
|
|
481
|
-
case "Pick":
|
|
482
|
-
return { ...body, bounds: resolveBounds(body.bounds), body: resolveInProof(body.body) };
|
|
483
|
-
case "Assert":
|
|
484
|
-
return { ...body, statement: resolveStatement(body.statement) };
|
|
485
|
-
default:
|
|
486
|
-
return body;
|
|
487
|
-
}
|
|
488
|
-
};
|
|
489
|
-
const resolveProof = (proof: Proof | undefined): Proof | undefined =>
|
|
490
|
-
proof?.kind === "By"
|
|
491
|
-
? { ...proof, facts: resolveFacts(proof.facts) }
|
|
492
|
-
: proof?.kind === "Steps"
|
|
640
|
+
const createProofResolver = (lookup: Lookup) => {
|
|
641
|
+
const isProofGoal = (name: string) => isGoal(name) || !lookup(name);
|
|
642
|
+
const resolveInProof = (expression: Expression) =>
|
|
643
|
+
resolveSubexpressions(expression, lookup, isProofGoal);
|
|
644
|
+
const resolveFacts = (facts: Fact[]) => {
|
|
645
|
+
const resolved = facts.map((fact) =>
|
|
646
|
+
fact.kind === "ModuleFact" ? fact : resolveInProof(fact),
|
|
647
|
+
);
|
|
648
|
+
factReferences.set(resolved, facts);
|
|
649
|
+
return resolved;
|
|
650
|
+
};
|
|
651
|
+
const resolveBounds = (bounds: Bound[]) =>
|
|
652
|
+
bounds.map((bound) => ({ ...bound, set: resolveInProof(bound.set) }));
|
|
653
|
+
const resolveStatement = (statement: Expression | AssumeProve): Expression | AssumeProve =>
|
|
654
|
+
statement.kind === "AssumeProve"
|
|
493
655
|
? {
|
|
494
|
-
...
|
|
495
|
-
|
|
496
|
-
|
|
497
|
-
|
|
498
|
-
|
|
499
|
-
|
|
656
|
+
...statement,
|
|
657
|
+
assumptions: statement.assumptions.map((assumption) =>
|
|
658
|
+
assumption.kind === "NewSymbol"
|
|
659
|
+
? { ...assumption, set: assumption.set && resolveInProof(assumption.set) }
|
|
660
|
+
: resolveStatement(assumption),
|
|
661
|
+
),
|
|
662
|
+
conclusion: resolveInProof(statement.conclusion),
|
|
500
663
|
}
|
|
501
|
-
:
|
|
664
|
+
: resolveInProof(statement);
|
|
665
|
+
const resolveStep = (body: StepBody): StepBody => {
|
|
666
|
+
switch (body.kind) {
|
|
667
|
+
case "Use":
|
|
668
|
+
case "Hide":
|
|
669
|
+
return { ...body, facts: resolveFacts(body.facts) };
|
|
670
|
+
case "Instance":
|
|
671
|
+
return resolveInstance(body, lookup, isProofGoal);
|
|
672
|
+
case "Define":
|
|
673
|
+
return {
|
|
674
|
+
...body,
|
|
675
|
+
definitions: body.definitions.map((definition) =>
|
|
676
|
+
definition.kind === "Instance"
|
|
677
|
+
? resolveInstance(definition, lookup, isProofGoal)
|
|
678
|
+
: mapDefinition(definition, resolveInProof),
|
|
679
|
+
),
|
|
680
|
+
};
|
|
681
|
+
case "Have":
|
|
682
|
+
case "Case":
|
|
683
|
+
return { ...body, expression: resolveInProof(body.expression) };
|
|
684
|
+
case "Witness":
|
|
685
|
+
return { ...body, expressions: body.expressions.map(resolveInProof) };
|
|
686
|
+
case "Take":
|
|
687
|
+
return { ...body, bounds: resolveBounds(body.bounds) };
|
|
688
|
+
case "Pick":
|
|
689
|
+
return { ...body, bounds: resolveBounds(body.bounds), body: resolveInProof(body.body) };
|
|
690
|
+
case "Assert":
|
|
691
|
+
return { ...body, statement: resolveStatement(body.statement) };
|
|
692
|
+
default:
|
|
693
|
+
return body;
|
|
694
|
+
}
|
|
695
|
+
};
|
|
696
|
+
const resolveProof = (proof: Proof | undefined): Proof | undefined => {
|
|
697
|
+
if (proof?.kind === "By") return { ...proof, facts: resolveFacts(proof.facts) };
|
|
698
|
+
if (proof?.kind !== "Steps") return proof;
|
|
699
|
+
let resolver = { lookup, resolveStep, resolveProof };
|
|
700
|
+
return {
|
|
701
|
+
...proof,
|
|
702
|
+
steps: proof.steps.map((step) => {
|
|
703
|
+
const resolved = {
|
|
704
|
+
...step,
|
|
705
|
+
body: resolver.resolveStep(step.body),
|
|
706
|
+
proof: resolver.resolveProof(step.proof),
|
|
707
|
+
};
|
|
708
|
+
if (step.body.kind === "Define") {
|
|
709
|
+
const definitions = step.body.definitions.flatMap((definition) =>
|
|
710
|
+
definition.kind === "Instance" ? [] : [definition],
|
|
711
|
+
);
|
|
712
|
+
const outer = resolver.lookup;
|
|
713
|
+
resolver = createProofResolver(
|
|
714
|
+
(name) => definitions.find((definition) => definition.name === name) ?? outer(name),
|
|
715
|
+
);
|
|
716
|
+
}
|
|
717
|
+
return resolved;
|
|
718
|
+
}),
|
|
719
|
+
};
|
|
720
|
+
};
|
|
721
|
+
return { lookup, resolveFacts, resolveStatement, resolveStep, resolveProof };
|
|
722
|
+
};
|
|
502
723
|
const resolved = {
|
|
503
724
|
...module,
|
|
504
|
-
theorems: module.theorems.map((theorem) =>
|
|
505
|
-
|
|
506
|
-
|
|
507
|
-
theorem
|
|
508
|
-
|
|
509
|
-
|
|
510
|
-
|
|
725
|
+
theorems: module.theorems.map((theorem) => {
|
|
726
|
+
const resolver = createProofResolver(getVisibleLookup(proofLookup, theorem.location));
|
|
727
|
+
return {
|
|
728
|
+
...theorem,
|
|
729
|
+
statement:
|
|
730
|
+
theorem.name !== undefined && theorem.statement.kind !== "AssumeProve"
|
|
731
|
+
? theorem.statement
|
|
732
|
+
: resolver.resolveStatement(theorem.statement),
|
|
733
|
+
proof:
|
|
734
|
+
theorem.proof &&
|
|
735
|
+
createProofResolver(getVisibleLookup(proofLookup, theorem.proof.location)).resolveProof(
|
|
736
|
+
theorem.proof,
|
|
737
|
+
),
|
|
738
|
+
};
|
|
739
|
+
}),
|
|
740
|
+
uses: module.uses.map((use) => ({
|
|
741
|
+
...use,
|
|
742
|
+
facts: createProofResolver(getVisibleLookup(proofLookup, use.location)).resolveFacts(
|
|
743
|
+
use.facts,
|
|
744
|
+
),
|
|
511
745
|
})),
|
|
512
|
-
uses: module.uses.map((use) => ({ ...use, facts: resolveFacts(use.facts) })),
|
|
513
746
|
};
|
|
514
747
|
const hasReferences =
|
|
515
748
|
module.definitions.some((definition) => containsReference(definition.body)) ||
|
|
@@ -517,10 +750,12 @@ export const resolveModuleSubexpressions = (module: Module, available: Definitio
|
|
|
517
750
|
if (!hasReferences) return resolved;
|
|
518
751
|
return {
|
|
519
752
|
...resolved,
|
|
520
|
-
definitions: module.definitions.map((definition) =>
|
|
753
|
+
definitions: module.definitions.map((definition) =>
|
|
754
|
+
mapDefinition(definition, (expression) => resolve(expression, definition.location)),
|
|
755
|
+
),
|
|
521
756
|
assumptions: module.assumptions.map((assumption) => ({
|
|
522
757
|
...assumption,
|
|
523
|
-
expression: resolve(assumption.expression),
|
|
758
|
+
expression: resolve(assumption.expression, assumption.location),
|
|
524
759
|
})),
|
|
525
760
|
};
|
|
526
761
|
};
|
package/src/successors.ts
CHANGED
|
@@ -723,6 +723,7 @@ const compileIdentifier = (
|
|
|
723
723
|
!definition ||
|
|
724
724
|
(expression.location.range && getStartupValue(definition, environment) !== undefined)
|
|
725
725
|
) {
|
|
726
|
+
// Deviation from TLC: Tool#getInitStates prints an unassigned variable's declaration as the non-boolean value it found.
|
|
726
727
|
guard(run, scope, partial, action, isFixed, onComplete);
|
|
727
728
|
return;
|
|
728
729
|
}
|
package/src/symmetry.ts
CHANGED
package/src/tlc/jar-data.ts
CHANGED
|
@@ -143,6 +143,16 @@ export const SANY_OPERATOR_SYNONYMS = [
|
|
|
143
143
|
["^+", "⁺"],
|
|
144
144
|
];
|
|
145
145
|
|
|
146
|
+
const SYNONYMS = new Map(
|
|
147
|
+
SANY_OPERATOR_SYNONYMS.flatMap((names) => names.slice(1).map((synonym) => [synonym, names[0]])),
|
|
148
|
+
);
|
|
149
|
+
|
|
150
|
+
export const resolveSynonym = (name: string) =>
|
|
151
|
+
name
|
|
152
|
+
.split("!")
|
|
153
|
+
.map((part) => SYNONYMS.get(part) ?? (part === "~" ? "\\lnot" : part))
|
|
154
|
+
.join("!");
|
|
155
|
+
|
|
146
156
|
export const TLC_STARTUP_STRINGS = [
|
|
147
157
|
"STRING",
|
|
148
158
|
"FALSE",
|
package/src/tlc/messages.ts
CHANGED
|
@@ -345,14 +345,14 @@ interface CodedMessage {
|
|
|
345
345
|
let codedMessagePatterns: { pattern: RegExp; message: CodedMessage }[] | undefined;
|
|
346
346
|
|
|
347
347
|
const getCodedMessagePatterns = () =>
|
|
348
|
-
(codedMessagePatterns ??= CODED_MESSAGES.map((
|
|
348
|
+
(codedMessagePatterns ??= CODED_MESSAGES.map((codedMessage) => ({
|
|
349
349
|
pattern: new RegExp(
|
|
350
|
-
`^${
|
|
350
|
+
`^${codedMessage[1]
|
|
351
351
|
.split(/%\d+%/)
|
|
352
352
|
.map((part) => part.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"))
|
|
353
353
|
.join("[\\s\\S]*")}$`,
|
|
354
354
|
),
|
|
355
|
-
message: { code, isEvalException },
|
|
355
|
+
message: { code: codedMessage[0], isEvalException: codedMessage[2] },
|
|
356
356
|
})));
|
|
357
357
|
|
|
358
358
|
const UNCODED_MESSAGE_PATTERN =
|