tla-ts 0.0.10-dev.99796fe03 → 0.0.10-dev.a17d6d9fa
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 +3 -2
- package/dist/index.d.ts +3 -2
- 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 +60 -60
- package/dist/prove.js +78 -78
- package/dist/run.cjs +42 -44
- 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 +39 -39
- 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 +50 -29
- package/src/builtins.ts +4 -3
- package/src/check-failure.ts +1 -1
- package/src/check-trace.ts +90 -51
- package/src/check.ts +367 -178
- 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 +16 -10
- package/src/cli/xml-exporter.ts +1 -1
- package/src/codegen.ts +26 -9
- package/src/dependencies.ts +49 -9
- package/src/dfid.ts +22 -10
- package/src/environment.ts +58 -33
- package/src/errors.ts +7 -0
- package/src/evaluate.ts +117 -41
- package/src/exit-codes.ts +4 -2
- package/src/instances.ts +5 -5
- package/src/java-hash.ts +14 -0
- package/src/java-overrides.ts +2 -2
- package/src/levels.ts +138 -90
- package/src/liveness-checker.ts +81 -33
- package/src/liveness.ts +49 -11
- 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 +112 -145
- 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/arith-rewriter.ts +11 -3
- package/src/prover/smt/solver/array-rewriter.ts +12 -2
- package/src/prover/smt/solver/asserted-formulas.ts +169 -58
- package/src/prover/smt/solver/ast-lt.ts +1 -1
- package/src/prover/smt/solver/ast.ts +63 -14
- package/src/prover/smt/solver/auf-solver.ts +23 -12
- package/src/prover/smt/solver/bit-blast-tactic.ts +26 -0
- package/src/prover/smt/solver/blast-term-ite.ts +47 -0
- package/src/prover/smt/solver/bound-simplifier.ts +11 -13
- 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 +32 -18
- package/src/prover/smt/solver/cofactor-elim-term-ite.ts +39 -24
- package/src/prover/smt/solver/context.ts +47 -9
- 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-bounds.ts +89 -0
- package/src/prover/smt/solver/elim-term-ite-tactic.ts +48 -0
- package/src/prover/smt/solver/elim-uncnstr.ts +5 -8
- 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 -11
- 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/internalizer.ts +1 -1
- package/src/prover/smt/solver/logic-tactics.ts +9 -2
- package/src/prover/smt/solver/lp/lp-settings.ts +5 -1
- package/src/prover/smt/solver/lp/nla-core.ts +1 -1
- package/src/prover/smt/solver/lp/nla-grobner.ts +2 -2
- package/src/prover/smt/solver/lp/nra-solver.ts +45 -39
- package/src/prover/smt/solver/lp/pdd.ts +2 -3
- 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-evaluator.ts +2 -0
- package/src/prover/smt/solver/model-generator.ts +85 -43
- 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 +20 -7
- package/src/prover/smt/solver/opt-nlsat.ts +29 -18
- package/src/prover/smt/solver/opt-pareto.ts +19 -0
- package/src/prover/smt/solver/opt-preprocess.ts +1 -1
- package/src/prover/smt/solver/opt-solver.ts +9 -5
- 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 +75 -18
- package/src/prover/smt/solver/probes.ts +88 -23
- package/src/prover/smt/solver/proto-model.ts +8 -8
- package/src/prover/smt/solver/push-app-ite.ts +37 -0
- 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/qsat.ts +16 -6
- 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/rewriter.ts +31 -25
- 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/goal2sat.ts +0 -1
- package/src/prover/smt/solver/sat/inc-sat-solver.ts +39 -5
- 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 +13 -5
- 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 +2 -2
- 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 +39 -5
- package/src/prover/smt/solver/smt-setup.ts +96 -10
- package/src/prover/smt/solver/smtlib-parser.ts +584 -223
- package/src/prover/smt/solver/smtlib-script.ts +509 -154
- package/src/prover/smt/solver/solve-eqs.ts +36 -37
- package/src/prover/smt/solver/solver.ts +18 -3
- package/src/prover/smt/solver/tactic.ts +284 -168
- package/src/prover/smt/solver/theory-bv.ts +13 -3
- package/src/prover/smt/solver/theory-fpa.ts +1 -1
- package/src/prover/smt/solver/theory-lra-final-check.ts +1 -0
- package/src/prover/smt/solver/theory-lra-internalize.ts +2 -0
- package/src/prover/smt/solver/theory-lra-propagate.ts +11 -3
- package/src/prover/smt/solver/theory-lra.ts +1 -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/smt/solver/tseitin-cnf.ts +1 -0
- package/src/prover/tlapm/cache.ts +8 -8
- package/src/prover/zenon/index-table.ts +5 -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/resolve.ts +959 -243
- package/src/runtime.ts +7 -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 +166 -101
- package/src/simulate.ts +110 -50
- package/src/spec-description.ts +5 -6
- package/src/standard-modules.ts +15 -6
- package/src/subexpressions.ts +398 -108
- package/src/successors.ts +4 -2
- 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/random.ts +2 -1
- package/src/tlc/replay.ts +3 -2
- package/src/tlc/tlc-operators.ts +10 -8
- package/src/tlc/tlcext-operators.ts +44 -15
- package/src/tlc/trace-spec.ts +9 -22
- package/src/typed-tier.ts +32 -25
- package/src/typescript/types.ts +2 -2
- package/src/values.ts +135 -78
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,28 @@ 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,
|
|
33
|
+
selectionArguments,
|
|
27
34
|
selections,
|
|
35
|
+
selectionSources,
|
|
36
|
+
SELECTION_NAME,
|
|
37
|
+
factReferences,
|
|
38
|
+
type NullSelection,
|
|
39
|
+
type SelectionArguments,
|
|
28
40
|
} from "./resolve";
|
|
29
41
|
|
|
30
42
|
type Lookup = (name: string) => Definition | undefined;
|
|
@@ -47,7 +59,38 @@ interface SelectingName {
|
|
|
47
59
|
argumentRanges?: (SourceRange | undefined)[];
|
|
48
60
|
}
|
|
49
61
|
|
|
50
|
-
const
|
|
62
|
+
const declaredArities = new WeakMap<Definition, number>();
|
|
63
|
+
|
|
64
|
+
const setDeclaredArities = (declarations: Declaration[], definitions: Definition[]) =>
|
|
65
|
+
declarations.forEach((declaration) => {
|
|
66
|
+
const definition = definitions.find(
|
|
67
|
+
(candidate) => candidate.isRecursive && candidate.name === declaration.name,
|
|
68
|
+
);
|
|
69
|
+
if (definition) declaredArities.set(definition, declaration.arity);
|
|
70
|
+
});
|
|
71
|
+
|
|
72
|
+
const getSelectorName = (selector: Selector) => {
|
|
73
|
+
switch (selector.kind) {
|
|
74
|
+
case "Name":
|
|
75
|
+
return selector.name;
|
|
76
|
+
case "Operand":
|
|
77
|
+
return typeof selector.operand === "number"
|
|
78
|
+
? `argument selector ${selector.operand}`
|
|
79
|
+
: selector.operand;
|
|
80
|
+
case "Bound":
|
|
81
|
+
return "!(...)";
|
|
82
|
+
case "At":
|
|
83
|
+
return "@";
|
|
84
|
+
case "Colon":
|
|
85
|
+
return ":";
|
|
86
|
+
}
|
|
87
|
+
};
|
|
88
|
+
|
|
89
|
+
const getExpressionArguments = (
|
|
90
|
+
operator: string,
|
|
91
|
+
range: SourceRange | undefined,
|
|
92
|
+
args: Expression[],
|
|
93
|
+
): SelectionArguments => ({ operator, range, args, params: args.map(() => 0) });
|
|
51
94
|
|
|
52
95
|
const createError = (message: string, location: SourceLocation) =>
|
|
53
96
|
new TlaSyntaxError(`${message} at line ${location.line}, column ${location.column}`);
|
|
@@ -79,7 +122,12 @@ const wrapLets = (body: Expression, lets: Definition[][], location: SourceLocati
|
|
|
79
122
|
const createApplication = (selection: Selection, body: Expression): Expression => {
|
|
80
123
|
const location = selection.location;
|
|
81
124
|
const wrapped = wrapLets(body, selection.lets, location);
|
|
82
|
-
if (selection.params.length === 0) return wrapped;
|
|
125
|
+
if (selection.params.length === 0 && wrapped !== body) return wrapped;
|
|
126
|
+
if (selection.params.length === 0) {
|
|
127
|
+
const copy = { ...body };
|
|
128
|
+
selectionSources.set(copy, selectionSources.get(body) ?? body);
|
|
129
|
+
return copy;
|
|
130
|
+
}
|
|
83
131
|
if (selection.args.length === 0) {
|
|
84
132
|
if (selection.params.some((param) => param.arity > 0)) {
|
|
85
133
|
throw createError("Selected an operator with operator parameters as an argument", location);
|
|
@@ -152,21 +200,33 @@ const applyDefinition = (definition: Definition, selection: Selection) => {
|
|
|
152
200
|
const selectSubexpression = (
|
|
153
201
|
selectors: Selector[],
|
|
154
202
|
lookup: Lookup,
|
|
203
|
+
isGoal: (name: string) => boolean,
|
|
155
204
|
reference: Expression & SelectingName,
|
|
156
205
|
isOperator: boolean,
|
|
157
206
|
): Expression => {
|
|
158
207
|
const location = reference.location;
|
|
159
208
|
const selection: Selection = { params: [], args: [], lets: [], location };
|
|
160
209
|
let selectorIndex = 0;
|
|
161
|
-
let current
|
|
210
|
+
let current: Expression | undefined;
|
|
162
211
|
let isFailed = false;
|
|
212
|
+
const nulls: NullSelection[] = [];
|
|
213
|
+
const applications: SelectionArguments[] = [];
|
|
214
|
+
let expressionError: SanyError | undefined;
|
|
215
|
+
const deferToExpression = (range: SourceRange | undefined, message: string) => {
|
|
216
|
+
if (!expressionError && range) expressionError = { location: formatRange(range), message };
|
|
217
|
+
};
|
|
218
|
+
const checkNull = (node: Expression | undefined, message: string, isEmpty = false) => {
|
|
219
|
+
const range = reference.selectorRanges?.[selectorIndex];
|
|
220
|
+
if (node && range) {
|
|
221
|
+
nulls.push({ node, error: { location: formatRange(range), message }, isEmpty });
|
|
222
|
+
}
|
|
223
|
+
};
|
|
163
224
|
|
|
164
225
|
const report = (range: SourceRange | undefined, message: string) => {
|
|
165
226
|
if (!range) throw createError(message, location);
|
|
166
227
|
selectionErrors.set(reference, {
|
|
167
|
-
|
|
168
|
-
|
|
169
|
-
.flatMap((selector) => ("args" in selector ? selector.args : [])),
|
|
228
|
+
applications,
|
|
229
|
+
nulls,
|
|
170
230
|
error: { location: formatRange(range), message },
|
|
171
231
|
});
|
|
172
232
|
isFailed = true;
|
|
@@ -178,6 +238,7 @@ const selectSubexpression = (
|
|
|
178
238
|
const args: Expression[] = [];
|
|
179
239
|
while (selectorIndex < selectors.length) {
|
|
180
240
|
const selector = selectors[selectorIndex];
|
|
241
|
+
if (selector.kind !== "Name" && !local) return undefined;
|
|
181
242
|
if (selector.kind !== "Name") throw createError("Expected an operator name", location);
|
|
182
243
|
names.push(selector.name);
|
|
183
244
|
args.push(...selector.args);
|
|
@@ -194,16 +255,49 @@ const selectSubexpression = (
|
|
|
194
255
|
|
|
195
256
|
const enterDefinition = (local: Definition[] | undefined) => {
|
|
196
257
|
const found = findDefinition(local);
|
|
258
|
+
if (!found) {
|
|
259
|
+
isFailed = true;
|
|
260
|
+
return undefined;
|
|
261
|
+
}
|
|
197
262
|
const definition = found.definition;
|
|
198
|
-
const arity = getArity(definition);
|
|
263
|
+
const arity = declaredArities.get(definition) ?? getArity(definition);
|
|
199
264
|
const isLast = selectorIndex === selectors.length - 1;
|
|
200
|
-
if (found.args.length !== arity
|
|
265
|
+
if (found.args.length !== arity) {
|
|
266
|
+
const range = reference.argumentRanges?.[selectorIndex] ?? location.range;
|
|
267
|
+
const message = `The operator ${resolveSynonym(found.name)} requires ${arity - found.earlier} arguments.`;
|
|
268
|
+
if (!isOperator || found.args.length !== 0) return report(range, message);
|
|
269
|
+
deferToExpression(range, message);
|
|
270
|
+
}
|
|
271
|
+
found.args.forEach((arg, index) =>
|
|
272
|
+
selectionArguments.set(arg, {
|
|
273
|
+
operator: found.name,
|
|
274
|
+
index,
|
|
275
|
+
range: reference.selectorRanges?.[selectorIndex],
|
|
276
|
+
}),
|
|
277
|
+
);
|
|
278
|
+
if (isLast) return { definition, args: found.args };
|
|
279
|
+
const range = definition.location.range;
|
|
280
|
+
const isUndefined =
|
|
281
|
+
declaredArities.has(definition) &&
|
|
282
|
+
range?.module === location.range?.module &&
|
|
283
|
+
isBefore(location, definition.location);
|
|
284
|
+
applications.push({
|
|
285
|
+
operator: found.name,
|
|
286
|
+
range: reference.selectorRanges?.[selectorIndex],
|
|
287
|
+
args: found.args,
|
|
288
|
+
params: isUndefined ? Array(arity).fill(0) : getParamArities(definition),
|
|
289
|
+
});
|
|
290
|
+
if (
|
|
291
|
+
definition.isRecursive &&
|
|
292
|
+
range &&
|
|
293
|
+
range.module === location.range?.module &&
|
|
294
|
+
isBefore(location, range.end)
|
|
295
|
+
) {
|
|
201
296
|
return report(
|
|
202
|
-
reference.
|
|
203
|
-
`
|
|
297
|
+
reference.selectorRanges?.[selectorIndex],
|
|
298
|
+
`Subexpression of \`${found.name}' used inside the operator's definition.`,
|
|
204
299
|
);
|
|
205
300
|
}
|
|
206
|
-
if (isLast) return { definition, args: found.args };
|
|
207
301
|
if (definition.kind !== "Operator") {
|
|
208
302
|
throw createError(`Cannot select a subexpression of ${definition.name}`, location);
|
|
209
303
|
}
|
|
@@ -222,12 +316,15 @@ const selectSubexpression = (
|
|
|
222
316
|
const found = current && findLabel(current, selector.name, []);
|
|
223
317
|
if (!found) return report(range, `Cannot find label \`${selector.name}'.`);
|
|
224
318
|
const params = found.label.params;
|
|
225
|
-
if (
|
|
226
|
-
|
|
319
|
+
if (selector.args.length !== params.length) {
|
|
320
|
+
const message = `Label \`${selector.name}' used with wrong number of arguments.`;
|
|
321
|
+
if (!isOperator) return report(range, message);
|
|
322
|
+
deferToExpression(range, message);
|
|
227
323
|
}
|
|
228
324
|
selection.lets.push(...found.lets);
|
|
229
325
|
selection.params.push(...params.map((name) => ({ name, arity: 0 })));
|
|
230
326
|
selection.args.push(...selector.args);
|
|
327
|
+
applications.push(getExpressionArguments(selector.name, range, selector.args));
|
|
231
328
|
current = found.label.body;
|
|
232
329
|
selectorIndex++;
|
|
233
330
|
}
|
|
@@ -236,14 +333,43 @@ const selectSubexpression = (
|
|
|
236
333
|
const selectOperand = (selector: Selector) => {
|
|
237
334
|
if (!current) throw createError("Subexpression selection failed", location);
|
|
238
335
|
if (selector.kind === "Colon") return;
|
|
336
|
+
const range = reference.selectorRanges?.[selectorIndex];
|
|
337
|
+
const currentRange = current.location.range;
|
|
338
|
+
if (
|
|
339
|
+
(current.kind === "Subexpression" ||
|
|
340
|
+
(current.kind === "Identifier" && current.name.includes("!")) ||
|
|
341
|
+
(current.kind === "Apply" && current.operator.includes("!"))) &&
|
|
342
|
+
(currentRange?.module !== location.range?.module || isBefore(current.location, location))
|
|
343
|
+
) {
|
|
344
|
+
const selected = selectionErrors.has(current)
|
|
345
|
+
? current
|
|
346
|
+
: resolveSubexpressions(current, lookup, isGoal);
|
|
347
|
+
const noOperands = `Choosing operand \`${getSelectorName(selector)}' of subexpression with no operands.`;
|
|
348
|
+
if (selectionErrors.has(selected)) {
|
|
349
|
+
report(range, noOperands);
|
|
350
|
+
return;
|
|
351
|
+
}
|
|
352
|
+
if (selections.has(selected) && selected.kind !== "Lambda") {
|
|
353
|
+
checkNull(selected, noOperands, true);
|
|
354
|
+
current =
|
|
355
|
+
selected.kind === "Let" &&
|
|
356
|
+
selected.body.kind === "Apply" &&
|
|
357
|
+
selected.body.operator === SELECTION_NAME
|
|
358
|
+
? selected.body
|
|
359
|
+
: // SANY wraps a selection without parameters in $Nop, whose only operand is the selection.
|
|
360
|
+
{ kind: "Tuple", elements: [selected], location: selected.location };
|
|
361
|
+
}
|
|
362
|
+
}
|
|
239
363
|
if (current.kind === "Label") {
|
|
240
364
|
current = current.body;
|
|
241
365
|
selectOperand(selector);
|
|
242
366
|
return;
|
|
243
367
|
}
|
|
368
|
+
const nonexistent = `Nonexistent operand specified by \`${getSelectorName(selector)}'.`;
|
|
244
369
|
if (current.kind === "Let") {
|
|
245
370
|
if (selector.kind !== "Operand" || getOperandIndex(selector.operand, 1) !== 0) {
|
|
246
|
-
|
|
371
|
+
report(range, "A LET/IN expression has only one operand.");
|
|
372
|
+
return;
|
|
247
373
|
}
|
|
248
374
|
selection.lets.push(current.definitions);
|
|
249
375
|
current = current.body;
|
|
@@ -251,33 +377,79 @@ const selectSubexpression = (
|
|
|
251
377
|
}
|
|
252
378
|
const binder = getBinder(current);
|
|
253
379
|
if (binder && (selector.kind === "Bound" || selector.kind === "At")) {
|
|
380
|
+
if (selector.kind === "Bound" && selector.args.length !== binder.names.length) {
|
|
381
|
+
report(
|
|
382
|
+
range,
|
|
383
|
+
`Selector with ${selector.args.length} argument(s) used for quantifier with ${binder.names.length} bound identifier(s).`,
|
|
384
|
+
);
|
|
385
|
+
return;
|
|
386
|
+
}
|
|
254
387
|
selection.params.push(...binder.names.map((name) => ({ name, arity: 0 })));
|
|
255
|
-
if (selector.kind === "Bound")
|
|
388
|
+
if (selector.kind === "Bound") {
|
|
389
|
+
selection.args.push(...selector.args);
|
|
390
|
+
applications.push(getExpressionArguments("", range, selector.args));
|
|
391
|
+
}
|
|
256
392
|
current = binder.body;
|
|
257
393
|
return;
|
|
258
394
|
}
|
|
259
|
-
if (current.kind === "Case"
|
|
395
|
+
if (current.kind === "Case") {
|
|
260
396
|
const arms = [
|
|
261
397
|
...current.arms,
|
|
262
398
|
...(current.other ? [{ condition: undefined, body: current.other }] : []),
|
|
263
399
|
];
|
|
264
|
-
|
|
265
|
-
|
|
266
|
-
|
|
267
|
-
|
|
400
|
+
if (selectorIndex === selectors.length - 1) {
|
|
401
|
+
report(range, "Subexpression of CASE must have form !i!j.");
|
|
402
|
+
return;
|
|
403
|
+
}
|
|
404
|
+
const arm =
|
|
405
|
+
selector.kind === "Operand"
|
|
406
|
+
? arms[getOperandIndex(selector.operand, arms.length)]
|
|
407
|
+
: undefined;
|
|
408
|
+
if (!arm) {
|
|
409
|
+
report(range, nonexistent);
|
|
410
|
+
return;
|
|
268
411
|
}
|
|
269
412
|
selectorIndex++;
|
|
270
|
-
const
|
|
271
|
-
const
|
|
272
|
-
|
|
413
|
+
const next = selectors[selectorIndex];
|
|
414
|
+
const part = next.kind === "Operand" ? getOperandIndex(next.operand, 2) : -1;
|
|
415
|
+
const nextRange = reference.selectorRanges?.[selectorIndex];
|
|
416
|
+
if (part === -1) {
|
|
417
|
+
report(
|
|
418
|
+
nextRange,
|
|
419
|
+
"Second selector for CASE subexpression must specify one of two operands.",
|
|
420
|
+
);
|
|
421
|
+
return;
|
|
422
|
+
}
|
|
423
|
+
const chosen = part === 0 ? arm.condition : arm.body;
|
|
424
|
+
if (!chosen) {
|
|
425
|
+
report(nextRange, "Selecting OTHER in a CASE statement.");
|
|
426
|
+
return;
|
|
427
|
+
}
|
|
273
428
|
current = chosen;
|
|
274
429
|
return;
|
|
275
430
|
}
|
|
276
|
-
if (
|
|
277
|
-
|
|
431
|
+
if (
|
|
432
|
+
current.kind === "Except" &&
|
|
433
|
+
selector.kind === "Operand" &&
|
|
434
|
+
getOperandIndex(selector.operand, current.updates.length + 1) > 0
|
|
435
|
+
) {
|
|
436
|
+
report(range, "Selecting subexpression of an EXCEPT not yet implemented.");
|
|
437
|
+
return;
|
|
438
|
+
}
|
|
278
439
|
const operands = binder ? binder.sets : getOperands(current);
|
|
440
|
+
if (!operands && current.kind !== "Identifier") {
|
|
441
|
+
report(range, "Selecting subexpression of expression that has none.");
|
|
442
|
+
return;
|
|
443
|
+
}
|
|
444
|
+
if (selector.kind !== "Operand") {
|
|
445
|
+
report(range, nonexistent);
|
|
446
|
+
return;
|
|
447
|
+
}
|
|
279
448
|
const operand = operands?.[getOperandIndex(selector.operand, operands.length)];
|
|
280
|
-
if (!operand)
|
|
449
|
+
if (!operand) {
|
|
450
|
+
report(range, nonexistent);
|
|
451
|
+
return;
|
|
452
|
+
}
|
|
281
453
|
current = operand;
|
|
282
454
|
};
|
|
283
455
|
|
|
@@ -290,7 +462,11 @@ const selectSubexpression = (
|
|
|
290
462
|
if (selector.kind === "Name") {
|
|
291
463
|
while (current?.kind === "Label") current = current.body;
|
|
292
464
|
if (current?.kind !== "Let") {
|
|
293
|
-
|
|
465
|
+
report(
|
|
466
|
+
reference.selectorRanges?.[selectorIndex - 1],
|
|
467
|
+
"A name selector here must be from a LET clause.",
|
|
468
|
+
);
|
|
469
|
+
return reference;
|
|
294
470
|
}
|
|
295
471
|
selection.lets.push(current.definitions);
|
|
296
472
|
const last = enterDefinition(current.definitions);
|
|
@@ -304,12 +480,40 @@ const selectSubexpression = (
|
|
|
304
480
|
followLabels();
|
|
305
481
|
continue;
|
|
306
482
|
}
|
|
483
|
+
if (selector.kind !== "Colon") {
|
|
484
|
+
checkNull(
|
|
485
|
+
current,
|
|
486
|
+
"Subexpression selection failed, probably due to an error in the selected expression.",
|
|
487
|
+
);
|
|
488
|
+
checkNull(
|
|
489
|
+
current,
|
|
490
|
+
`Choosing operand \`${getSelectorName(selector)}' of subexpression with no operands.`,
|
|
491
|
+
true,
|
|
492
|
+
);
|
|
493
|
+
}
|
|
307
494
|
selectOperand(selector);
|
|
495
|
+
checkNull(
|
|
496
|
+
current,
|
|
497
|
+
`An unexpected null node specified by '${getSelectorName(selectors[selectorIndex])}'.\nThis is probably due to a previous error.`,
|
|
498
|
+
);
|
|
308
499
|
selectorIndex++;
|
|
309
500
|
}
|
|
310
501
|
if (isFailed) return reference;
|
|
311
502
|
if (!current) throw createError("Subexpression selection failed", location);
|
|
312
|
-
|
|
503
|
+
const params = selection.params.length;
|
|
504
|
+
const args = selection.args.length;
|
|
505
|
+
if (params !== args) {
|
|
506
|
+
const message = `Expected ${params} arguments but found ${args}.`;
|
|
507
|
+
if (!isOperator || args > 0) {
|
|
508
|
+
report(location.range, message);
|
|
509
|
+
return reference;
|
|
510
|
+
}
|
|
511
|
+
deferToExpression(location.range, message);
|
|
512
|
+
}
|
|
513
|
+
const selected = createApplication(selection, current);
|
|
514
|
+
nullSelections.set(selected, nulls);
|
|
515
|
+
if (expressionError) operatorSelectionErrors.set(selected, expressionError);
|
|
516
|
+
return selected;
|
|
313
517
|
};
|
|
314
518
|
|
|
315
519
|
const getQualifiedSelectors = (
|
|
@@ -338,18 +542,25 @@ const resolveSubexpressions = (
|
|
|
338
542
|
): Expression => {
|
|
339
543
|
if (!containsReference(expression)) return expression;
|
|
340
544
|
if (expression.kind === "Let") {
|
|
545
|
+
if (expression.recursive) setDeclaredArities(expression.recursive, expression.definitions);
|
|
341
546
|
const local: Lookup = (name) =>
|
|
342
547
|
expression.definitions.find((definition) => definition.name === name) ?? lookup(name);
|
|
343
|
-
const
|
|
548
|
+
const isLocalGoal = (name: string) =>
|
|
549
|
+
!expression.definitions.some((definition) => definition.name === name) && isGoal(name);
|
|
550
|
+
const mapped = mapChildren(expression, (child) =>
|
|
551
|
+
resolveSubexpressions(child, local, isLocalGoal),
|
|
552
|
+
);
|
|
344
553
|
return mapped.kind === "Let" && mapped.instances
|
|
345
554
|
? {
|
|
346
555
|
...mapped,
|
|
347
|
-
instances: mapped.instances.map((instance) =>
|
|
556
|
+
instances: mapped.instances.map((instance) =>
|
|
557
|
+
resolveInstance(instance, local, isLocalGoal),
|
|
558
|
+
),
|
|
348
559
|
}
|
|
349
560
|
: mapped;
|
|
350
561
|
}
|
|
351
562
|
const callee = expression.kind === "Apply" ? lookup(expression.operator) : undefined;
|
|
352
|
-
const
|
|
563
|
+
const rebuilt =
|
|
353
564
|
expression.kind === "Apply"
|
|
354
565
|
? {
|
|
355
566
|
...expression,
|
|
@@ -363,6 +574,10 @@ const resolveSubexpressions = (
|
|
|
363
574
|
),
|
|
364
575
|
}
|
|
365
576
|
: mapChildren(expression, (child) => resolveSubexpressions(child, lookup, isGoal));
|
|
577
|
+
const children = getChildren(expression);
|
|
578
|
+
const mapped = getChildren(rebuilt).every((child, index) => child === children[index])
|
|
579
|
+
? expression
|
|
580
|
+
: rebuilt;
|
|
366
581
|
const selectors =
|
|
367
582
|
mapped.kind === "Subexpression"
|
|
368
583
|
? mapped.selectors
|
|
@@ -372,8 +587,22 @@ const resolveSubexpressions = (
|
|
|
372
587
|
? getQualifiedSelectors(mapped.operator, mapped.args, mapped.argumentCounts, lookup)
|
|
373
588
|
: undefined;
|
|
374
589
|
const first = selectors?.[0];
|
|
375
|
-
if (!selectors
|
|
376
|
-
const
|
|
590
|
+
if (!selectors) return mapped;
|
|
591
|
+
const nameCount = selectors.findIndex((selector) => selector.kind !== "Name");
|
|
592
|
+
const names = selectors.slice(0, nameCount === -1 ? selectors.length : nameCount);
|
|
593
|
+
const isQualified = names.some(
|
|
594
|
+
(_name, index) =>
|
|
595
|
+
index > 0 &&
|
|
596
|
+
lookup(
|
|
597
|
+
names
|
|
598
|
+
.slice(0, index + 1)
|
|
599
|
+
.map(getSelectorName)
|
|
600
|
+
.join("!"),
|
|
601
|
+
),
|
|
602
|
+
);
|
|
603
|
+
if (first?.kind === "Name" && isGoal(first.name) && !isQualified) return mapped;
|
|
604
|
+
if (first?.kind === "Name" && selectors[1].kind !== "Name" && !lookup(first.name)) return mapped;
|
|
605
|
+
const selected = selectSubexpression(selectors, lookup, isGoal, mapped, isOperator);
|
|
377
606
|
if (selected !== mapped) selections.add(selected);
|
|
378
607
|
return selected;
|
|
379
608
|
};
|
|
@@ -427,89 +656,148 @@ export const resolveModuleSubexpressions = (module: Module, available: Definitio
|
|
|
427
656
|
},
|
|
428
657
|
];
|
|
429
658
|
});
|
|
430
|
-
const
|
|
659
|
+
const own = new Set([...module.definitions, ...clauses]);
|
|
660
|
+
setDeclaredArities(
|
|
661
|
+
module.units.flatMap((unit) => (unit.kind === "Recursive" ? unit.declarations : [])),
|
|
662
|
+
module.definitions,
|
|
663
|
+
);
|
|
664
|
+
const recursive = new Map(
|
|
665
|
+
module.units.flatMap((unit): [string, SourceLocation][] =>
|
|
666
|
+
unit.kind === "Recursive"
|
|
667
|
+
? unit.declarations.map((declaration) => [declaration.name, declaration.location])
|
|
668
|
+
: [],
|
|
669
|
+
),
|
|
670
|
+
);
|
|
671
|
+
const isDeclaredBefore = (definition: Definition, location: SourceLocation) => {
|
|
672
|
+
const declared = recursive.get(definition.name);
|
|
673
|
+
return (
|
|
674
|
+
isBefore(definition.location, location) ||
|
|
675
|
+
(definition.isRecursive && declared !== undefined && isBefore(declared, location))
|
|
676
|
+
);
|
|
677
|
+
};
|
|
678
|
+
const getVisibleLookup =
|
|
679
|
+
(lookup: Lookup, location: SourceLocation): Lookup =>
|
|
680
|
+
(name) => {
|
|
681
|
+
const definition = lookup(name);
|
|
682
|
+
return definition && (!own.has(definition) || isDeclaredBefore(definition, location))
|
|
683
|
+
? definition
|
|
684
|
+
: undefined;
|
|
685
|
+
};
|
|
686
|
+
const proofLookup = createLookup([...available, ...module.definitions]);
|
|
431
687
|
const isGoal = (name: string) => goals.has(name);
|
|
432
688
|
const definitionLookup = createLookup([...available, ...module.definitions, ...clauses]);
|
|
433
|
-
const resolve = (expression: Expression) =>
|
|
689
|
+
const resolve = (expression: Expression, location: SourceLocation) =>
|
|
434
690
|
resolveSubexpressions(
|
|
435
691
|
expression,
|
|
436
|
-
definitionLookup,
|
|
692
|
+
getVisibleLookup(definitionLookup, location),
|
|
437
693
|
(name) => isGoal(name) && clauses.every((clause) => clause.name !== name),
|
|
438
694
|
);
|
|
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"
|
|
695
|
+
const createProofResolver = (lookup: Lookup) => {
|
|
696
|
+
const isProofGoal = (name: string) => isGoal(name) || !lookup(name);
|
|
697
|
+
const resolveInProof = (expression: Expression) =>
|
|
698
|
+
resolveSubexpressions(expression, lookup, isProofGoal);
|
|
699
|
+
const resolveFacts = (facts: Fact[]) => {
|
|
700
|
+
const resolved = facts.map((fact) =>
|
|
701
|
+
fact.kind === "ModuleFact" ? fact : resolveInProof(fact),
|
|
702
|
+
);
|
|
703
|
+
factReferences.set(resolved, facts);
|
|
704
|
+
return resolved;
|
|
705
|
+
};
|
|
706
|
+
const resolveBounds = (bounds: Bound[]) =>
|
|
707
|
+
bounds.map((bound) => ({ ...bound, set: resolveInProof(bound.set) }));
|
|
708
|
+
const resolveStatement = (statement: Expression | AssumeProve): Expression | AssumeProve =>
|
|
709
|
+
statement.kind === "AssumeProve"
|
|
493
710
|
? {
|
|
494
|
-
...
|
|
495
|
-
|
|
496
|
-
|
|
497
|
-
|
|
498
|
-
|
|
499
|
-
|
|
711
|
+
...statement,
|
|
712
|
+
assumptions: statement.assumptions.map((assumption) =>
|
|
713
|
+
assumption.kind === "NewSymbol"
|
|
714
|
+
? { ...assumption, set: assumption.set && resolveInProof(assumption.set) }
|
|
715
|
+
: resolveStatement(assumption),
|
|
716
|
+
),
|
|
717
|
+
conclusion: resolveInProof(statement.conclusion),
|
|
500
718
|
}
|
|
501
|
-
:
|
|
719
|
+
: resolveInProof(statement);
|
|
720
|
+
const resolveStep = (body: StepBody): StepBody => {
|
|
721
|
+
switch (body.kind) {
|
|
722
|
+
case "Use":
|
|
723
|
+
case "Hide":
|
|
724
|
+
return { ...body, facts: resolveFacts(body.facts) };
|
|
725
|
+
case "Instance":
|
|
726
|
+
return resolveInstance(body, lookup, isProofGoal);
|
|
727
|
+
case "Define":
|
|
728
|
+
return {
|
|
729
|
+
...body,
|
|
730
|
+
definitions: body.definitions.map((definition) =>
|
|
731
|
+
definition.kind === "Instance"
|
|
732
|
+
? resolveInstance(definition, lookup, isProofGoal)
|
|
733
|
+
: mapDefinition(definition, resolveInProof),
|
|
734
|
+
),
|
|
735
|
+
};
|
|
736
|
+
case "Have":
|
|
737
|
+
case "Case":
|
|
738
|
+
return { ...body, expression: resolveInProof(body.expression) };
|
|
739
|
+
case "Witness":
|
|
740
|
+
return { ...body, expressions: body.expressions.map(resolveInProof) };
|
|
741
|
+
case "Take":
|
|
742
|
+
return { ...body, bounds: resolveBounds(body.bounds) };
|
|
743
|
+
case "Pick":
|
|
744
|
+
return { ...body, bounds: resolveBounds(body.bounds), body: resolveInProof(body.body) };
|
|
745
|
+
case "Assert":
|
|
746
|
+
return { ...body, statement: resolveStatement(body.statement) };
|
|
747
|
+
default:
|
|
748
|
+
return body;
|
|
749
|
+
}
|
|
750
|
+
};
|
|
751
|
+
const resolveProof = (proof: Proof | undefined): Proof | undefined => {
|
|
752
|
+
if (proof?.kind === "By") return { ...proof, facts: resolveFacts(proof.facts) };
|
|
753
|
+
if (proof?.kind !== "Steps") return proof;
|
|
754
|
+
let resolver = { lookup, resolveStep, resolveProof };
|
|
755
|
+
return {
|
|
756
|
+
...proof,
|
|
757
|
+
steps: proof.steps.map((step) => {
|
|
758
|
+
const resolved = {
|
|
759
|
+
...step,
|
|
760
|
+
body: resolver.resolveStep(step.body),
|
|
761
|
+
proof: resolver.resolveProof(step.proof),
|
|
762
|
+
};
|
|
763
|
+
if (step.body.kind === "Define") {
|
|
764
|
+
const definitions = step.body.definitions.flatMap((definition) =>
|
|
765
|
+
definition.kind === "Instance" ? [] : [definition],
|
|
766
|
+
);
|
|
767
|
+
const outer = resolver.lookup;
|
|
768
|
+
resolver = createProofResolver(
|
|
769
|
+
(name) => definitions.find((definition) => definition.name === name) ?? outer(name),
|
|
770
|
+
);
|
|
771
|
+
}
|
|
772
|
+
return resolved;
|
|
773
|
+
}),
|
|
774
|
+
};
|
|
775
|
+
};
|
|
776
|
+
return { lookup, resolveFacts, resolveStatement, resolveStep, resolveProof };
|
|
777
|
+
};
|
|
502
778
|
const resolved = {
|
|
503
779
|
...module,
|
|
504
|
-
theorems: module.theorems.map((theorem) =>
|
|
505
|
-
|
|
506
|
-
|
|
507
|
-
theorem
|
|
508
|
-
|
|
509
|
-
|
|
510
|
-
|
|
780
|
+
theorems: module.theorems.map((theorem) => {
|
|
781
|
+
const resolver = createProofResolver(getVisibleLookup(proofLookup, theorem.location));
|
|
782
|
+
return {
|
|
783
|
+
...theorem,
|
|
784
|
+
statement:
|
|
785
|
+
theorem.name !== undefined && theorem.statement.kind !== "AssumeProve"
|
|
786
|
+
? theorem.statement
|
|
787
|
+
: resolver.resolveStatement(theorem.statement),
|
|
788
|
+
proof:
|
|
789
|
+
theorem.proof &&
|
|
790
|
+
createProofResolver(getVisibleLookup(proofLookup, theorem.proof.location)).resolveProof(
|
|
791
|
+
theorem.proof,
|
|
792
|
+
),
|
|
793
|
+
};
|
|
794
|
+
}),
|
|
795
|
+
uses: module.uses.map((use) => ({
|
|
796
|
+
...use,
|
|
797
|
+
facts: createProofResolver(getVisibleLookup(proofLookup, use.location)).resolveFacts(
|
|
798
|
+
use.facts,
|
|
799
|
+
),
|
|
511
800
|
})),
|
|
512
|
-
uses: module.uses.map((use) => ({ ...use, facts: resolveFacts(use.facts) })),
|
|
513
801
|
};
|
|
514
802
|
const hasReferences =
|
|
515
803
|
module.definitions.some((definition) => containsReference(definition.body)) ||
|
|
@@ -517,10 +805,12 @@ export const resolveModuleSubexpressions = (module: Module, available: Definitio
|
|
|
517
805
|
if (!hasReferences) return resolved;
|
|
518
806
|
return {
|
|
519
807
|
...resolved,
|
|
520
|
-
definitions: module.definitions.map((definition) =>
|
|
808
|
+
definitions: module.definitions.map((definition) =>
|
|
809
|
+
mapDefinition(definition, (expression) => resolve(expression, definition.location)),
|
|
810
|
+
),
|
|
521
811
|
assumptions: module.assumptions.map((assumption) => ({
|
|
522
812
|
...assumption,
|
|
523
|
-
expression: resolve(assumption.expression),
|
|
813
|
+
expression: resolve(assumption.expression, assumption.location),
|
|
524
814
|
})),
|
|
525
815
|
};
|
|
526
816
|
};
|