tla-ts 0.0.10-dev.d618a2d79 → 0.0.10-dev.e3e5dd576
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 +53 -53
- package/dist/index.cjs +1 -1
- package/dist/index.d.cts +18 -4
- package/dist/index.d.ts +18 -4
- 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 +56 -56
- package/dist/prove.js +78 -78
- package/dist/run.cjs +40 -44
- package/dist/run.js +42 -46
- package/dist/tlapm.cjs +1 -1
- package/dist/tlapm.js +2 -2
- package/dist/transfer.cjs +49 -44
- package/dist/transfer.js +48 -43
- package/dist/worker.cjs +7 -7
- package/dist/worker.js +7 -7
- package/package.json +1 -1
- package/src/ast.ts +14 -2
- package/src/bags.ts +50 -29
- package/src/builtins.ts +4 -3
- package/src/check-failure.ts +13 -11
- package/src/check-trace.ts +116 -64
- package/src/check.ts +516 -280
- package/src/cli/runtime-invariants.ts +20 -56
- package/src/cli/tlc-arguments.ts +2 -2
- package/src/cli/tlc-output.ts +18 -4
- package/src/cli/tlc.ts +18 -12
- package/src/cli/xml-exporter.ts +1 -1
- package/src/codegen.ts +23 -10
- package/src/coverage.ts +190 -1
- package/src/dependencies.ts +68 -15
- package/src/dfid.ts +101 -36
- package/src/environment.ts +123 -38
- package/src/errors.ts +7 -0
- package/src/evaluate.ts +370 -99
- package/src/exit-codes.ts +28 -14
- package/src/instances.ts +135 -11
- package/src/java-hash.ts +14 -0
- package/src/java-overrides.ts +2 -2
- package/src/levels.ts +675 -236
- package/src/lexer.ts +12 -2
- package/src/liveness-checker.ts +179 -60
- package/src/liveness.ts +51 -10
- package/src/obligations/index.ts +1 -1
- package/src/obligations/normalize.ts +1 -4
- package/src/obligations/printer.ts +5 -5
- package/src/obligations/source.ts +2 -0
- package/src/parallel-worker.ts +8 -2
- package/src/parallel.ts +5 -0
- package/src/parser.ts +180 -149
- 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 +171 -58
- package/src/prover/smt/solver/ast-lt.ts +1 -1
- package/src/prover/smt/solver/ast.ts +66 -14
- package/src/prover/smt/solver/auf-solver.ts +23 -12
- package/src/prover/smt/solver/bit-blast-tactic.ts +27 -1
- 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 +35 -18
- package/src/prover/smt/solver/cofactor-elim-term-ite.ts +39 -24
- package/src/prover/smt/solver/context.ts +84 -15
- 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 +28 -16
- package/src/prover/smt/solver/diff-neq.ts +1 -2
- package/src/prover/smt/solver/dt2bv-tactic.ts +57 -21
- 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 +608 -139
- 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 +15 -5
- package/src/prover/smt/solver/lp/core-solver.ts +12 -8
- package/src/prover/smt/solver/lp/lar-solver.ts +1 -1
- package/src/prover/smt/solver/lp/lp-settings.ts +6 -2
- 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/maxcore.ts +2 -1
- package/src/prover/smt/solver/maxsmt-base.ts +1 -0
- package/src/prover/smt/solver/model-based-opt.ts +1 -1
- package/src/prover/smt/solver/model-checker.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 +22 -44
- package/src/prover/smt/solver/muz/dl-mk-coi-filter.ts +1 -1
- package/src/prover/smt/solver/muz/dl-mk-slice.ts +3 -3
- package/src/prover/smt/solver/muz/dl-rule.ts +8 -9
- package/src/prover/smt/solver/muz/hnf.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 +15 -2
- package/src/prover/smt/solver/muz/rule-properties.ts +22 -0
- 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/muz/spacer-prop-solver.ts +1 -1
- 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 +21 -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 +10 -6
- package/src/prover/smt/solver/optsmt.ts +1 -1
- package/src/prover/smt/solver/parallel-tactic.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 +23 -8
- 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-tpl.ts +7 -6
- package/src/prover/smt/solver/rewriter.ts +31 -25
- package/src/prover/smt/solver/rlimit.ts +7 -3
- package/src/prover/smt/solver/sat/config.ts +1 -1
- package/src/prover/smt/solver/sat/goal2sat.ts +65 -12
- package/src/prover/smt/solver/sat/inc-sat-solver.ts +129 -43
- package/src/prover/smt/solver/sat/model-converter.ts +1 -1
- package/src/prover/smt/solver/sat/pb-constraint.ts +7 -0
- package/src/prover/smt/solver/sat/pb-solver.ts +26 -7
- package/src/prover/smt/solver/sat/sat-tactic.ts +17 -7
- package/src/prover/smt/solver/sat/sat2goal.ts +72 -48
- package/src/prover/smt/solver/sat/simplifier.ts +1 -1
- package/src/prover/smt/solver/sat/solver.ts +27 -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-consequences.ts +1 -1
- package/src/prover/smt/solver/smt-kernel.ts +48 -7
- package/src/prover/smt/solver/smt-setup.ts +106 -13
- package/src/prover/smt/solver/smtlib-parser.ts +589 -224
- package/src/prover/smt/solver/smtlib-script.ts +713 -210
- 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 +350 -195
- 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-state.ts +1 -1
- 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/theory-without-terms.ts +24 -0
- 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 +1274 -257
- package/src/runtime.ts +7 -1
- package/src/sany/builtins.ts +10 -10
- package/src/sany/generation.ts +5 -15
- package/src/sany/generator-def-entries.ts +123 -36
- package/src/sany/generator-definitions.ts +5 -3
- package/src/sany/generator-expressions.ts +60 -37
- package/src/sany/generator-proofs.ts +18 -12
- package/src/sany/generator.ts +12 -6
- package/src/sany/lexer.ts +15 -7
- 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 +319 -135
- package/src/simulate.ts +235 -182
- package/src/spec-description.ts +8 -6
- package/src/standard-definitions.ts +1 -0
- package/src/standard-modules.ts +56 -22
- package/src/subexpressions.ts +564 -138
- package/src/successors.ts +37 -13
- package/src/symmetry.ts +2 -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 +67 -43
- 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/trace-liveness.ts +529 -0
- package/src/typed-tier.ts +52 -31
- package/src/typescript/types.ts +2 -2
- package/src/values.ts +150 -79
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,31 @@ 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 { parenthesizedRanges } from "./parser";
|
|
21
|
+
import { STANDARD_LEVELS } from "./standard-definitions";
|
|
22
|
+
import { resolveSynonym } from "./tlc/jar-data";
|
|
19
23
|
import {
|
|
24
|
+
compareLocations,
|
|
20
25
|
getArity,
|
|
21
26
|
getBinder,
|
|
22
27
|
getNameSelectors,
|
|
23
28
|
getOperandIndex,
|
|
24
29
|
getOperands,
|
|
30
|
+
getParamArities,
|
|
31
|
+
isBefore,
|
|
25
32
|
LOCAL_RESOLUTION,
|
|
33
|
+
nullSelections,
|
|
34
|
+
operatorSelectionErrors,
|
|
26
35
|
selectionErrors,
|
|
36
|
+
selectionArguments,
|
|
27
37
|
selections,
|
|
38
|
+
SELECTION_NAME,
|
|
39
|
+
factReferences,
|
|
40
|
+
generatedArgumentCounts,
|
|
41
|
+
type NullSelection,
|
|
42
|
+
type SelectionArguments,
|
|
28
43
|
} from "./resolve";
|
|
29
44
|
|
|
30
45
|
type Lookup = (name: string) => Definition | undefined;
|
|
@@ -32,6 +47,7 @@ type Lookup = (name: string) => Definition | undefined;
|
|
|
32
47
|
interface FoundLabel {
|
|
33
48
|
label: Expression & { kind: "Label" };
|
|
34
49
|
lets: Definition[][];
|
|
50
|
+
applications: Expression[];
|
|
35
51
|
}
|
|
36
52
|
|
|
37
53
|
interface Selection {
|
|
@@ -47,7 +63,48 @@ interface SelectingName {
|
|
|
47
63
|
argumentRanges?: (SourceRange | undefined)[];
|
|
48
64
|
}
|
|
49
65
|
|
|
50
|
-
const
|
|
66
|
+
const declaredArities = new WeakMap<Definition, number>();
|
|
67
|
+
|
|
68
|
+
const resolveDefinition = (
|
|
69
|
+
definition: Definition,
|
|
70
|
+
resolve: (expression: Expression) => Expression,
|
|
71
|
+
) => {
|
|
72
|
+
const resolved = mapDefinition(definition, resolve);
|
|
73
|
+
const arity = declaredArities.get(definition);
|
|
74
|
+
if (arity !== undefined) declaredArities.set(resolved, arity);
|
|
75
|
+
return resolved;
|
|
76
|
+
};
|
|
77
|
+
|
|
78
|
+
const setDeclaredArities = (declarations: Declaration[], definitions: Definition[]) =>
|
|
79
|
+
declarations.forEach((declaration) => {
|
|
80
|
+
const definition = definitions.find(
|
|
81
|
+
(candidate) => candidate.isRecursive && candidate.name === declaration.name,
|
|
82
|
+
);
|
|
83
|
+
if (definition) declaredArities.set(definition, declaration.arity);
|
|
84
|
+
});
|
|
85
|
+
|
|
86
|
+
const getSelectorName = (selector: Selector) => {
|
|
87
|
+
switch (selector.kind) {
|
|
88
|
+
case "Name":
|
|
89
|
+
return selector.name;
|
|
90
|
+
case "Operand":
|
|
91
|
+
return typeof selector.operand === "number"
|
|
92
|
+
? `argument selector ${selector.operand}`
|
|
93
|
+
: selector.operand;
|
|
94
|
+
case "Bound":
|
|
95
|
+
return "!(...)";
|
|
96
|
+
case "At":
|
|
97
|
+
return "@";
|
|
98
|
+
case "Colon":
|
|
99
|
+
return ":";
|
|
100
|
+
}
|
|
101
|
+
};
|
|
102
|
+
|
|
103
|
+
const getExpressionArguments = (
|
|
104
|
+
operator: string,
|
|
105
|
+
range: SourceRange | undefined,
|
|
106
|
+
args: Expression[],
|
|
107
|
+
): SelectionArguments => ({ operator, range, args, params: args.map(() => 0) });
|
|
51
108
|
|
|
52
109
|
const createError = (message: string, location: SourceLocation) =>
|
|
53
110
|
new TlaSyntaxError(`${message} at line ${location.line}, column ${location.column}`);
|
|
@@ -56,30 +113,47 @@ const findLabel = (
|
|
|
56
113
|
expression: Expression,
|
|
57
114
|
name: string,
|
|
58
115
|
lets: Definition[][],
|
|
116
|
+
applications: Expression[],
|
|
59
117
|
): FoundLabel | undefined => {
|
|
60
118
|
if (expression.kind === "Label") {
|
|
61
|
-
return expression.name === name ? { label: expression, lets } : undefined;
|
|
119
|
+
return expression.name === name ? { label: expression, lets, applications } : undefined;
|
|
62
120
|
}
|
|
63
121
|
if (expression.kind === "Let")
|
|
64
|
-
return findLabel(expression.body, name, [...lets, expression.definitions]);
|
|
65
|
-
if (expression.kind === "Lambda") return undefined;
|
|
66
|
-
|
|
67
|
-
|
|
122
|
+
return findLabel(expression.body, name, [...lets, expression.definitions], applications);
|
|
123
|
+
if (expression.kind === "Lambda" || expression.kind === "Selection") return undefined;
|
|
124
|
+
const generated = generatedArgumentCounts.get(expression);
|
|
125
|
+
const enclosing =
|
|
126
|
+
(expression.kind === "Apply" && generated === undefined) ||
|
|
127
|
+
expression.kind === "FunctionApplication"
|
|
128
|
+
? [...applications, expression]
|
|
129
|
+
: applications;
|
|
130
|
+
for (const child of getChildren(expression).slice(0, generated)) {
|
|
131
|
+
const isFunction = expression.kind === "FunctionApplication" && child === expression.function;
|
|
132
|
+
const found = findLabel(child, name, lets, isFunction ? applications : enclosing);
|
|
68
133
|
if (found) return found;
|
|
69
134
|
}
|
|
70
135
|
return undefined;
|
|
71
136
|
};
|
|
72
137
|
|
|
138
|
+
const getHiddenLocation = (location: SourceLocation) => ({
|
|
139
|
+
line: location.line,
|
|
140
|
+
column: location.column,
|
|
141
|
+
});
|
|
142
|
+
|
|
73
143
|
const wrapLets = (body: Expression, lets: Definition[][], location: SourceLocation) =>
|
|
74
144
|
lets.reduceRight<Expression>(
|
|
75
|
-
(inner, definitions) => ({
|
|
145
|
+
(inner, definitions) => ({
|
|
146
|
+
kind: "Let",
|
|
147
|
+
definitions,
|
|
148
|
+
body: inner,
|
|
149
|
+
location: getHiddenLocation(location),
|
|
150
|
+
}),
|
|
76
151
|
body,
|
|
77
152
|
);
|
|
78
153
|
|
|
79
154
|
const createApplication = (selection: Selection, body: Expression): Expression => {
|
|
80
155
|
const location = selection.location;
|
|
81
|
-
|
|
82
|
-
if (selection.params.length === 0) return wrapped;
|
|
156
|
+
if (selection.params.length === 0) return body;
|
|
83
157
|
if (selection.args.length === 0) {
|
|
84
158
|
if (selection.params.some((param) => param.arity > 0)) {
|
|
85
159
|
throw createError("Selected an operator with operator parameters as an argument", location);
|
|
@@ -87,7 +161,7 @@ const createApplication = (selection: Selection, body: Expression): Expression =
|
|
|
87
161
|
return {
|
|
88
162
|
kind: "Lambda",
|
|
89
163
|
params: selection.params.map((param) => param.name),
|
|
90
|
-
body
|
|
164
|
+
body,
|
|
91
165
|
location,
|
|
92
166
|
};
|
|
93
167
|
}
|
|
@@ -104,7 +178,7 @@ const createApplication = (selection: Selection, body: Expression): Expression =
|
|
|
104
178
|
kind: "Operator",
|
|
105
179
|
name: SELECTION_NAME,
|
|
106
180
|
params: selection.params,
|
|
107
|
-
body
|
|
181
|
+
body,
|
|
108
182
|
isLocal: true,
|
|
109
183
|
isRecursive: false,
|
|
110
184
|
location,
|
|
@@ -117,7 +191,7 @@ const createApplication = (selection: Selection, body: Expression): Expression =
|
|
|
117
191
|
location,
|
|
118
192
|
resolution: LOCAL_RESOLUTION,
|
|
119
193
|
},
|
|
120
|
-
location,
|
|
194
|
+
location: getHiddenLocation(location),
|
|
121
195
|
};
|
|
122
196
|
};
|
|
123
197
|
|
|
@@ -146,7 +220,10 @@ const applyDefinition = (definition: Definition, selection: Selection) => {
|
|
|
146
220
|
location,
|
|
147
221
|
resolution: LOCAL_RESOLUTION,
|
|
148
222
|
};
|
|
149
|
-
return createApplication(
|
|
223
|
+
return createApplication(
|
|
224
|
+
{ ...selection, params: [...selection.params, ...params] },
|
|
225
|
+
wrapLets(reference, selection.lets, location),
|
|
226
|
+
);
|
|
150
227
|
};
|
|
151
228
|
|
|
152
229
|
const selectSubexpression = (
|
|
@@ -158,58 +235,124 @@ const selectSubexpression = (
|
|
|
158
235
|
const location = reference.location;
|
|
159
236
|
const selection: Selection = { params: [], args: [], lets: [], location };
|
|
160
237
|
let selectorIndex = 0;
|
|
161
|
-
let
|
|
238
|
+
let operatorIndex = -1;
|
|
239
|
+
let current: Expression | undefined;
|
|
240
|
+
let unwrappedSelection: Expression | undefined;
|
|
162
241
|
let isFailed = false;
|
|
242
|
+
let generatedArguments = 0;
|
|
243
|
+
const nulls: NullSelection[] = [];
|
|
244
|
+
const applications: SelectionArguments[] = [];
|
|
245
|
+
let expressionError: SanyError | undefined;
|
|
246
|
+
const deferToExpression = (range: SourceRange | undefined, message: string) => {
|
|
247
|
+
if (!expressionError && range) expressionError = { location: formatRange(range), message };
|
|
248
|
+
};
|
|
249
|
+
const checkNull = (node: Expression | undefined, message: string, isEmpty = false) => {
|
|
250
|
+
const range = reference.selectorRanges?.[selectorIndex];
|
|
251
|
+
if (node && range) {
|
|
252
|
+
nulls.push({
|
|
253
|
+
node,
|
|
254
|
+
error: { location: formatRange(range), message },
|
|
255
|
+
isEmpty,
|
|
256
|
+
applications: [...applications],
|
|
257
|
+
});
|
|
258
|
+
}
|
|
259
|
+
};
|
|
163
260
|
|
|
164
261
|
const report = (range: SourceRange | undefined, message: string) => {
|
|
165
262
|
if (!range) throw createError(message, location);
|
|
166
263
|
selectionErrors.set(reference, {
|
|
167
|
-
|
|
168
|
-
|
|
169
|
-
.flatMap((selector) => ("args" in selector ? selector.args : [])),
|
|
264
|
+
applications,
|
|
265
|
+
nulls,
|
|
170
266
|
error: { location: formatRange(range), message },
|
|
171
267
|
});
|
|
268
|
+
generatedArgumentCounts.set(reference, generatedArguments);
|
|
172
269
|
isFailed = true;
|
|
173
270
|
return undefined;
|
|
174
271
|
};
|
|
175
272
|
|
|
176
273
|
const findDefinition = (local: Definition[] | undefined) => {
|
|
274
|
+
const start = reference.selectorRanges?.[selectorIndex];
|
|
177
275
|
const names: string[] = [];
|
|
178
276
|
const args: Expression[] = [];
|
|
179
277
|
while (selectorIndex < selectors.length) {
|
|
180
278
|
const selector = selectors[selectorIndex];
|
|
181
|
-
if (selector.kind !== "Name"
|
|
182
|
-
|
|
183
|
-
|
|
184
|
-
|
|
185
|
-
|
|
186
|
-
|
|
187
|
-
|
|
188
|
-
|
|
189
|
-
|
|
279
|
+
if (selector.kind !== "Name" && !local) return undefined;
|
|
280
|
+
if (selector.kind === "Name") {
|
|
281
|
+
names.push(selector.name);
|
|
282
|
+
args.push(...selector.args);
|
|
283
|
+
const name = names.join("!");
|
|
284
|
+
const definition = local
|
|
285
|
+
? local.find((candidate) => getSourceName(candidate) === name)
|
|
286
|
+
: lookup(name);
|
|
287
|
+
if (definition)
|
|
288
|
+
return { definition, name, args, earlier: args.length - selector.args.length };
|
|
289
|
+
}
|
|
190
290
|
selectorIndex++;
|
|
191
291
|
}
|
|
192
|
-
|
|
292
|
+
const end =
|
|
293
|
+
reference.selectorRanges?.[selectors.findLastIndex((selector) => selector.kind === "Name")];
|
|
294
|
+
return report(
|
|
295
|
+
start && end && { ...start, end: end.end },
|
|
296
|
+
`Unknown operator: \`${names.join("!")}'.`,
|
|
297
|
+
);
|
|
193
298
|
};
|
|
194
299
|
|
|
195
300
|
const enterDefinition = (local: Definition[] | undefined) => {
|
|
196
301
|
const found = findDefinition(local);
|
|
302
|
+
if (!found) {
|
|
303
|
+
isFailed = true;
|
|
304
|
+
return undefined;
|
|
305
|
+
}
|
|
197
306
|
const definition = found.definition;
|
|
198
|
-
const arity = getArity(definition);
|
|
307
|
+
const arity = declaredArities.get(definition) ?? getArity(definition);
|
|
199
308
|
const isLast = selectorIndex === selectors.length - 1;
|
|
200
|
-
if (found.args.length !== arity
|
|
309
|
+
if (found.args.length !== arity) {
|
|
310
|
+
const range = reference.argumentRanges?.[selectorIndex] ?? location.range;
|
|
311
|
+
const message = `The operator ${resolveSynonym(found.name)} requires ${arity - found.earlier} arguments.`;
|
|
312
|
+
if (!isOperator || found.args.length !== 0) {
|
|
313
|
+
generatedArguments += found.earlier;
|
|
314
|
+
return report(range, message);
|
|
315
|
+
}
|
|
316
|
+
deferToExpression(range, message);
|
|
317
|
+
}
|
|
318
|
+
generatedArguments += found.args.length;
|
|
319
|
+
found.args.forEach((arg, index) =>
|
|
320
|
+
selectionArguments.set(arg, {
|
|
321
|
+
operator: found.name,
|
|
322
|
+
index,
|
|
323
|
+
range: reference.selectorRanges?.[selectorIndex],
|
|
324
|
+
}),
|
|
325
|
+
);
|
|
326
|
+
if (isLast) return { definition, args: found.args };
|
|
327
|
+
const range = definition.location.range;
|
|
328
|
+
const isUndefined =
|
|
329
|
+
declaredArities.has(definition) &&
|
|
330
|
+
range?.module === location.range?.module &&
|
|
331
|
+
isBefore(location, definition.location);
|
|
332
|
+
applications.push({
|
|
333
|
+
operator: found.name,
|
|
334
|
+
range: reference.selectorRanges?.[selectorIndex],
|
|
335
|
+
args: found.args,
|
|
336
|
+
params: isUndefined ? Array(arity).fill(0) : getParamArities(definition),
|
|
337
|
+
});
|
|
338
|
+
if (
|
|
339
|
+
definition.isRecursive &&
|
|
340
|
+
range &&
|
|
341
|
+
range.module === location.range?.module &&
|
|
342
|
+
isBefore(location, range.end)
|
|
343
|
+
) {
|
|
201
344
|
return report(
|
|
202
|
-
reference.
|
|
203
|
-
`
|
|
345
|
+
reference.selectorRanges?.[selectorIndex],
|
|
346
|
+
`Subexpression of \`${found.name}' used inside the operator's definition.`,
|
|
204
347
|
);
|
|
205
348
|
}
|
|
206
|
-
if (isLast) return { definition, args: found.args };
|
|
207
349
|
if (definition.kind !== "Operator") {
|
|
208
350
|
throw createError(`Cannot select a subexpression of ${definition.name}`, location);
|
|
209
351
|
}
|
|
210
352
|
selection.params.push(...definition.params);
|
|
211
353
|
selection.args.push(...found.args);
|
|
212
354
|
current = definition.body;
|
|
355
|
+
operatorIndex = selectorIndex;
|
|
213
356
|
selectorIndex++;
|
|
214
357
|
return undefined;
|
|
215
358
|
};
|
|
@@ -219,15 +362,21 @@ const selectSubexpression = (
|
|
|
219
362
|
const selector = selectors[selectorIndex];
|
|
220
363
|
if (selector.kind !== "Name") return;
|
|
221
364
|
const range = reference.selectorRanges?.[selectorIndex];
|
|
222
|
-
const found = current && findLabel(current, selector.name, []);
|
|
223
|
-
|
|
365
|
+
const found = current && findLabel(current, selector.name, [], []);
|
|
366
|
+
const missing = `Cannot find label \`${selector.name}'.`;
|
|
367
|
+
if (!found) return report(range, missing);
|
|
368
|
+
found.applications.forEach((application) => checkNull(application, missing, true));
|
|
224
369
|
const params = found.label.params;
|
|
225
|
-
if (
|
|
226
|
-
|
|
370
|
+
if (selector.args.length !== params.length) {
|
|
371
|
+
const message = `Label \`${selector.name}' used with wrong number of arguments.`;
|
|
372
|
+
if (!isOperator) return report(range, message);
|
|
373
|
+
deferToExpression(range, message);
|
|
227
374
|
}
|
|
375
|
+
generatedArguments += selector.args.length;
|
|
228
376
|
selection.lets.push(...found.lets);
|
|
229
377
|
selection.params.push(...params.map((name) => ({ name, arity: 0 })));
|
|
230
378
|
selection.args.push(...selector.args);
|
|
379
|
+
applications.push(getExpressionArguments(selector.name, range, selector.args));
|
|
231
380
|
current = found.label.body;
|
|
232
381
|
selectorIndex++;
|
|
233
382
|
}
|
|
@@ -236,14 +385,35 @@ const selectSubexpression = (
|
|
|
236
385
|
const selectOperand = (selector: Selector) => {
|
|
237
386
|
if (!current) throw createError("Subexpression selection failed", location);
|
|
238
387
|
if (selector.kind === "Colon") return;
|
|
388
|
+
const range = reference.selectorRanges?.[selectorIndex];
|
|
389
|
+
const noOperands = `Choosing operand \`${getSelectorName(selector)}' of subexpression with no operands.`;
|
|
390
|
+
if (selectionErrors.has(current)) {
|
|
391
|
+
report(range, noOperands);
|
|
392
|
+
return;
|
|
393
|
+
}
|
|
394
|
+
if (selections.has(current) && current.kind !== "Lambda" && current !== unwrappedSelection) {
|
|
395
|
+
checkNull(current, noOperands, true);
|
|
396
|
+
unwrappedSelection = current;
|
|
397
|
+
current =
|
|
398
|
+
current.kind === "Let" &&
|
|
399
|
+
current.body.kind === "Apply" &&
|
|
400
|
+
current.body.operator === SELECTION_NAME
|
|
401
|
+
? current.body
|
|
402
|
+
: current.kind === "Selection"
|
|
403
|
+
? current
|
|
404
|
+
: // SANY wraps a selection without parameters in $Nop, whose only operand is the selection.
|
|
405
|
+
{ kind: "Tuple", elements: [current], location: current.location };
|
|
406
|
+
}
|
|
239
407
|
if (current.kind === "Label") {
|
|
240
408
|
current = current.body;
|
|
241
409
|
selectOperand(selector);
|
|
242
410
|
return;
|
|
243
411
|
}
|
|
412
|
+
const nonexistent = `Nonexistent operand specified by \`${getSelectorName(selector)}'.`;
|
|
244
413
|
if (current.kind === "Let") {
|
|
245
414
|
if (selector.kind !== "Operand" || getOperandIndex(selector.operand, 1) !== 0) {
|
|
246
|
-
|
|
415
|
+
report(range, "A LET/IN expression has only one operand.");
|
|
416
|
+
return;
|
|
247
417
|
}
|
|
248
418
|
selection.lets.push(current.definitions);
|
|
249
419
|
current = current.body;
|
|
@@ -251,33 +421,83 @@ const selectSubexpression = (
|
|
|
251
421
|
}
|
|
252
422
|
const binder = getBinder(current);
|
|
253
423
|
if (binder && (selector.kind === "Bound" || selector.kind === "At")) {
|
|
424
|
+
if (selector.kind === "Bound" && selector.args.length !== binder.names.length) {
|
|
425
|
+
report(
|
|
426
|
+
range,
|
|
427
|
+
`Selector with ${selector.args.length} argument(s) used for quantifier with ${binder.names.length} bound identifier(s).`,
|
|
428
|
+
);
|
|
429
|
+
return;
|
|
430
|
+
}
|
|
254
431
|
selection.params.push(...binder.names.map((name) => ({ name, arity: 0 })));
|
|
255
|
-
if (selector.kind === "Bound")
|
|
256
|
-
|
|
432
|
+
if (selector.kind === "Bound") {
|
|
433
|
+
generatedArguments += selector.args.length;
|
|
434
|
+
selection.args.push(...selector.args);
|
|
435
|
+
applications.push(getExpressionArguments("", range, selector.args));
|
|
436
|
+
}
|
|
437
|
+
current =
|
|
438
|
+
selections.has(current) && binder.body.kind === "Selection"
|
|
439
|
+
? binder.body.expression
|
|
440
|
+
: binder.body;
|
|
257
441
|
return;
|
|
258
442
|
}
|
|
259
|
-
if (current.kind === "Case"
|
|
443
|
+
if (current.kind === "Case") {
|
|
260
444
|
const arms = [
|
|
261
445
|
...current.arms,
|
|
262
446
|
...(current.other ? [{ condition: undefined, body: current.other }] : []),
|
|
263
447
|
];
|
|
264
|
-
|
|
265
|
-
|
|
266
|
-
|
|
267
|
-
|
|
448
|
+
if (selectorIndex === selectors.length - 1) {
|
|
449
|
+
report(range, "Subexpression of CASE must have form !i!j.");
|
|
450
|
+
return;
|
|
451
|
+
}
|
|
452
|
+
const arm =
|
|
453
|
+
selector.kind === "Operand"
|
|
454
|
+
? arms[getOperandIndex(selector.operand, arms.length)]
|
|
455
|
+
: undefined;
|
|
456
|
+
if (!arm) {
|
|
457
|
+
report(range, nonexistent);
|
|
458
|
+
return;
|
|
268
459
|
}
|
|
269
460
|
selectorIndex++;
|
|
270
|
-
const
|
|
271
|
-
const
|
|
272
|
-
|
|
461
|
+
const next = selectors[selectorIndex];
|
|
462
|
+
const part = next.kind === "Operand" ? getOperandIndex(next.operand, 2) : -1;
|
|
463
|
+
const nextRange = reference.selectorRanges?.[selectorIndex];
|
|
464
|
+
if (part === -1) {
|
|
465
|
+
report(
|
|
466
|
+
nextRange,
|
|
467
|
+
"Second selector for CASE subexpression must specify one of two operands.",
|
|
468
|
+
);
|
|
469
|
+
return;
|
|
470
|
+
}
|
|
471
|
+
const chosen = part === 0 ? arm.condition : arm.body;
|
|
472
|
+
if (!chosen) {
|
|
473
|
+
report(nextRange, "Selecting OTHER in a CASE statement.");
|
|
474
|
+
return;
|
|
475
|
+
}
|
|
273
476
|
current = chosen;
|
|
274
477
|
return;
|
|
275
478
|
}
|
|
276
|
-
if (
|
|
277
|
-
|
|
479
|
+
if (
|
|
480
|
+
current.kind === "Except" &&
|
|
481
|
+
selector.kind === "Operand" &&
|
|
482
|
+
getOperandIndex(selector.operand, current.updates.length + 1) > 0
|
|
483
|
+
) {
|
|
484
|
+
report(range, "Selecting subexpression of an EXCEPT not yet implemented.");
|
|
485
|
+
return;
|
|
486
|
+
}
|
|
278
487
|
const operands = binder ? binder.sets : getOperands(current);
|
|
488
|
+
if (!operands && current.kind !== "Identifier") {
|
|
489
|
+
report(range, "Selecting subexpression of expression that has none.");
|
|
490
|
+
return;
|
|
491
|
+
}
|
|
492
|
+
if (selector.kind !== "Operand") {
|
|
493
|
+
report(range, nonexistent);
|
|
494
|
+
return;
|
|
495
|
+
}
|
|
279
496
|
const operand = operands?.[getOperandIndex(selector.operand, operands.length)];
|
|
280
|
-
if (!operand)
|
|
497
|
+
if (!operand) {
|
|
498
|
+
report(range, nonexistent);
|
|
499
|
+
return;
|
|
500
|
+
}
|
|
281
501
|
current = operand;
|
|
282
502
|
};
|
|
283
503
|
|
|
@@ -290,7 +510,11 @@ const selectSubexpression = (
|
|
|
290
510
|
if (selector.kind === "Name") {
|
|
291
511
|
while (current?.kind === "Label") current = current.body;
|
|
292
512
|
if (current?.kind !== "Let") {
|
|
293
|
-
|
|
513
|
+
report(
|
|
514
|
+
reference.selectorRanges?.[selectorIndex - 1],
|
|
515
|
+
"A name selector here must be from a LET clause.",
|
|
516
|
+
);
|
|
517
|
+
return reference;
|
|
294
518
|
}
|
|
295
519
|
selection.lets.push(current.definitions);
|
|
296
520
|
const last = enterDefinition(current.definitions);
|
|
@@ -304,12 +528,74 @@ const selectSubexpression = (
|
|
|
304
528
|
followLabels();
|
|
305
529
|
continue;
|
|
306
530
|
}
|
|
531
|
+
if (selector.kind === "Colon" && selectors[selectorIndex - 1].kind !== "Name") {
|
|
532
|
+
report(
|
|
533
|
+
reference.selectorRanges?.[selectorIndex - 1],
|
|
534
|
+
"!: should not follow an operand selector.",
|
|
535
|
+
);
|
|
536
|
+
return reference;
|
|
537
|
+
}
|
|
538
|
+
if (
|
|
539
|
+
selector.kind === "Colon" &&
|
|
540
|
+
selectors[selectorIndex + 1]?.kind !== "Name" &&
|
|
541
|
+
(operatorIndex !== selectorIndex - 1 || selectorIndex !== selectors.length - 1)
|
|
542
|
+
) {
|
|
543
|
+
report(
|
|
544
|
+
reference.selectorRanges?.[selectorIndex],
|
|
545
|
+
"`!:' can be used only after a name and either at the end after an\noperator name or before an operator name.",
|
|
546
|
+
);
|
|
547
|
+
return reference;
|
|
548
|
+
}
|
|
549
|
+
if (selector.kind !== "Colon") {
|
|
550
|
+
checkNull(
|
|
551
|
+
current,
|
|
552
|
+
"Subexpression selection failed, probably due to an error in the selected expression.",
|
|
553
|
+
);
|
|
554
|
+
checkNull(
|
|
555
|
+
current,
|
|
556
|
+
`Choosing operand \`${getSelectorName(selector)}' of subexpression with no operands.`,
|
|
557
|
+
true,
|
|
558
|
+
);
|
|
559
|
+
}
|
|
307
560
|
selectOperand(selector);
|
|
561
|
+
checkNull(
|
|
562
|
+
current,
|
|
563
|
+
`An unexpected null node specified by '${getSelectorName(selectors[selectorIndex])}'.\nThis is probably due to a previous error.`,
|
|
564
|
+
);
|
|
308
565
|
selectorIndex++;
|
|
309
566
|
}
|
|
310
567
|
if (isFailed) return reference;
|
|
311
568
|
if (!current) throw createError("Subexpression selection failed", location);
|
|
312
|
-
|
|
569
|
+
const params = selection.params.length;
|
|
570
|
+
const args = selection.args.length;
|
|
571
|
+
if (params !== args) {
|
|
572
|
+
const message = `Expected ${params} arguments but found ${args}.`;
|
|
573
|
+
if (!isOperator || args > 0) {
|
|
574
|
+
report(location.range, message);
|
|
575
|
+
return reference;
|
|
576
|
+
}
|
|
577
|
+
deferToExpression(location.range, message);
|
|
578
|
+
}
|
|
579
|
+
const body = wrapLets(current, selection.lets, location);
|
|
580
|
+
const share = (expression: Expression): Expression => ({
|
|
581
|
+
kind: "Selection",
|
|
582
|
+
expression,
|
|
583
|
+
// SANY's $Nop, which TLC's call stack shows at the reference, wraps only a selection without parameters.
|
|
584
|
+
location:
|
|
585
|
+
selection.params.length === 0 && body.kind !== "Lambda"
|
|
586
|
+
? location
|
|
587
|
+
: getHiddenLocation(location),
|
|
588
|
+
});
|
|
589
|
+
// SANY selects a LAMBDA itself rather than wrapping it in $Nop, so the selection keeps its arity.
|
|
590
|
+
const selected = createApplication(
|
|
591
|
+
selection,
|
|
592
|
+
body.kind !== "Lambda"
|
|
593
|
+
? share(body)
|
|
594
|
+
: { ...body, body: selections.has(body) ? body.body : share(body.body), location },
|
|
595
|
+
);
|
|
596
|
+
nullSelections.set(selected, nulls);
|
|
597
|
+
if (expressionError) operatorSelectionErrors.set(selected, expressionError);
|
|
598
|
+
return selected;
|
|
313
599
|
};
|
|
314
600
|
|
|
315
601
|
const getQualifiedSelectors = (
|
|
@@ -338,18 +624,43 @@ const resolveSubexpressions = (
|
|
|
338
624
|
): Expression => {
|
|
339
625
|
if (!containsReference(expression)) return expression;
|
|
340
626
|
if (expression.kind === "Let") {
|
|
627
|
+
if (expression.recursive) setDeclaredArities(expression.recursive, expression.definitions);
|
|
628
|
+
const resolved: Definition[] = [];
|
|
341
629
|
const local: Lookup = (name) =>
|
|
342
|
-
|
|
343
|
-
|
|
344
|
-
|
|
630
|
+
resolved.find((definition) => definition.name === name) ??
|
|
631
|
+
expression.definitions.find((definition) => definition.name === name) ??
|
|
632
|
+
lookup(name);
|
|
633
|
+
const isLocalGoal = (name: string) =>
|
|
634
|
+
!expression.definitions.some((definition) => definition.name === name) && isGoal(name);
|
|
635
|
+
expression.definitions.forEach((definition) =>
|
|
636
|
+
resolved.push(
|
|
637
|
+
resolveDefinition(definition, (child) => resolveSubexpressions(child, local, isLocalGoal)),
|
|
638
|
+
),
|
|
639
|
+
);
|
|
640
|
+
const mapped = {
|
|
641
|
+
...expression,
|
|
642
|
+
definitions: resolved,
|
|
643
|
+
body: resolveSubexpressions(expression.body, local, isLocalGoal),
|
|
644
|
+
};
|
|
645
|
+
return mapped.instances
|
|
345
646
|
? {
|
|
346
647
|
...mapped,
|
|
347
|
-
instances: mapped.instances.map((instance) =>
|
|
648
|
+
instances: mapped.instances.map((instance) =>
|
|
649
|
+
resolveInstance(instance, local, isLocalGoal),
|
|
650
|
+
),
|
|
348
651
|
}
|
|
349
652
|
: mapped;
|
|
350
653
|
}
|
|
351
654
|
const callee = expression.kind === "Apply" ? lookup(expression.operator) : undefined;
|
|
352
|
-
|
|
655
|
+
// SANY expects an operator argument only of a user-defined operator, which a standard module's built-in operators stand for.
|
|
656
|
+
const calleeParams =
|
|
657
|
+
callee?.kind === "Operator"
|
|
658
|
+
? callee.params
|
|
659
|
+
: expression.kind === "Apply"
|
|
660
|
+
? STANDARD_LEVELS.get(expression.operator.slice(expression.operator.lastIndexOf("!") + 1))
|
|
661
|
+
?.formals
|
|
662
|
+
: undefined;
|
|
663
|
+
const rebuilt =
|
|
353
664
|
expression.kind === "Apply"
|
|
354
665
|
? {
|
|
355
666
|
...expression,
|
|
@@ -358,11 +669,15 @@ const resolveSubexpressions = (
|
|
|
358
669
|
arg,
|
|
359
670
|
lookup,
|
|
360
671
|
isGoal,
|
|
361
|
-
|
|
672
|
+
calleeParams !== undefined && calleeParams[index]?.arity !== 0,
|
|
362
673
|
),
|
|
363
674
|
),
|
|
364
675
|
}
|
|
365
676
|
: mapChildren(expression, (child) => resolveSubexpressions(child, lookup, isGoal));
|
|
677
|
+
const children = getChildren(expression);
|
|
678
|
+
const mapped = getChildren(rebuilt).every((child, index) => child === children[index])
|
|
679
|
+
? expression
|
|
680
|
+
: rebuilt;
|
|
366
681
|
const selectors =
|
|
367
682
|
mapped.kind === "Subexpression"
|
|
368
683
|
? mapped.selectors
|
|
@@ -372,9 +687,39 @@ const resolveSubexpressions = (
|
|
|
372
687
|
? getQualifiedSelectors(mapped.operator, mapped.args, mapped.argumentCounts, lookup)
|
|
373
688
|
: undefined;
|
|
374
689
|
const first = selectors?.[0];
|
|
375
|
-
|
|
690
|
+
const setGeneratedArguments = (count: number) => {
|
|
691
|
+
generatedArgumentCounts.set(expression, count);
|
|
692
|
+
generatedArgumentCounts.set(mapped, count);
|
|
693
|
+
};
|
|
694
|
+
if (!selectors) {
|
|
695
|
+
if (mapped.kind === "Apply" && mapped.operator.includes("!") && !lookup(mapped.operator)) {
|
|
696
|
+
setGeneratedArguments(0);
|
|
697
|
+
}
|
|
698
|
+
return mapped;
|
|
699
|
+
}
|
|
700
|
+
const nameCount = selectors.findIndex((selector) => selector.kind !== "Name");
|
|
701
|
+
const names = selectors.slice(0, nameCount === -1 ? selectors.length : nameCount);
|
|
702
|
+
const isQualified = names.some(
|
|
703
|
+
(_name, index) =>
|
|
704
|
+
index > 0 &&
|
|
705
|
+
lookup(
|
|
706
|
+
names
|
|
707
|
+
.slice(0, index + 1)
|
|
708
|
+
.map(getSelectorName)
|
|
709
|
+
.join("!"),
|
|
710
|
+
),
|
|
711
|
+
);
|
|
712
|
+
if (first?.kind === "Name" && isGoal(first.name) && !isQualified) return mapped;
|
|
713
|
+
if (first?.kind === "Name" && selectors[1].kind !== "Name" && !lookup(first.name)) {
|
|
714
|
+
setGeneratedArguments(0);
|
|
715
|
+
return mapped;
|
|
716
|
+
}
|
|
376
717
|
const selected = selectSubexpression(selectors, lookup, mapped, isOperator);
|
|
377
|
-
|
|
718
|
+
const generated = generatedArgumentCounts.get(mapped);
|
|
719
|
+
if (generated !== undefined) setGeneratedArguments(generated);
|
|
720
|
+
const parenthesized = parenthesizedRanges.get(expression);
|
|
721
|
+
if (parenthesized && selected !== mapped) parenthesizedRanges.set(selected, parenthesized);
|
|
722
|
+
if (selected !== mapped) selections.set(selected, mapped);
|
|
378
723
|
return selected;
|
|
379
724
|
};
|
|
380
725
|
|
|
@@ -427,100 +772,181 @@ export const resolveModuleSubexpressions = (module: Module, available: Definitio
|
|
|
427
772
|
},
|
|
428
773
|
];
|
|
429
774
|
});
|
|
430
|
-
const
|
|
775
|
+
const own = new Set([...module.definitions, ...clauses]);
|
|
776
|
+
setDeclaredArities(
|
|
777
|
+
module.units.flatMap((unit) => (unit.kind === "Recursive" ? unit.declarations : [])),
|
|
778
|
+
module.definitions,
|
|
779
|
+
);
|
|
780
|
+
const recursive = new Map(
|
|
781
|
+
module.units.flatMap((unit): [string, SourceLocation][] =>
|
|
782
|
+
unit.kind === "Recursive"
|
|
783
|
+
? unit.declarations.map((declaration) => [declaration.name, declaration.location])
|
|
784
|
+
: [],
|
|
785
|
+
),
|
|
786
|
+
);
|
|
787
|
+
const isDeclaredBefore = (definition: Definition, location: SourceLocation) => {
|
|
788
|
+
const declared = recursive.get(definition.name);
|
|
789
|
+
return (
|
|
790
|
+
isBefore(definition.location, location) ||
|
|
791
|
+
(definition.isRecursive && declared !== undefined && isBefore(declared, location))
|
|
792
|
+
);
|
|
793
|
+
};
|
|
794
|
+
const resolvedDefinitions = new Map<Definition, Definition>();
|
|
795
|
+
const getVisibleLookup =
|
|
796
|
+
(lookup: Lookup, location: SourceLocation): Lookup =>
|
|
797
|
+
(name) => {
|
|
798
|
+
const definition = lookup(name);
|
|
799
|
+
if (!definition || (own.has(definition) && !isDeclaredBefore(definition, location))) {
|
|
800
|
+
return undefined;
|
|
801
|
+
}
|
|
802
|
+
return resolvedDefinitions.get(definition) ?? definition;
|
|
803
|
+
};
|
|
804
|
+
const proofLookup = createLookup([...available, ...module.definitions]);
|
|
431
805
|
const isGoal = (name: string) => goals.has(name);
|
|
432
806
|
const definitionLookup = createLookup([...available, ...module.definitions, ...clauses]);
|
|
433
|
-
const resolve = (expression: Expression) =>
|
|
807
|
+
const resolve = (expression: Expression, location: SourceLocation) =>
|
|
434
808
|
resolveSubexpressions(
|
|
435
809
|
expression,
|
|
436
|
-
definitionLookup,
|
|
810
|
+
getVisibleLookup(definitionLookup, location),
|
|
437
811
|
(name) => isGoal(name) && clauses.every((clause) => clause.name !== name),
|
|
438
812
|
);
|
|
439
|
-
const
|
|
440
|
-
|
|
441
|
-
|
|
442
|
-
|
|
443
|
-
|
|
444
|
-
|
|
445
|
-
|
|
446
|
-
|
|
447
|
-
|
|
448
|
-
|
|
449
|
-
|
|
450
|
-
|
|
451
|
-
|
|
452
|
-
|
|
453
|
-
|
|
454
|
-
|
|
455
|
-
|
|
456
|
-
|
|
457
|
-
|
|
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"
|
|
813
|
+
const createProofResolver = (lookup: Lookup) => {
|
|
814
|
+
const isProofGoal = (name: string) => isGoal(name) || !lookup(name);
|
|
815
|
+
const resolveInProof = (expression: Expression) =>
|
|
816
|
+
resolveSubexpressions(expression, lookup, isProofGoal);
|
|
817
|
+
const resolveFacts = (facts: Fact[]) => {
|
|
818
|
+
const resolved = facts.map((fact) =>
|
|
819
|
+
fact.kind === "ModuleFact" ? fact : resolveInProof(fact),
|
|
820
|
+
);
|
|
821
|
+
factReferences.set(resolved, facts);
|
|
822
|
+
return resolved;
|
|
823
|
+
};
|
|
824
|
+
const resolveDefs = (defs: Fact[]) =>
|
|
825
|
+
defs.map((def) =>
|
|
826
|
+
def.kind === "ModuleFact" ? def : resolveSubexpressions(def, lookup, isProofGoal, true),
|
|
827
|
+
);
|
|
828
|
+
const resolveBounds = (bounds: Bound[]) =>
|
|
829
|
+
bounds.map((bound) => ({ ...bound, set: resolveInProof(bound.set) }));
|
|
830
|
+
const resolveStatement = (statement: Expression | AssumeProve): Expression | AssumeProve =>
|
|
831
|
+
statement.kind === "AssumeProve"
|
|
493
832
|
? {
|
|
494
|
-
...
|
|
495
|
-
|
|
496
|
-
|
|
497
|
-
|
|
498
|
-
|
|
499
|
-
|
|
833
|
+
...statement,
|
|
834
|
+
assumptions: statement.assumptions.map((assumption) =>
|
|
835
|
+
assumption.kind === "NewSymbol"
|
|
836
|
+
? { ...assumption, set: assumption.set && resolveInProof(assumption.set) }
|
|
837
|
+
: resolveStatement(assumption),
|
|
838
|
+
),
|
|
839
|
+
conclusion: resolveInProof(statement.conclusion),
|
|
500
840
|
}
|
|
501
|
-
:
|
|
502
|
-
|
|
503
|
-
|
|
504
|
-
|
|
505
|
-
|
|
506
|
-
|
|
507
|
-
|
|
508
|
-
|
|
509
|
-
|
|
510
|
-
|
|
511
|
-
|
|
512
|
-
|
|
841
|
+
: resolveInProof(statement);
|
|
842
|
+
const resolveStep = (body: StepBody): StepBody => {
|
|
843
|
+
switch (body.kind) {
|
|
844
|
+
case "Use":
|
|
845
|
+
case "Hide":
|
|
846
|
+
return { ...body, facts: resolveFacts(body.facts), defs: resolveDefs(body.defs) };
|
|
847
|
+
case "Instance":
|
|
848
|
+
return resolveInstance(body, lookup, isProofGoal);
|
|
849
|
+
case "Define":
|
|
850
|
+
return {
|
|
851
|
+
...body,
|
|
852
|
+
definitions: body.definitions.map((definition) =>
|
|
853
|
+
definition.kind === "Instance"
|
|
854
|
+
? resolveInstance(definition, lookup, isProofGoal)
|
|
855
|
+
: resolveDefinition(definition, resolveInProof),
|
|
856
|
+
),
|
|
857
|
+
};
|
|
858
|
+
case "Have":
|
|
859
|
+
case "Case":
|
|
860
|
+
return { ...body, expression: resolveInProof(body.expression) };
|
|
861
|
+
case "Witness":
|
|
862
|
+
return { ...body, expressions: body.expressions.map(resolveInProof) };
|
|
863
|
+
case "Take":
|
|
864
|
+
return { ...body, bounds: resolveBounds(body.bounds) };
|
|
865
|
+
case "Pick":
|
|
866
|
+
return { ...body, bounds: resolveBounds(body.bounds), body: resolveInProof(body.body) };
|
|
867
|
+
case "Assert":
|
|
868
|
+
return { ...body, statement: resolveStatement(body.statement) };
|
|
869
|
+
default:
|
|
870
|
+
return body;
|
|
871
|
+
}
|
|
872
|
+
};
|
|
873
|
+
const resolveProof = (proof: Proof | undefined): Proof | undefined => {
|
|
874
|
+
if (proof?.kind === "By") {
|
|
875
|
+
return { ...proof, facts: resolveFacts(proof.facts), defs: resolveDefs(proof.defs) };
|
|
876
|
+
}
|
|
877
|
+
if (proof?.kind !== "Steps") return proof;
|
|
878
|
+
let resolver = { lookup, resolveStep, resolveProof };
|
|
879
|
+
return {
|
|
880
|
+
...proof,
|
|
881
|
+
steps: proof.steps.map((step) => {
|
|
882
|
+
const resolved = {
|
|
883
|
+
...step,
|
|
884
|
+
body: resolver.resolveStep(step.body),
|
|
885
|
+
proof: resolver.resolveProof(step.proof),
|
|
886
|
+
};
|
|
887
|
+
if (resolved.body.kind === "Define") {
|
|
888
|
+
const definitions = resolved.body.definitions.flatMap((definition) =>
|
|
889
|
+
definition.kind === "Instance" ? [] : [definition],
|
|
890
|
+
);
|
|
891
|
+
const outer = resolver.lookup;
|
|
892
|
+
resolver = createProofResolver(
|
|
893
|
+
(name) => definitions.find((definition) => definition.name === name) ?? outer(name),
|
|
894
|
+
);
|
|
895
|
+
}
|
|
896
|
+
return resolved;
|
|
897
|
+
}),
|
|
898
|
+
};
|
|
899
|
+
};
|
|
900
|
+
return { lookup, resolveFacts, resolveDefs, resolveStatement, resolveStep, resolveProof };
|
|
513
901
|
};
|
|
514
902
|
const hasReferences =
|
|
515
903
|
module.definitions.some((definition) => containsReference(definition.body)) ||
|
|
516
904
|
module.assumptions.some((assumption) => containsReference(assumption.expression));
|
|
905
|
+
if (hasReferences) {
|
|
906
|
+
[...module.definitions, ...clauses]
|
|
907
|
+
.toSorted((left, right) => compareLocations(left.location, right.location))
|
|
908
|
+
.forEach((definition) =>
|
|
909
|
+
resolvedDefinitions.set(
|
|
910
|
+
definition,
|
|
911
|
+
resolveDefinition(definition, (expression) => resolve(expression, definition.location)),
|
|
912
|
+
),
|
|
913
|
+
);
|
|
914
|
+
}
|
|
915
|
+
const resolved = {
|
|
916
|
+
...module,
|
|
917
|
+
theorems: module.theorems.map((theorem) => {
|
|
918
|
+
const resolver = createProofResolver(getVisibleLookup(proofLookup, theorem.location));
|
|
919
|
+
return {
|
|
920
|
+
...theorem,
|
|
921
|
+
statement:
|
|
922
|
+
theorem.name !== undefined && theorem.statement.kind !== "AssumeProve"
|
|
923
|
+
? theorem.statement
|
|
924
|
+
: resolver.resolveStatement(theorem.statement),
|
|
925
|
+
proof:
|
|
926
|
+
theorem.proof &&
|
|
927
|
+
createProofResolver(getVisibleLookup(proofLookup, theorem.proof.location)).resolveProof(
|
|
928
|
+
theorem.proof,
|
|
929
|
+
),
|
|
930
|
+
};
|
|
931
|
+
}),
|
|
932
|
+
uses: module.uses.map((use) => {
|
|
933
|
+
const resolver = createProofResolver(getVisibleLookup(proofLookup, use.location));
|
|
934
|
+
return {
|
|
935
|
+
...use,
|
|
936
|
+
facts: resolver.resolveFacts(use.facts),
|
|
937
|
+
defs: resolver.resolveDefs(use.defs),
|
|
938
|
+
};
|
|
939
|
+
}),
|
|
940
|
+
};
|
|
517
941
|
if (!hasReferences) return resolved;
|
|
518
942
|
return {
|
|
519
943
|
...resolved,
|
|
520
|
-
definitions: module.definitions.map(
|
|
944
|
+
definitions: module.definitions.map(
|
|
945
|
+
(definition) => resolvedDefinitions.get(definition) ?? definition,
|
|
946
|
+
),
|
|
521
947
|
assumptions: module.assumptions.map((assumption) => ({
|
|
522
948
|
...assumption,
|
|
523
|
-
expression: resolve(assumption.expression),
|
|
949
|
+
expression: resolve(assumption.expression, assumption.location),
|
|
524
950
|
})),
|
|
525
951
|
};
|
|
526
952
|
};
|