tla-ts 0.0.10-dev.28c823e4b → 0.0.10-dev.63a6693bd
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 +6 -6
- package/dist/compile.js +10 -10
- package/dist/deciders.cjs +29 -29
- package/dist/deciders.js +40 -40
- package/dist/index.cjs +1 -1
- package/dist/index.js +1 -1
- package/dist/parallel-worker.cjs +1 -1
- package/dist/parallel-worker.js +1 -1
- package/dist/prove-worker.cjs +1 -1
- package/dist/prove-worker.js +1 -1
- package/dist/prove.cjs +54 -54
- package/dist/prove.js +52 -52
- package/dist/run.cjs +42 -42
- package/dist/run.js +44 -44
- package/dist/tlapm.cjs +2 -2
- package/dist/tlapm.js +2 -2
- package/dist/transfer.cjs +39 -39
- package/dist/transfer.js +41 -41
- package/dist/worker.cjs +4 -4
- package/dist/worker.js +4 -4
- package/package.json +1 -1
- package/src/ast.ts +44 -39
- package/src/builtins.ts +4 -13
- package/src/check-failure.ts +116 -0
- package/src/check-trace.ts +282 -0
- package/src/check.ts +152 -518
- package/src/cli/options.ts +6 -31
- package/src/cli/shared.ts +1 -1
- package/src/cli/tlapm.ts +14 -13
- package/src/cli/tlc-arguments.ts +222 -210
- package/src/cli/tlc-output.ts +687 -0
- package/src/cli/tlc-usage.ts +1 -1
- package/src/cli/tlc.ts +34 -701
- package/src/cli/xml-exporter.ts +23 -33
- package/src/codegen.ts +5 -10
- package/src/coverage.ts +3 -10
- package/src/dependencies.ts +8 -13
- package/src/dfid.ts +16 -16
- package/src/environment-config.ts +315 -0
- package/src/environment.ts +45 -333
- package/src/errors.ts +3 -2
- package/src/evaluate.ts +5 -4
- package/src/fingerprints.ts +65 -1
- package/src/instances.ts +47 -10
- package/src/java-hash.ts +7 -0
- package/src/json.ts +4 -7
- package/src/levels.ts +39 -42
- package/src/liveness-checker.ts +24 -37
- package/src/liveness.ts +47 -54
- package/src/obligations/action.ts +4 -11
- package/src/obligations/anonymize.ts +4 -2
- package/src/obligations/expression.ts +18 -2
- package/src/obligations/generate.ts +45 -38
- package/src/obligations/index.ts +2 -2
- package/src/obligations/module.ts +27 -38
- package/src/obligations/normalize.ts +2 -1
- package/src/obligations/simplify.ts +39 -44
- package/src/obligations/source.ts +47 -57
- package/src/obligations/temporal.ts +5 -5
- package/src/parallel-worker.ts +10 -30
- package/src/parallel.ts +22 -45
- package/src/parser.ts +19 -34
- package/src/prover/decide-pool.ts +3 -3
- package/src/prover/deciders.ts +3 -3
- package/src/prover/isabelle/encode.ts +1 -1
- package/src/prover/isabelle/isar/inner-syntax.ts +9 -4
- package/src/prover/isabelle/isar/method.ts +14 -25
- package/src/prover/isabelle/isar/theory.ts +11 -10
- package/src/prover/isabelle/isar/type-check.ts +6 -6
- package/src/prover/isabelle/provers/blast/blast.ts +7 -63
- package/src/prover/isabelle/provers/hypsubst.ts +17 -26
- package/src/prover/isabelle/pure/bicompose.ts +9 -25
- package/src/prover/isabelle/pure/conv.ts +2 -8
- package/src/prover/isabelle/pure/drule.ts +9 -2
- package/src/prover/isabelle/pure/logic.ts +1 -1
- package/src/prover/isabelle/pure/raw-simplifier.ts +4 -13
- package/src/prover/isabelle/pure/rewriter.ts +5 -9
- package/src/prover/isabelle/pure/table.ts +2 -1
- package/src/prover/isabelle/pure/tactical.ts +42 -35
- package/src/prover/isabelle/pure/thm.ts +14 -11
- package/src/prover/isabelle/tla/classical-setup.ts +17 -14
- package/src/prover/isabelle/tla/context.ts +7 -2
- package/src/prover/isabelle/tla/logic.ts +10 -21
- package/src/prover/isabelle/tla/simpdata.ts +1 -10
- package/src/prover/prep/action.ts +11 -19
- package/src/prover/prep/fingerprint.ts +2 -5
- package/src/prover/prep/methods.ts +24 -3
- package/src/prover/prove.ts +87 -64
- package/src/prover/smt/context.ts +1 -2
- package/src/prover/smt/data.ts +418 -406
- package/src/prover/smt/encode.ts +30 -18
- package/src/prover/smt/rewrite.ts +657 -626
- package/src/prover/smt/solver/ast.ts +0 -22
- package/src/prover/smt/solver/auf-solver.ts +2 -5
- package/src/prover/smt/solver/context.ts +3 -3
- package/src/prover/smt/solver/e-matching.ts +1 -1
- package/src/prover/smt/solver/expr-safe-replace.ts +1 -1
- package/src/prover/smt/solver/internalizer.ts +1 -2
- package/src/prover/smt/solver/lp/dioph-eq.ts +1 -8
- package/src/prover/smt/solver/lp/hnf-cutter.ts +1 -1
- package/src/prover/smt/solver/lp/nla-core.ts +2 -6
- package/src/prover/smt/solver/mam-compiler.ts +4 -2
- package/src/prover/smt/solver/model-checker.ts +1 -1
- package/src/prover/smt/solver/model-finder.ts +12 -17
- package/src/prover/smt/solver/model-macro-solver.ts +11 -19
- package/src/prover/smt/solver/nlsat/algebraic.ts +9 -9
- package/src/prover/smt/solver/nlsat/atoms.ts +20 -4
- package/src/prover/smt/solver/nlsat/explain.ts +7 -22
- package/src/prover/smt/solver/nlsat/levelwise.ts +1 -6
- package/src/prover/smt/solver/nlsat/polynomial.ts +12 -3
- package/src/prover/smt/solver/nlsat/solver.ts +12 -24
- package/src/prover/smt/solver/nlsat/upolynomial-factorization.ts +1 -1
- package/src/prover/smt/solver/proto-model.ts +0 -4
- package/src/prover/smt/solver/quantifier-analyzer.ts +10 -10
- package/src/prover/smt/solver/quantifier-manager.ts +1 -5
- package/src/prover/smt/solver/smtlib-parser.ts +78 -94
- package/src/prover/smt/solver/theory-lra-bounds.ts +1 -2
- package/src/prover/smt/solver/theory-lra-internalize.ts +5 -16
- package/src/prover/tlapm/cache.ts +28 -18
- package/src/prover/tlapm/tlapm.ts +15 -9
- package/src/prover/verdict.ts +7 -0
- package/src/prover/zenon/check/check.ts +1 -2
- package/src/prover/zenon/check/records.ts +1 -1
- package/src/prover/zenon/check/relations.ts +2 -1
- package/src/prover/zenon/check/rewrites.ts +2 -15
- package/src/prover/zenon/check/sets.ts +40 -58
- package/src/prover/zenon/check/terms.ts +1 -2
- package/src/prover/zenon/eqrel.ts +2 -0
- package/src/prover/zenon/expr.ts +7 -0
- package/src/prover/zenon/index-table.ts +9 -19
- package/src/prover/zenon/isar.ts +35 -35
- package/src/prover/zenon/llproof.ts +2 -11
- package/src/prover/zenon/mltoll.ts +12 -28
- package/src/prover/zenon/parse.ts +3 -6
- package/src/prover/zenon/search.ts +4 -14
- package/src/prover/zenon/tla/functions.ts +2 -2
- package/src/prover/zenon/tla/llproof.ts +9 -11
- package/src/prover/zenon/tla/records.ts +1 -6
- package/src/prover/zenon/tla/sets.ts +15 -14
- package/src/prover/zenon/tla/tla.ts +7 -6
- package/src/resolve.ts +55 -72
- package/src/sany/generation.ts +394 -0
- package/src/sany/generator-def-entries.ts +210 -0
- package/src/sany/generator-definitions.ts +686 -0
- package/src/sany/generator-expressions.ts +1100 -0
- package/src/sany/generator-proofs.ts +662 -0
- package/src/sany/generator.ts +155 -2625
- package/src/sany/lexer.ts +17 -16
- package/src/sany/nodes.ts +6 -13
- package/src/sany/report.ts +3 -6
- package/src/sany/selectors.ts +35 -38
- package/src/sany/xml.ts +23 -55
- package/src/search.ts +65 -27
- package/src/simulate.ts +157 -133
- package/src/spec-description.ts +33 -48
- package/src/standard-modules.ts +16 -32
- package/src/state-graph.ts +2 -7
- package/src/substitution-levels.ts +5 -4
- package/src/successors.ts +5 -7
- package/src/tlc/messages.ts +20 -15
- package/src/tlc/order.ts +2 -9
- package/src/tlc/random.ts +4 -4
- package/src/tlc/replay.ts +8 -15
- package/src/tlc/tlc-operators.ts +2 -3
- package/src/tlc/trace-spec.ts +25 -45
- package/src/typescript/actions.ts +2 -4
- package/src/typescript/collections.ts +34 -20
- package/src/typescript/compile.ts +1 -3
- package/src/typescript/formula.ts +5 -3
- package/src/typescript/model.ts +4 -5
- package/src/typescript/steps.ts +20 -18
- package/src/values.ts +63 -158
|
@@ -70,662 +70,693 @@ export interface Env {
|
|
|
70
70
|
rest: Env | undefined;
|
|
71
71
|
}
|
|
72
72
|
|
|
73
|
+
export interface Encoder {
|
|
74
|
+
session: EncodingSession;
|
|
75
|
+
flattener: ReturnType<typeof createFlattener>;
|
|
76
|
+
anonymous: Map<string, number>;
|
|
77
|
+
recordFields: Map<string, string[]>;
|
|
78
|
+
context: ReturnType<typeof createContext>;
|
|
79
|
+
declared: Map<string, Identifier>;
|
|
80
|
+
}
|
|
81
|
+
|
|
73
82
|
interface NestedContext {
|
|
74
83
|
env: Env | undefined;
|
|
75
84
|
mode: Mode;
|
|
76
85
|
wrappers: ((body: string) => string)[];
|
|
77
86
|
}
|
|
78
87
|
|
|
79
|
-
|
|
80
|
-
|
|
81
|
-
const flatten = flattener.flatten;
|
|
82
|
-
const anonymous = new Map<string, number>();
|
|
83
|
-
const recordFields = new Map<string, string[]>();
|
|
84
|
-
const context = createContext();
|
|
85
|
-
const declared = new Map<string, Identifier>();
|
|
88
|
+
const toBool = (term: Term) =>
|
|
89
|
+
term.isBool ? term.text : `(= ${resolveTriggers(term.text, true)} ${TT_IDV})`;
|
|
86
90
|
|
|
87
|
-
|
|
88
|
-
|
|
91
|
+
const toIdv = (term: Term) =>
|
|
92
|
+
term.isBool ? `(${CAST_BOOL} ${resolveTriggers(term.text, true)})` : term.text;
|
|
89
93
|
|
|
90
|
-
|
|
91
|
-
term.isBool ? `(${CAST_BOOL} ${resolveTriggers(term.text, true)})` : term.text;
|
|
94
|
+
const wrapBool = (text: string): Term => ({ isBool: true, text });
|
|
92
95
|
|
|
93
|
-
|
|
96
|
+
const wrapIdv = (text: string): Term => ({ isBool: false, text });
|
|
94
97
|
|
|
95
|
-
|
|
98
|
+
const getBinding = (env: Env | undefined, index: number): Binding => {
|
|
99
|
+
const found = Array.from({ length: index - 1 }).reduce<Env | undefined>(
|
|
100
|
+
(current) => current?.rest,
|
|
101
|
+
env,
|
|
102
|
+
);
|
|
103
|
+
if (!found) throw new TlaUnsupportedError("a reference outside the obligation");
|
|
104
|
+
return found.binding;
|
|
105
|
+
};
|
|
96
106
|
|
|
97
|
-
|
|
98
|
-
|
|
99
|
-
|
|
100
|
-
|
|
101
|
-
)
|
|
102
|
-
|
|
103
|
-
|
|
104
|
-
|
|
105
|
-
|
|
106
|
-
|
|
107
|
-
|
|
108
|
-
|
|
109
|
-
|
|
110
|
-
|
|
111
|
-
|
|
112
|
-
|
|
113
|
-
|
|
114
|
-
|
|
115
|
-
|
|
116
|
-
|
|
117
|
-
|
|
118
|
-
|
|
119
|
-
|
|
120
|
-
|
|
121
|
-
|
|
122
|
-
|
|
123
|
-
|
|
124
|
-
|
|
125
|
-
|
|
126
|
-
|
|
127
|
-
|
|
128
|
-
|
|
129
|
-
|
|
107
|
+
export const push = (env: Env | undefined, binding: Binding): Env => ({ binding, rest: env });
|
|
108
|
+
|
|
109
|
+
const getFree = (text: string, depth: number) =>
|
|
110
|
+
[...new Set(text.match(/[^\s()]+#\d+/g))]
|
|
111
|
+
.filter((variable) => getDepth(variable) < depth)
|
|
112
|
+
.toSorted((left, right) => getDepth(left) - getDepth(right));
|
|
113
|
+
|
|
114
|
+
export const getUniqueName = (encoder: Encoder, name: string) => {
|
|
115
|
+
const identifier = encoder.context.adjoin(name);
|
|
116
|
+
encoder.context.enter(identifier);
|
|
117
|
+
encoder.declared.set(identifier.name, identifier);
|
|
118
|
+
return identifier.name;
|
|
119
|
+
};
|
|
120
|
+
|
|
121
|
+
const clearPolarity = (mode: Mode): Mode => ({ ...mode, polarity: "Neither" });
|
|
122
|
+
|
|
123
|
+
const invert = (mode: Mode): Mode => ({
|
|
124
|
+
...mode,
|
|
125
|
+
polarity:
|
|
126
|
+
mode.polarity === "Positive"
|
|
127
|
+
? "Negative"
|
|
128
|
+
: mode.polarity === "Negative"
|
|
129
|
+
? "Positive"
|
|
130
|
+
: "Neither",
|
|
131
|
+
});
|
|
132
|
+
|
|
133
|
+
export const encodeIdv = (encoder: Encoder, expression: Expr, env: Env | undefined, mode: Mode) =>
|
|
134
|
+
toIdv(encode(encoder, expression, env, clearPolarity(mode)));
|
|
135
|
+
|
|
136
|
+
export const encodeBool = (encoder: Encoder, expression: Expr, env: Env | undefined, mode: Mode) =>
|
|
137
|
+
toBool(encode(encoder, expression, env, mode));
|
|
138
|
+
|
|
139
|
+
// tlapm's Rewrite encodes each Ditto's copy of a domain, so each copy flattens again.
|
|
140
|
+
const encodeDomains = (encoder: Encoder, bounds: Bound[], env: Env | undefined, mode: Mode) =>
|
|
141
|
+
bounds
|
|
142
|
+
.reduce<(Expr | undefined)[]>((domains, bound) => {
|
|
143
|
+
if (bound.domain.kind === "Ditto") return [...domains, domains.at(-1)];
|
|
144
|
+
if (bound.domain.kind === "NoDomain") return [...domains, undefined];
|
|
145
|
+
return [...domains, bound.domain.expression];
|
|
146
|
+
}, [])
|
|
147
|
+
.map((domain) => (domain === undefined ? undefined : encodeIdv(encoder, domain, env, mode)));
|
|
148
|
+
|
|
149
|
+
const getDomains = (
|
|
150
|
+
encoder: Encoder,
|
|
151
|
+
bounds: Bound[],
|
|
152
|
+
env: Env | undefined,
|
|
153
|
+
mode: Mode,
|
|
154
|
+
construct: string,
|
|
155
|
+
) =>
|
|
156
|
+
encodeDomains(encoder, bounds, env, mode).map((domain) => {
|
|
157
|
+
if (domain === undefined) throw new TlaUnsupportedError(`${construct} without a domain`);
|
|
158
|
+
return domain;
|
|
130
159
|
});
|
|
131
160
|
|
|
132
|
-
|
|
133
|
-
|
|
134
|
-
|
|
135
|
-
|
|
136
|
-
|
|
137
|
-
|
|
138
|
-
|
|
139
|
-
|
|
140
|
-
bounds
|
|
141
|
-
.reduce<(Expr | undefined)[]>((domains, bound) => {
|
|
142
|
-
if (bound.domain.kind === "Ditto") return [...domains, domains.at(-1)];
|
|
143
|
-
if (bound.domain.kind === "NoDomain") return [...domains, undefined];
|
|
144
|
-
return [...domains, bound.domain.expression];
|
|
145
|
-
}, [])
|
|
146
|
-
.map((domain) => (domain === undefined ? undefined : encodeIdv(domain, env, mode)));
|
|
147
|
-
|
|
148
|
-
const getDomains = (bounds: Bound[], env: Env | undefined, mode: Mode, construct: string) =>
|
|
149
|
-
encodeDomains(bounds, env, mode).map((domain) => {
|
|
150
|
-
if (domain === undefined) throw new TlaUnsupportedError(`${construct} without a domain`);
|
|
151
|
-
return domain;
|
|
152
|
-
});
|
|
153
|
-
|
|
154
|
-
const bindVariables = (names: string[], env: Env | undefined, mode: Mode) => {
|
|
155
|
-
const variables = names.map((name, index) => getVariable(name, mode.depth + index));
|
|
156
|
-
const inner = variables.reduce<Env | undefined>(
|
|
157
|
-
(current, symbol) => push(current, { kind: "constant", symbol }),
|
|
158
|
-
env,
|
|
159
|
-
);
|
|
160
|
-
return { variables, env: inner, mode: { ...mode, depth: mode.depth + names.length } };
|
|
161
|
-
};
|
|
162
|
-
|
|
163
|
-
const encodeQuantifier = (
|
|
164
|
-
expression: Extract<Expr, { kind: "Quant" }>,
|
|
165
|
-
env: Env | undefined,
|
|
166
|
-
mode: Mode,
|
|
167
|
-
) => {
|
|
168
|
-
const domains = encodeDomains(expression.bounds, env, mode);
|
|
169
|
-
const bound = bindVariables(
|
|
170
|
-
expression.bounds.map((innerBound) => innerBound.name),
|
|
171
|
-
env,
|
|
172
|
-
mode,
|
|
173
|
-
);
|
|
174
|
-
const body = encodeBool(expression.body, bound.env, bound.mode);
|
|
175
|
-
const guards = bound.variables.flatMap((variable, index) =>
|
|
176
|
-
domains[index] === undefined ? [] : [`(${MEM} ${variable} ${domains[index]})`],
|
|
177
|
-
);
|
|
178
|
-
return expression.quantifier === "Forall"
|
|
179
|
-
? `(forall (${getBinders(bound.variables)}) ${guards.length === 0 ? body : `(=> ${conjoin(guards)} ${body})`})`
|
|
180
|
-
: `(exists (${getBinders(bound.variables)}) ${conjoin([...guards, body])})`;
|
|
181
|
-
};
|
|
182
|
-
|
|
183
|
-
const encodeSetSt = (
|
|
184
|
-
expression: Extract<Expr, { kind: "SetSt" }>,
|
|
185
|
-
env: Env | undefined,
|
|
186
|
-
mode: Mode,
|
|
187
|
-
) => {
|
|
188
|
-
const domain = encodeIdv(expression.domain, env, mode);
|
|
189
|
-
const bound = bindVariables([expression.name], env, clearPolarity(mode));
|
|
190
|
-
const body = encodeBool(expression.body, bound.env, bound.mode);
|
|
191
|
-
const free = getFree(body, mode.depth);
|
|
192
|
-
const symbol = flatten(
|
|
193
|
-
"SetSt",
|
|
194
|
-
body,
|
|
195
|
-
mode,
|
|
196
|
-
(name) => getSetStAxioms(name, free, body, bound.variables[0]),
|
|
197
|
-
free.length + 1,
|
|
198
|
-
);
|
|
199
|
-
return wrapIdv(call(symbol, [domain, ...free]));
|
|
200
|
-
};
|
|
201
|
-
|
|
202
|
-
const encodeSetOf = (
|
|
203
|
-
expression: Extract<Expr, { kind: "SetOf" }>,
|
|
204
|
-
env: Env | undefined,
|
|
205
|
-
mode: Mode,
|
|
206
|
-
) => {
|
|
207
|
-
const domains = getDomains(expression.bounds, env, mode, "a set of values");
|
|
208
|
-
const bound = bindVariables(
|
|
209
|
-
expression.bounds.map((innerBound) => innerBound.name),
|
|
210
|
-
env,
|
|
211
|
-
clearPolarity(mode),
|
|
212
|
-
);
|
|
213
|
-
const element = encodeIdv(expression.element, bound.env, bound.mode);
|
|
214
|
-
const free = getFree(element, mode.depth);
|
|
215
|
-
const count = domains.length;
|
|
216
|
-
const symbol = flatten(
|
|
217
|
-
`SetOf_${count}`,
|
|
218
|
-
element,
|
|
219
|
-
mode,
|
|
220
|
-
(name) => getSetOfAxioms(name, free, element, bound.variables),
|
|
221
|
-
count + free.length,
|
|
222
|
-
);
|
|
223
|
-
return wrapIdv(call(symbol, [...domains, ...free]));
|
|
224
|
-
};
|
|
225
|
-
|
|
226
|
-
const encodeFunction = (
|
|
227
|
-
expression: Extract<Expr, { kind: "Fcn" }>,
|
|
228
|
-
env: Env | undefined,
|
|
229
|
-
mode: Mode,
|
|
230
|
-
) => {
|
|
231
|
-
const domains = getDomains(expression.bounds, env, mode, "a function");
|
|
232
|
-
const domain =
|
|
233
|
-
domains.length === 1 ? domains[0] : call(tla(`Product_${domains.length}`), domains);
|
|
234
|
-
const variable = getVariable(
|
|
235
|
-
domains.length === 1 ? expression.bounds[0].name : "x",
|
|
236
|
-
mode.depth,
|
|
237
|
-
);
|
|
238
|
-
const inner = { ...clearPolarity(mode), depth: mode.depth + 1 };
|
|
239
|
-
const bodyEnv =
|
|
240
|
-
domains.length === 1
|
|
241
|
-
? push(env, { kind: "constant", symbol: variable })
|
|
242
|
-
: getIntegers(domains.length).reduce<Env | undefined>(
|
|
243
|
-
(current, key) =>
|
|
244
|
-
push(current, { kind: "constant", symbol: `(${FUN_APP} ${variable} ${key})` }),
|
|
245
|
-
env,
|
|
246
|
-
);
|
|
247
|
-
const body = encodeIdv(expression.body, bodyEnv, inner);
|
|
248
|
-
const free = getFree(body, mode.depth);
|
|
249
|
-
const symbol = flatten(
|
|
250
|
-
"FunFcn",
|
|
251
|
-
body,
|
|
252
|
-
mode,
|
|
253
|
-
(name, axioms) => getFunctionAxioms(name, free, body, variable, axioms),
|
|
254
|
-
free.length + 1,
|
|
255
|
-
);
|
|
256
|
-
return wrapIdv(call(symbol, [domain, ...free]));
|
|
257
|
-
};
|
|
258
|
-
|
|
259
|
-
const encodeChoose = (
|
|
260
|
-
expression: Extract<Expr, { kind: "Choose" }>,
|
|
261
|
-
env: Env | undefined,
|
|
262
|
-
mode: Mode,
|
|
263
|
-
) => {
|
|
264
|
-
const bound = bindVariables([expression.name], env, clearPolarity(mode));
|
|
265
|
-
const variable = bound.variables[0];
|
|
266
|
-
const domain =
|
|
267
|
-
expression.domain && `(${MEM} ${variable} ${encodeIdv(expression.domain, env, mode)})`;
|
|
268
|
-
const predicate = encodeBool(expression.body, bound.env, bound.mode);
|
|
269
|
-
const body = domain === undefined ? predicate : conjoin([domain, predicate]);
|
|
270
|
-
const free = getFree(body, mode.depth);
|
|
271
|
-
const symbol = flatten(
|
|
272
|
-
"Choose",
|
|
273
|
-
body,
|
|
274
|
-
mode,
|
|
275
|
-
(name) => getChooseAxioms(name, free, body, variable),
|
|
276
|
-
free.length,
|
|
277
|
-
);
|
|
278
|
-
return wrapIdv(call(symbol, free));
|
|
279
|
-
};
|
|
280
|
-
|
|
281
|
-
const encodeEquality = (args: Expr[], env: Env | undefined, mode: Mode, isNegated: boolean) =>
|
|
282
|
-
getEquality(
|
|
283
|
-
encodeIdv(args[0], env, mode),
|
|
284
|
-
encodeIdv(args[1], env, mode),
|
|
285
|
-
mode.polarity,
|
|
286
|
-
isNegated,
|
|
287
|
-
);
|
|
161
|
+
const bindVariables = (names: string[], env: Env | undefined, mode: Mode) => {
|
|
162
|
+
const variables = names.map((name, index) => getVariable(name, mode.depth + index));
|
|
163
|
+
const inner = variables.reduce<Env | undefined>(
|
|
164
|
+
(current, symbol) => push(current, { kind: "constant", symbol }),
|
|
165
|
+
env,
|
|
166
|
+
);
|
|
167
|
+
return { variables, env: inner, mode: { ...mode, depth: mode.depth + names.length } };
|
|
168
|
+
};
|
|
288
169
|
|
|
289
|
-
|
|
290
|
-
|
|
291
|
-
|
|
292
|
-
|
|
293
|
-
|
|
294
|
-
|
|
295
|
-
|
|
296
|
-
|
|
297
|
-
|
|
298
|
-
|
|
299
|
-
|
|
300
|
-
|
|
301
|
-
|
|
302
|
-
|
|
303
|
-
|
|
304
|
-
|
|
305
|
-
|
|
306
|
-
|
|
307
|
-
|
|
308
|
-
|
|
309
|
-
|
|
310
|
-
|
|
311
|
-
|
|
312
|
-
|
|
313
|
-
|
|
314
|
-
|
|
315
|
-
|
|
316
|
-
|
|
317
|
-
|
|
318
|
-
|
|
319
|
-
|
|
320
|
-
|
|
321
|
-
|
|
322
|
-
|
|
323
|
-
|
|
324
|
-
|
|
325
|
-
|
|
326
|
-
|
|
327
|
-
|
|
328
|
-
|
|
329
|
-
|
|
330
|
-
|
|
331
|
-
|
|
332
|
-
|
|
333
|
-
|
|
334
|
-
|
|
335
|
-
|
|
336
|
-
|
|
337
|
-
|
|
338
|
-
|
|
339
|
-
|
|
340
|
-
|
|
341
|
-
|
|
342
|
-
|
|
343
|
-
|
|
344
|
-
|
|
345
|
-
|
|
346
|
-
|
|
347
|
-
|
|
348
|
-
|
|
349
|
-
|
|
350
|
-
|
|
351
|
-
|
|
352
|
-
|
|
353
|
-
|
|
354
|
-
|
|
355
|
-
|
|
356
|
-
|
|
170
|
+
const encodeQuantifier = (
|
|
171
|
+
encoder: Encoder,
|
|
172
|
+
expression: Extract<Expr, { kind: "Quant" }>,
|
|
173
|
+
env: Env | undefined,
|
|
174
|
+
mode: Mode,
|
|
175
|
+
) => {
|
|
176
|
+
const domains = encodeDomains(encoder, expression.bounds, env, mode);
|
|
177
|
+
const bound = bindVariables(
|
|
178
|
+
expression.bounds.map((innerBound) => innerBound.name),
|
|
179
|
+
env,
|
|
180
|
+
mode,
|
|
181
|
+
);
|
|
182
|
+
const body = encodeBool(encoder, expression.body, bound.env, bound.mode);
|
|
183
|
+
const guards = bound.variables.flatMap((variable, index) =>
|
|
184
|
+
domains[index] === undefined ? [] : [`(${MEM} ${variable} ${domains[index]})`],
|
|
185
|
+
);
|
|
186
|
+
return expression.quantifier === "Forall"
|
|
187
|
+
? `(forall (${getBinders(bound.variables)}) ${guards.length === 0 ? body : `(=> ${conjoin(guards)} ${body})`})`
|
|
188
|
+
: `(exists (${getBinders(bound.variables)}) ${conjoin([...guards, body])})`;
|
|
189
|
+
};
|
|
190
|
+
|
|
191
|
+
const encodeSetSt = (
|
|
192
|
+
encoder: Encoder,
|
|
193
|
+
expression: Extract<Expr, { kind: "SetSt" }>,
|
|
194
|
+
env: Env | undefined,
|
|
195
|
+
mode: Mode,
|
|
196
|
+
) => {
|
|
197
|
+
const domain = encodeIdv(encoder, expression.domain, env, mode);
|
|
198
|
+
const bound = bindVariables([expression.name], env, clearPolarity(mode));
|
|
199
|
+
const body = encodeBool(encoder, expression.body, bound.env, bound.mode);
|
|
200
|
+
const free = getFree(body, mode.depth);
|
|
201
|
+
const symbol = encoder.flattener.flatten(
|
|
202
|
+
"SetSt",
|
|
203
|
+
body,
|
|
204
|
+
mode,
|
|
205
|
+
(name) => getSetStAxioms(name, free, body, bound.variables[0]),
|
|
206
|
+
free.length + 1,
|
|
207
|
+
);
|
|
208
|
+
return wrapIdv(call(symbol, [domain, ...free]));
|
|
209
|
+
};
|
|
210
|
+
|
|
211
|
+
const encodeSetOf = (
|
|
212
|
+
encoder: Encoder,
|
|
213
|
+
expression: Extract<Expr, { kind: "SetOf" }>,
|
|
214
|
+
env: Env | undefined,
|
|
215
|
+
mode: Mode,
|
|
216
|
+
) => {
|
|
217
|
+
const domains = getDomains(encoder, expression.bounds, env, mode, "a set of values");
|
|
218
|
+
const bound = bindVariables(
|
|
219
|
+
expression.bounds.map((innerBound) => innerBound.name),
|
|
220
|
+
env,
|
|
221
|
+
clearPolarity(mode),
|
|
222
|
+
);
|
|
223
|
+
const element = encodeIdv(encoder, expression.element, bound.env, bound.mode);
|
|
224
|
+
const free = getFree(element, mode.depth);
|
|
225
|
+
const count = domains.length;
|
|
226
|
+
const symbol = encoder.flattener.flatten(
|
|
227
|
+
`SetOf_${count}`,
|
|
228
|
+
element,
|
|
229
|
+
mode,
|
|
230
|
+
(name) => getSetOfAxioms(name, free, element, bound.variables),
|
|
231
|
+
count + free.length,
|
|
232
|
+
);
|
|
233
|
+
return wrapIdv(call(symbol, [...domains, ...free]));
|
|
234
|
+
};
|
|
235
|
+
|
|
236
|
+
const encodeFunction = (
|
|
237
|
+
encoder: Encoder,
|
|
238
|
+
expression: Extract<Expr, { kind: "Fcn" }>,
|
|
239
|
+
env: Env | undefined,
|
|
240
|
+
mode: Mode,
|
|
241
|
+
) => {
|
|
242
|
+
const domains = getDomains(encoder, expression.bounds, env, mode, "a function");
|
|
243
|
+
const domain =
|
|
244
|
+
domains.length === 1 ? domains[0] : call(tla(`Product_${domains.length}`), domains);
|
|
245
|
+
const variable = getVariable(domains.length === 1 ? expression.bounds[0].name : "x", mode.depth);
|
|
246
|
+
const inner = { ...clearPolarity(mode), depth: mode.depth + 1 };
|
|
247
|
+
const bodyEnv =
|
|
248
|
+
domains.length === 1
|
|
249
|
+
? push(env, { kind: "constant", symbol: variable })
|
|
250
|
+
: getIntegers(domains.length).reduce<Env | undefined>(
|
|
251
|
+
(current, key) =>
|
|
252
|
+
push(current, { kind: "constant", symbol: `(${FUN_APP} ${variable} ${key})` }),
|
|
253
|
+
env,
|
|
357
254
|
);
|
|
358
|
-
|
|
359
|
-
|
|
360
|
-
|
|
361
|
-
|
|
362
|
-
|
|
363
|
-
|
|
364
|
-
|
|
365
|
-
|
|
366
|
-
|
|
367
|
-
|
|
368
|
-
|
|
255
|
+
const body = encodeIdv(encoder, expression.body, bodyEnv, inner);
|
|
256
|
+
const free = getFree(body, mode.depth);
|
|
257
|
+
const symbol = encoder.flattener.flatten(
|
|
258
|
+
"FunFcn",
|
|
259
|
+
body,
|
|
260
|
+
mode,
|
|
261
|
+
(name, axioms) => getFunctionAxioms(name, free, body, variable, axioms),
|
|
262
|
+
free.length + 1,
|
|
263
|
+
);
|
|
264
|
+
return wrapIdv(call(symbol, [domain, ...free]));
|
|
265
|
+
};
|
|
266
|
+
|
|
267
|
+
const encodeChoose = (
|
|
268
|
+
encoder: Encoder,
|
|
269
|
+
expression: Extract<Expr, { kind: "Choose" }>,
|
|
270
|
+
env: Env | undefined,
|
|
271
|
+
mode: Mode,
|
|
272
|
+
) => {
|
|
273
|
+
const bound = bindVariables([expression.name], env, clearPolarity(mode));
|
|
274
|
+
const variable = bound.variables[0];
|
|
275
|
+
const domain =
|
|
276
|
+
expression.domain && `(${MEM} ${variable} ${encodeIdv(encoder, expression.domain, env, mode)})`;
|
|
277
|
+
const predicate = encodeBool(encoder, expression.body, bound.env, bound.mode);
|
|
278
|
+
const body = domain === undefined ? predicate : conjoin([domain, predicate]);
|
|
279
|
+
const free = getFree(body, mode.depth);
|
|
280
|
+
const symbol = encoder.flattener.flatten(
|
|
281
|
+
"Choose",
|
|
282
|
+
body,
|
|
283
|
+
mode,
|
|
284
|
+
(name) => getChooseAxioms(name, free, body, variable),
|
|
285
|
+
free.length,
|
|
286
|
+
);
|
|
287
|
+
return wrapIdv(call(symbol, free));
|
|
288
|
+
};
|
|
289
|
+
|
|
290
|
+
const encodeEquality = (
|
|
291
|
+
encoder: Encoder,
|
|
292
|
+
args: Expr[],
|
|
293
|
+
env: Env | undefined,
|
|
294
|
+
mode: Mode,
|
|
295
|
+
isNegated: boolean,
|
|
296
|
+
) =>
|
|
297
|
+
getEquality(
|
|
298
|
+
encodeIdv(encoder, args[0], env, mode),
|
|
299
|
+
encodeIdv(encoder, args[1], env, mode),
|
|
300
|
+
mode.polarity,
|
|
301
|
+
isNegated,
|
|
302
|
+
);
|
|
303
|
+
|
|
304
|
+
const getSelectionTest = (encoder: Encoder, test: Expr, env: Env | undefined, mode: Mode) => {
|
|
305
|
+
const lambda = test.kind === "Lambda" && test.params.length === 1 ? test : undefined;
|
|
306
|
+
const bound = bindVariables([lambda?.params[0].name ?? "x1"], env, clearPolarity(mode));
|
|
307
|
+
const body = encodeBool(
|
|
308
|
+
encoder,
|
|
309
|
+
lambda?.body ?? {
|
|
310
|
+
kind: "Apply",
|
|
311
|
+
operator: shiftExpr(1, test),
|
|
312
|
+
args: [{ kind: "Ix", index: 1 }],
|
|
313
|
+
},
|
|
314
|
+
bound.env,
|
|
315
|
+
bound.mode,
|
|
316
|
+
);
|
|
317
|
+
return { body, variable: bound.variables[0] };
|
|
318
|
+
};
|
|
319
|
+
|
|
320
|
+
const encodeBuiltin = (
|
|
321
|
+
encoder: Encoder,
|
|
322
|
+
builtin: Builtin,
|
|
323
|
+
args: Expr[],
|
|
324
|
+
env: Env | undefined,
|
|
325
|
+
mode: Mode,
|
|
326
|
+
): Term => {
|
|
327
|
+
const encodeArgs = () => args.map((arg) => encodeIdv(encoder, arg, env, mode));
|
|
328
|
+
switch (builtin) {
|
|
329
|
+
case "Conj":
|
|
330
|
+
return wrapBool(conjoin(args.map((arg) => encodeBool(encoder, arg, env, mode))));
|
|
331
|
+
case "Disj":
|
|
332
|
+
return wrapBool(disjoin(args.map((arg) => encodeBool(encoder, arg, env, mode))));
|
|
333
|
+
case "Implies":
|
|
334
|
+
return wrapBool(
|
|
335
|
+
`(=> ${encodeBool(encoder, args[0], env, invert(mode))} ${encodeBool(encoder, args[1], env, mode)})`,
|
|
336
|
+
);
|
|
337
|
+
case "Equiv":
|
|
338
|
+
return wrapBool(
|
|
339
|
+
`(= ${args.map((arg) => encodeBool(encoder, arg, env, clearPolarity(mode))).join(" ")})`,
|
|
340
|
+
);
|
|
341
|
+
case "Neg":
|
|
342
|
+
return wrapBool(`(not ${encodeBool(encoder, args[0], env, invert(mode))})`);
|
|
343
|
+
case "Eq":
|
|
344
|
+
return wrapBool(encodeEquality(encoder, args, env, mode, false));
|
|
345
|
+
case "Neq":
|
|
346
|
+
return wrapBool(encodeEquality(encoder, args, env, mode, true));
|
|
347
|
+
case "Mem":
|
|
348
|
+
return wrapBool(call(MEM, encodeArgs()));
|
|
349
|
+
case "Notmem":
|
|
350
|
+
return wrapBool(`(not ${call(MEM, encodeArgs())})`);
|
|
351
|
+
case "Subseteq":
|
|
352
|
+
return wrapBool(call(SUBSET_EQ, encodeArgs()));
|
|
353
|
+
case "Lteq":
|
|
354
|
+
return wrapBool(call(INT_LTEQ, encodeArgs()));
|
|
355
|
+
case "Gteq":
|
|
356
|
+
return wrapBool(call(INT_LTEQ, encodeArgs().toReversed()));
|
|
357
|
+
case "Lt":
|
|
358
|
+
case "Gt": {
|
|
359
|
+
// Rewrite copies the operands before Flatten, which flattens each copy again.
|
|
360
|
+
const getOperands = () => (builtin === "Lt" ? encodeArgs() : encodeArgs().toReversed());
|
|
361
|
+
return wrapBool(
|
|
362
|
+
`(and ${call(INT_LTEQ, getOperands())} (distinct ${getOperands().join(" ")}))`,
|
|
363
|
+
);
|
|
369
364
|
}
|
|
370
|
-
|
|
371
|
-
|
|
372
|
-
|
|
373
|
-
|
|
374
|
-
|
|
375
|
-
|
|
376
|
-
|
|
377
|
-
|
|
378
|
-
|
|
379
|
-
|
|
380
|
-
|
|
381
|
-
if (args.length > 0) throw new TlaUnsupportedError(`an applied ${binding.kind}`);
|
|
382
|
-
return wrapIdv(binding.symbol);
|
|
383
|
-
case "operator":
|
|
384
|
-
if (args.length !== binding.arity)
|
|
385
|
-
throw new TlaUnsupportedError("an operator applied to the wrong number of arguments");
|
|
386
|
-
return wrapIdv(
|
|
387
|
-
call(
|
|
388
|
-
binding.symbol,
|
|
389
|
-
args.map((arg) => encodeIdv(arg, env, mode)),
|
|
390
|
-
),
|
|
391
|
-
);
|
|
392
|
-
case "secondOrder": {
|
|
393
|
-
if (args.length !== binding.shapes.length)
|
|
394
|
-
throw new TlaUnsupportedError("an operator applied to the wrong number of arguments");
|
|
395
|
-
const operands = args.map((arg, index) => {
|
|
396
|
-
if (binding.shapes[index] === 0)
|
|
397
|
-
return { isFirstOrder: true, text: encodeIdv(arg, env, mode) };
|
|
398
|
-
if (arg.kind === "Ix") {
|
|
399
|
-
const argument = getBinding(env, arg.index);
|
|
400
|
-
if (argument.kind !== "operator")
|
|
401
|
-
throw new TlaUnsupportedError("an operator argument that isn't a LAMBDA");
|
|
402
|
-
return { isFirstOrder: false, text: argument.symbol };
|
|
403
|
-
}
|
|
404
|
-
if (arg.kind !== "Lambda")
|
|
405
|
-
throw new TlaUnsupportedError("an operator argument that isn't a LAMBDA");
|
|
406
|
-
const bound = bindVariables(
|
|
407
|
-
arg.params.map((param) => param.name),
|
|
408
|
-
env,
|
|
409
|
-
clearPolarity(mode),
|
|
410
|
-
);
|
|
411
|
-
return { isFirstOrder: false, text: encodeIdv(arg.body, bound.env, bound.mode) };
|
|
412
|
-
});
|
|
413
|
-
const firstOrder = operands.flatMap((operand) =>
|
|
414
|
-
operand.isFirstOrder ? [operand.text] : [],
|
|
415
|
-
);
|
|
416
|
-
const higherOrder = operands.flatMap((operand) =>
|
|
417
|
-
operand.isFirstOrder ? [] : [operand.text],
|
|
418
|
-
);
|
|
419
|
-
const free = getFree(higherOrder.join(" "), mode.depth);
|
|
420
|
-
const symbol = flatten(
|
|
421
|
-
"",
|
|
422
|
-
higherOrder.join(" "),
|
|
423
|
-
mode,
|
|
424
|
-
() => [],
|
|
425
|
-
firstOrder.length + free.length,
|
|
426
|
-
binding.name,
|
|
427
|
-
);
|
|
428
|
-
return wrapIdv(call(symbol, [...firstOrder, ...free]));
|
|
429
|
-
}
|
|
430
|
-
case "unsupported":
|
|
431
|
-
throw new TlaUnsupportedError(binding.reason);
|
|
365
|
+
case "SelectSeq": {
|
|
366
|
+
const test = getSelectionTest(encoder, args[1], env, mode);
|
|
367
|
+
const free = getFree(test.body, mode.depth);
|
|
368
|
+
const symbol = encoder.flattener.flatten(
|
|
369
|
+
"SelectSeq",
|
|
370
|
+
test.body,
|
|
371
|
+
mode,
|
|
372
|
+
(name) => getSelectSeqAxioms(name, free, test.body, test.variable),
|
|
373
|
+
free.length + 1,
|
|
374
|
+
);
|
|
375
|
+
return wrapIdv(call(symbol, [encodeIdv(encoder, args[0], env, mode), ...free]));
|
|
432
376
|
}
|
|
433
|
-
|
|
434
|
-
|
|
435
|
-
|
|
436
|
-
|
|
437
|
-
|
|
438
|
-
|
|
439
|
-
|
|
440
|
-
|
|
441
|
-
|
|
442
|
-
|
|
443
|
-
|
|
444
|
-
if (args.length === 0 && name.endsWith("#prime"))
|
|
445
|
-
return wrapIdv(getPrimed(env, name.slice(0, -"#prime".length)));
|
|
446
|
-
const anonymousName = args.length === 0 ? `Anon_OPAQUE_${name}` : `Anon_${name}`;
|
|
447
|
-
anonymous.set(anonymousName, args.length);
|
|
448
|
-
return wrapIdv(
|
|
449
|
-
call(
|
|
450
|
-
tla(anonymousName),
|
|
451
|
-
args.map((arg) => encodeIdv(arg, env, mode)),
|
|
452
|
-
),
|
|
453
|
-
);
|
|
454
|
-
};
|
|
455
|
-
|
|
456
|
-
const encodeExcept = (
|
|
457
|
-
expression: Extract<Expr, { kind: "Except" }>,
|
|
458
|
-
env: Env | undefined,
|
|
459
|
-
mode: Mode,
|
|
460
|
-
) =>
|
|
461
|
-
expression.specs.reduce(
|
|
462
|
-
(base, spec) => {
|
|
463
|
-
const update = (value: string, trail: typeof spec.trail): string => {
|
|
464
|
-
if (trail.length === 0) return encodeIdv(spec.value, env, { ...mode, at: value });
|
|
465
|
-
const point = trail[0];
|
|
466
|
-
const encodeKey = () =>
|
|
467
|
-
point.kind === "Dot"
|
|
468
|
-
? tla(`StrLit_${point.field}`)
|
|
469
|
-
: encodeIdv(point.expression, env, mode);
|
|
470
|
-
const key = encodeKey();
|
|
471
|
-
// Elab.desugar repeats the key in the value it updates, and Flatten counts both.
|
|
472
|
-
const inner = update(
|
|
473
|
-
`(${FUN_APP} ${value} ${trail.length > 1 ? encodeKey() : key})`,
|
|
474
|
-
trail.slice(1),
|
|
475
|
-
);
|
|
476
|
-
return `(${FUN_EXCEPT} ${value} ${key} ${inner})`;
|
|
477
|
-
};
|
|
478
|
-
return update(base, spec.trail);
|
|
479
|
-
},
|
|
480
|
-
encodeIdv(expression.function, env, mode),
|
|
481
|
-
);
|
|
377
|
+
case "Unprimable": {
|
|
378
|
+
const term = encode(encoder, args[0], env, clearPolarity(mode));
|
|
379
|
+
return { ...term, text: `(${UNPRIMABLE} ${term.text})` };
|
|
380
|
+
}
|
|
381
|
+
default: {
|
|
382
|
+
const symbol = BUILTIN_SYMBOLS[builtin];
|
|
383
|
+
if (symbol === undefined) throw new TlaUnsupportedError(`the operator ${builtin}`);
|
|
384
|
+
return wrapIdv(call(symbol, encodeArgs()));
|
|
385
|
+
}
|
|
386
|
+
}
|
|
387
|
+
};
|
|
482
388
|
|
|
483
|
-
|
|
484
|
-
|
|
485
|
-
|
|
486
|
-
|
|
487
|
-
|
|
488
|
-
|
|
489
|
-
|
|
490
|
-
|
|
491
|
-
|
|
492
|
-
|
|
493
|
-
|
|
494
|
-
|
|
495
|
-
|
|
496
|
-
|
|
497
|
-
|
|
498
|
-
|
|
499
|
-
|
|
500
|
-
|
|
501
|
-
|
|
502
|
-
|
|
503
|
-
const integer = expression.arms.reduceRight(
|
|
504
|
-
(rest, arm, index) =>
|
|
505
|
-
`(ite ${encodeBool(arm.condition, env, clearPolarity(mode))} ${bodies[index].integer} ${rest})`,
|
|
506
|
-
other.integer ?? "",
|
|
389
|
+
const encodeReference = (
|
|
390
|
+
encoder: Encoder,
|
|
391
|
+
binding: Binding,
|
|
392
|
+
args: Expr[],
|
|
393
|
+
env: Env | undefined,
|
|
394
|
+
mode: Mode,
|
|
395
|
+
): Term => {
|
|
396
|
+
switch (binding.kind) {
|
|
397
|
+
case "constant":
|
|
398
|
+
case "variable":
|
|
399
|
+
if (args.length > 0) throw new TlaUnsupportedError(`an applied ${binding.kind}`);
|
|
400
|
+
return wrapIdv(binding.symbol);
|
|
401
|
+
case "operator":
|
|
402
|
+
if (args.length !== binding.arity)
|
|
403
|
+
throw new TlaUnsupportedError("an operator applied to the wrong number of arguments");
|
|
404
|
+
return wrapIdv(
|
|
405
|
+
call(
|
|
406
|
+
binding.symbol,
|
|
407
|
+
args.map((arg) => encodeIdv(encoder, arg, env, mode)),
|
|
408
|
+
),
|
|
507
409
|
);
|
|
508
|
-
|
|
410
|
+
case "secondOrder": {
|
|
411
|
+
if (args.length !== binding.shapes.length)
|
|
412
|
+
throw new TlaUnsupportedError("an operator applied to the wrong number of arguments");
|
|
413
|
+
const operands = args.map((arg, index) => {
|
|
414
|
+
if (binding.shapes[index] === 0)
|
|
415
|
+
return { isFirstOrder: true, text: encodeIdv(encoder, arg, env, mode) };
|
|
416
|
+
if (arg.kind === "Ix") {
|
|
417
|
+
const argument = getBinding(env, arg.index);
|
|
418
|
+
if (argument.kind !== "operator")
|
|
419
|
+
throw new TlaUnsupportedError("an operator argument that isn't a LAMBDA");
|
|
420
|
+
return { isFirstOrder: false, text: argument.symbol };
|
|
421
|
+
}
|
|
422
|
+
if (arg.kind !== "Lambda")
|
|
423
|
+
throw new TlaUnsupportedError("an operator argument that isn't a LAMBDA");
|
|
424
|
+
const bound = bindVariables(
|
|
425
|
+
arg.params.map((param) => param.name),
|
|
426
|
+
env,
|
|
427
|
+
clearPolarity(mode),
|
|
428
|
+
);
|
|
429
|
+
return { isFirstOrder: false, text: encodeIdv(encoder, arg.body, bound.env, bound.mode) };
|
|
430
|
+
});
|
|
431
|
+
const firstOrder = operands.flatMap((operand) =>
|
|
432
|
+
operand.isFirstOrder ? [operand.text] : [],
|
|
433
|
+
);
|
|
434
|
+
const higherOrder = operands.flatMap((operand) =>
|
|
435
|
+
operand.isFirstOrder ? [] : [operand.text],
|
|
436
|
+
);
|
|
437
|
+
const free = getFree(higherOrder.join(" "), mode.depth);
|
|
438
|
+
const symbol = encoder.flattener.flatten(
|
|
439
|
+
"",
|
|
440
|
+
higherOrder.join(" "),
|
|
441
|
+
mode,
|
|
442
|
+
() => [],
|
|
443
|
+
firstOrder.length + free.length,
|
|
444
|
+
binding.name,
|
|
445
|
+
);
|
|
446
|
+
return wrapIdv(call(symbol, [...firstOrder, ...free]));
|
|
509
447
|
}
|
|
510
|
-
|
|
511
|
-
|
|
448
|
+
case "unsupported":
|
|
449
|
+
throw new TlaUnsupportedError(binding.reason);
|
|
450
|
+
}
|
|
451
|
+
};
|
|
452
|
+
|
|
453
|
+
const getPrimed = (env: Env | undefined, name: string): string => {
|
|
454
|
+
if (!env) throw new TlaUnsupportedError(`a primed declaration that isn't a variable`);
|
|
455
|
+
const binding = env.binding;
|
|
456
|
+
return binding.kind === "variable" && binding.name === name
|
|
457
|
+
? binding.primed
|
|
458
|
+
: getPrimed(env.rest, name);
|
|
459
|
+
};
|
|
460
|
+
|
|
461
|
+
const encodeOpaque = (
|
|
462
|
+
encoder: Encoder,
|
|
463
|
+
name: string,
|
|
464
|
+
args: Expr[],
|
|
465
|
+
env: Env | undefined,
|
|
466
|
+
mode: Mode,
|
|
467
|
+
) => {
|
|
468
|
+
if (args.length === 0 && name.endsWith("#prime"))
|
|
469
|
+
return wrapIdv(getPrimed(env, name.slice(0, -"#prime".length)));
|
|
470
|
+
const anonymousName = args.length === 0 ? `Anon_OPAQUE_${name}` : `Anon_${name}`;
|
|
471
|
+
encoder.anonymous.set(anonymousName, args.length);
|
|
472
|
+
return wrapIdv(
|
|
473
|
+
call(
|
|
474
|
+
tla(anonymousName),
|
|
475
|
+
args.map((arg) => encodeIdv(encoder, arg, env, mode)),
|
|
476
|
+
),
|
|
477
|
+
);
|
|
478
|
+
};
|
|
479
|
+
|
|
480
|
+
const encodeExcept = (
|
|
481
|
+
encoder: Encoder,
|
|
482
|
+
expression: Extract<Expr, { kind: "Except" }>,
|
|
483
|
+
env: Env | undefined,
|
|
484
|
+
mode: Mode,
|
|
485
|
+
) =>
|
|
486
|
+
expression.specs.reduce(
|
|
487
|
+
(base, spec) => {
|
|
488
|
+
const update = (value: string, trail: typeof spec.trail): string => {
|
|
489
|
+
if (trail.length === 0) return encodeIdv(encoder, spec.value, env, { ...mode, at: value });
|
|
490
|
+
const point = trail[0];
|
|
491
|
+
const encodeKey = () =>
|
|
492
|
+
point.kind === "Dot"
|
|
493
|
+
? tla(`StrLit_${point.field}`)
|
|
494
|
+
: encodeIdv(encoder, point.expression, env, mode);
|
|
495
|
+
const key = encodeKey();
|
|
496
|
+
// Elab.desugar repeats the key in the value it updates, and Flatten counts both.
|
|
497
|
+
const inner = update(
|
|
498
|
+
`(${FUN_APP} ${value} ${trail.length > 1 ? encodeKey() : key})`,
|
|
499
|
+
trail.slice(1),
|
|
500
|
+
);
|
|
501
|
+
return `(${FUN_EXCEPT} ${value} ${key} ${inner})`;
|
|
502
|
+
};
|
|
503
|
+
return update(base, spec.trail);
|
|
504
|
+
},
|
|
505
|
+
encodeIdv(encoder, expression.function, env, mode),
|
|
506
|
+
);
|
|
507
|
+
|
|
508
|
+
const getCaseError = (encoder: Encoder) => {
|
|
509
|
+
encoder.session.caseErrors++;
|
|
510
|
+
const name = `Anon_incomplete_case_error_${encoder.session.caseErrors}`;
|
|
511
|
+
encoder.anonymous.set(name, 0);
|
|
512
|
+
return tla(name);
|
|
513
|
+
};
|
|
514
|
+
|
|
515
|
+
const encodeCase = (
|
|
516
|
+
encoder: Encoder,
|
|
517
|
+
expression: Extract<Expr, { kind: "Case" }>,
|
|
518
|
+
env: Env | undefined,
|
|
519
|
+
mode: Mode,
|
|
520
|
+
): Term => {
|
|
521
|
+
const bodies = expression.arms.map((arm) => encode(encoder, arm.body, env, mode));
|
|
522
|
+
const other: Term = expression.other
|
|
523
|
+
? encode(encoder, expression.other, env, mode)
|
|
524
|
+
: wrapIdv(getCaseError(encoder));
|
|
525
|
+
const isBool = other.isBool && bodies.every((body) => body.isBool);
|
|
526
|
+
const isInteger =
|
|
527
|
+
other.integer !== undefined && bodies.every((body) => body.integer !== undefined);
|
|
528
|
+
if (isInteger) {
|
|
529
|
+
const integer = expression.arms.reduceRight(
|
|
512
530
|
(rest, arm, index) =>
|
|
513
|
-
`(ite ${encodeBool(arm.condition, env, mode)} ${
|
|
514
|
-
|
|
531
|
+
`(ite ${encodeBool(encoder, arm.condition, env, clearPolarity(mode))} ${bodies[index].integer} ${rest})`,
|
|
532
|
+
other.integer ?? "",
|
|
515
533
|
);
|
|
516
|
-
return { isBool, text };
|
|
517
|
-
}
|
|
518
|
-
|
|
519
|
-
const
|
|
520
|
-
|
|
521
|
-
(
|
|
522
|
-
|
|
523
|
-
|
|
524
|
-
|
|
525
|
-
|
|
526
|
-
|
|
527
|
-
|
|
528
|
-
|
|
529
|
-
|
|
530
|
-
|
|
531
|
-
|
|
532
|
-
|
|
533
|
-
|
|
534
|
-
|
|
535
|
-
|
|
536
|
-
|
|
537
|
-
|
|
538
|
-
|
|
539
|
-
|
|
540
|
-
env: bound.env,
|
|
541
|
-
mode: bound.mode,
|
|
542
|
-
wrappers: [
|
|
543
|
-
...state.wrappers,
|
|
544
|
-
(body) => `(forall ((${variable} Idv)) ${guard ? `(=> ${guard} ${body})` : body})`,
|
|
545
|
-
],
|
|
546
|
-
};
|
|
547
|
-
}
|
|
548
|
-
case "Fact": {
|
|
549
|
-
const fact =
|
|
550
|
-
hyp.visibility === "Visible"
|
|
551
|
-
? encodeBool(hyp.expression, state.env, invert(state.mode))
|
|
552
|
-
: undefined;
|
|
534
|
+
return { isBool: false, text: `(${CAST_INT} ${integer})`, integer };
|
|
535
|
+
}
|
|
536
|
+
const convert = (term: Term) => (isBool ? term.text : toIdv(term));
|
|
537
|
+
const text = expression.arms.reduceRight(
|
|
538
|
+
(rest, arm, index) =>
|
|
539
|
+
`(ite ${encodeBool(encoder, arm.condition, env, mode)} ${convert(bodies[index])} ${rest})`,
|
|
540
|
+
convert(other),
|
|
541
|
+
);
|
|
542
|
+
return { isBool, text };
|
|
543
|
+
};
|
|
544
|
+
|
|
545
|
+
const encodeSequent = (
|
|
546
|
+
encoder: Encoder,
|
|
547
|
+
sequent: Sequent,
|
|
548
|
+
env: Env | undefined,
|
|
549
|
+
mode: Mode,
|
|
550
|
+
): string => {
|
|
551
|
+
const steps = sequent.context.reduce<NestedContext>(
|
|
552
|
+
(state, hyp) => {
|
|
553
|
+
switch (hyp.kind) {
|
|
554
|
+
case "Fresh": {
|
|
555
|
+
if (hyp.shape > 0) {
|
|
556
|
+
if (!state.mode.isOmitted) throw new TlaUnsupportedError("a second-order ASSUME");
|
|
557
|
+
const variable = getVariable(hyp.name, state.mode.depth);
|
|
553
558
|
return {
|
|
554
|
-
env: push(state.env, { kind: "
|
|
555
|
-
mode: state.mode,
|
|
556
|
-
wrappers:
|
|
557
|
-
? [...state.wrappers, (body) => `(=> ${fact} ${body})`]
|
|
558
|
-
: state.wrappers,
|
|
559
|
+
env: push(state.env, { kind: "operator", symbol: variable, arity: hyp.shape }),
|
|
560
|
+
mode: { ...state.mode, depth: state.mode.depth + 1 },
|
|
561
|
+
wrappers: [...state.wrappers, (body) => `(forall ((${variable} Idv)) ${body})`],
|
|
559
562
|
};
|
|
560
563
|
}
|
|
561
|
-
|
|
562
|
-
throw new TlaUnsupportedError(
|
|
564
|
+
if (hyp.level !== "Constant")
|
|
565
|
+
throw new TlaUnsupportedError("a NEW declaration that isn't constant");
|
|
566
|
+
const domain = hyp.domain && encodeIdv(encoder, hyp.domain, state.env, state.mode);
|
|
567
|
+
const bound = bindVariables([hyp.name], state.env, state.mode);
|
|
568
|
+
const variable = bound.variables[0];
|
|
569
|
+
const guard = domain && `(${MEM} ${variable} ${domain})`;
|
|
570
|
+
return {
|
|
571
|
+
env: bound.env,
|
|
572
|
+
mode: bound.mode,
|
|
573
|
+
wrappers: [
|
|
574
|
+
...state.wrappers,
|
|
575
|
+
(body) => `(forall ((${variable} Idv)) ${guard ? `(=> ${guard} ${body})` : body})`,
|
|
576
|
+
],
|
|
577
|
+
};
|
|
563
578
|
}
|
|
564
|
-
|
|
565
|
-
|
|
566
|
-
|
|
567
|
-
|
|
568
|
-
|
|
569
|
-
|
|
570
|
-
|
|
571
|
-
|
|
572
|
-
|
|
573
|
-
|
|
574
|
-
switch (expression.kind) {
|
|
575
|
-
case "Ix":
|
|
576
|
-
return encodeReference(getBinding(env, expression.index), [], env, mode);
|
|
577
|
-
case "Internal":
|
|
578
|
-
switch (expression.builtin) {
|
|
579
|
-
case "TRUE":
|
|
580
|
-
return wrapBool("true");
|
|
581
|
-
case "FALSE":
|
|
582
|
-
return wrapBool("false");
|
|
583
|
-
case "BOOLEAN":
|
|
584
|
-
return wrapIdv(BOOL_SET);
|
|
585
|
-
case "STRING":
|
|
586
|
-
return wrapIdv(STR_SET);
|
|
587
|
-
case "Nat":
|
|
588
|
-
return wrapIdv(NAT_SET);
|
|
589
|
-
case "Int":
|
|
590
|
-
return wrapIdv(INT_SET);
|
|
591
|
-
default:
|
|
592
|
-
throw new TlaUnsupportedError(`the operator ${expression.builtin}`);
|
|
579
|
+
case "Fact": {
|
|
580
|
+
const fact =
|
|
581
|
+
hyp.visibility === "Visible"
|
|
582
|
+
? encodeBool(encoder, hyp.expression, state.env, invert(state.mode))
|
|
583
|
+
: undefined;
|
|
584
|
+
return {
|
|
585
|
+
env: push(state.env, { kind: "unsupported", reason: "a reference to a fact" }),
|
|
586
|
+
mode: state.mode,
|
|
587
|
+
wrappers: fact ? [...state.wrappers, (body) => `(=> ${fact} ${body})`] : state.wrappers,
|
|
588
|
+
};
|
|
593
589
|
}
|
|
594
|
-
|
|
595
|
-
|
|
596
|
-
if (operator.kind === "Internal")
|
|
597
|
-
return encodeBuiltin(operator.builtin, expression.args, env, mode);
|
|
598
|
-
if (operator.kind === "Ix")
|
|
599
|
-
return encodeReference(getBinding(env, operator.index), expression.args, env, mode);
|
|
600
|
-
if (operator.kind === "Opaque")
|
|
601
|
-
return encodeOpaque(operator.name, expression.args, env, mode);
|
|
602
|
-
if (operator.kind === "Lambda")
|
|
603
|
-
return encode(normalizeApply(operator, expression.args), env, mode);
|
|
604
|
-
throw new TlaUnsupportedError(`an application of ${operator.kind}`);
|
|
590
|
+
default:
|
|
591
|
+
throw new TlaUnsupportedError(`a ${hyp.kind} in a nested ASSUME`);
|
|
605
592
|
}
|
|
606
|
-
|
|
607
|
-
|
|
608
|
-
|
|
609
|
-
|
|
610
|
-
|
|
611
|
-
|
|
612
|
-
|
|
613
|
-
|
|
614
|
-
|
|
615
|
-
|
|
616
|
-
|
|
617
|
-
|
|
618
|
-
|
|
619
|
-
|
|
620
|
-
|
|
621
|
-
|
|
622
|
-
|
|
623
|
-
|
|
624
|
-
|
|
625
|
-
|
|
626
|
-
|
|
627
|
-
|
|
628
|
-
|
|
629
|
-
|
|
630
|
-
|
|
631
|
-
|
|
632
|
-
|
|
633
|
-
|
|
634
|
-
|
|
635
|
-
case "SetOf":
|
|
636
|
-
return encodeSetOf(expression, env, mode);
|
|
637
|
-
case "SetEnum":
|
|
638
|
-
return wrapIdv(
|
|
639
|
-
call(
|
|
640
|
-
tla(`SetEnum_${expression.elements.length}`),
|
|
641
|
-
expression.elements.map((element) => encodeIdv(element, env, mode)),
|
|
642
|
-
),
|
|
643
|
-
);
|
|
644
|
-
case "Product":
|
|
645
|
-
return wrapIdv(
|
|
646
|
-
call(
|
|
647
|
-
tla(`Product_${expression.factors.length}`),
|
|
648
|
-
expression.factors.map((factor) => encodeIdv(factor, env, mode)),
|
|
649
|
-
),
|
|
650
|
-
);
|
|
651
|
-
case "Tuple":
|
|
652
|
-
return wrapIdv(
|
|
653
|
-
call(
|
|
654
|
-
tla(`Tuple_${expression.elements.length}`),
|
|
655
|
-
expression.elements.map((element) => encodeIdv(element, env, mode)),
|
|
656
|
-
),
|
|
657
|
-
);
|
|
658
|
-
case "Fcn":
|
|
659
|
-
return encodeFunction(expression, env, mode);
|
|
660
|
-
case "FcnApp": {
|
|
661
|
-
const encodedFunction = encodeIdv(expression.function, env, mode);
|
|
662
|
-
const args = expression.args.map((arg) => encodeIdv(arg, env, mode));
|
|
663
|
-
const argument = args.length === 1 ? args[0] : call(tla(`Tuple_${args.length}`), args);
|
|
664
|
-
return wrapIdv(`(${FUN_APP} ${encodedFunction} ${argument})`);
|
|
593
|
+
},
|
|
594
|
+
{ env, mode, wrappers: [] },
|
|
595
|
+
);
|
|
596
|
+
return steps.wrappers.reduceRight(
|
|
597
|
+
(body, wrap) => wrap(body),
|
|
598
|
+
encodeBool(encoder, sequent.active, steps.env, steps.mode),
|
|
599
|
+
);
|
|
600
|
+
};
|
|
601
|
+
|
|
602
|
+
const encode = (encoder: Encoder, expression: Expr, env: Env | undefined, mode: Mode): Term => {
|
|
603
|
+
switch (expression.kind) {
|
|
604
|
+
case "Ix":
|
|
605
|
+
return encodeReference(encoder, getBinding(env, expression.index), [], env, mode);
|
|
606
|
+
case "Internal":
|
|
607
|
+
switch (expression.builtin) {
|
|
608
|
+
case "TRUE":
|
|
609
|
+
return wrapBool("true");
|
|
610
|
+
case "FALSE":
|
|
611
|
+
return wrapBool("false");
|
|
612
|
+
case "BOOLEAN":
|
|
613
|
+
return wrapIdv(BOOL_SET);
|
|
614
|
+
case "STRING":
|
|
615
|
+
return wrapIdv(STR_SET);
|
|
616
|
+
case "Nat":
|
|
617
|
+
return wrapIdv(NAT_SET);
|
|
618
|
+
case "Int":
|
|
619
|
+
return wrapIdv(INT_SET);
|
|
620
|
+
default:
|
|
621
|
+
throw new TlaUnsupportedError(`the operator ${expression.builtin}`);
|
|
665
622
|
}
|
|
666
|
-
|
|
667
|
-
|
|
668
|
-
|
|
669
|
-
|
|
670
|
-
|
|
671
|
-
|
|
672
|
-
|
|
673
|
-
|
|
674
|
-
|
|
675
|
-
|
|
676
|
-
|
|
677
|
-
recordFields.set(`Record_${suffix}`, names);
|
|
678
|
-
recordFields.set(`RecordSet_${suffix}`, names);
|
|
679
|
-
return wrapIdv(
|
|
680
|
-
call(
|
|
681
|
-
tla(`${expression.kind === "Record" ? "Record" : "RecordSet"}_${suffix}`),
|
|
682
|
-
expression.fields.map((field) => encodeIdv(field.value, env, mode)),
|
|
683
|
-
),
|
|
623
|
+
case "Apply": {
|
|
624
|
+
const operator = expression.operator;
|
|
625
|
+
if (operator.kind === "Internal")
|
|
626
|
+
return encodeBuiltin(encoder, operator.builtin, expression.args, env, mode);
|
|
627
|
+
if (operator.kind === "Ix")
|
|
628
|
+
return encodeReference(
|
|
629
|
+
encoder,
|
|
630
|
+
getBinding(env, operator.index),
|
|
631
|
+
expression.args,
|
|
632
|
+
env,
|
|
633
|
+
mode,
|
|
684
634
|
);
|
|
635
|
+
if (operator.kind === "Opaque")
|
|
636
|
+
return encodeOpaque(encoder, operator.name, expression.args, env, mode);
|
|
637
|
+
if (operator.kind === "Lambda")
|
|
638
|
+
return encode(encoder, normalizeApply(operator, expression.args), env, mode);
|
|
639
|
+
throw new TlaUnsupportedError(`an application of ${operator.kind}`);
|
|
640
|
+
}
|
|
641
|
+
case "Sequent":
|
|
642
|
+
return wrapBool(encodeSequent(encoder, expression.sequent, env, mode));
|
|
643
|
+
case "With":
|
|
644
|
+
case "Parens":
|
|
645
|
+
return encode(encoder, expression.expression, env, mode);
|
|
646
|
+
case "If": {
|
|
647
|
+
const condition = encodeBool(encoder, expression.condition, env, mode);
|
|
648
|
+
const consequent = encode(encoder, expression.consequent, env, mode);
|
|
649
|
+
const alternative = encode(encoder, expression.alternative, env, mode);
|
|
650
|
+
if (consequent.integer !== undefined && alternative.integer !== undefined) {
|
|
651
|
+
const integer = `(ite ${resolveTriggers(condition, true)} ${consequent.integer} ${alternative.integer})`;
|
|
652
|
+
return { isBool: false, text: `(${CAST_INT} ${integer})`, integer };
|
|
685
653
|
}
|
|
686
|
-
|
|
687
|
-
|
|
688
|
-
|
|
689
|
-
|
|
690
|
-
|
|
691
|
-
|
|
692
|
-
|
|
693
|
-
|
|
694
|
-
|
|
695
|
-
|
|
696
|
-
|
|
697
|
-
|
|
698
|
-
|
|
699
|
-
|
|
700
|
-
|
|
701
|
-
|
|
702
|
-
|
|
703
|
-
|
|
704
|
-
|
|
705
|
-
|
|
706
|
-
|
|
707
|
-
|
|
708
|
-
|
|
709
|
-
|
|
710
|
-
|
|
711
|
-
|
|
654
|
+
return consequent.isBool && alternative.isBool
|
|
655
|
+
? wrapBool(`(ite ${condition} ${consequent.text} ${alternative.text})`)
|
|
656
|
+
: wrapIdv(`(ite ${condition} ${toIdv(consequent)} ${toIdv(alternative)})`);
|
|
657
|
+
}
|
|
658
|
+
case "List": {
|
|
659
|
+
const items = expression.items.map((item) => encodeBool(encoder, item, env, mode));
|
|
660
|
+
return wrapBool(expression.bullet === "Or" ? disjoin(items) : conjoin(items));
|
|
661
|
+
}
|
|
662
|
+
case "Opaque":
|
|
663
|
+
return encodeOpaque(encoder, expression.name, [], env, mode);
|
|
664
|
+
case "Quant":
|
|
665
|
+
return wrapBool(encodeQuantifier(encoder, expression, env, mode));
|
|
666
|
+
case "Choose":
|
|
667
|
+
return encodeChoose(encoder, expression, env, mode);
|
|
668
|
+
case "SetSt":
|
|
669
|
+
return encodeSetSt(encoder, expression, env, mode);
|
|
670
|
+
case "SetOf":
|
|
671
|
+
return encodeSetOf(encoder, expression, env, mode);
|
|
672
|
+
case "SetEnum":
|
|
673
|
+
return wrapIdv(
|
|
674
|
+
call(
|
|
675
|
+
tla(`SetEnum_${expression.elements.length}`),
|
|
676
|
+
expression.elements.map((element) => encodeIdv(encoder, element, env, mode)),
|
|
677
|
+
),
|
|
678
|
+
);
|
|
679
|
+
case "Product":
|
|
680
|
+
return wrapIdv(
|
|
681
|
+
call(
|
|
682
|
+
tla(`Product_${expression.factors.length}`),
|
|
683
|
+
expression.factors.map((factor) => encodeIdv(encoder, factor, env, mode)),
|
|
684
|
+
),
|
|
685
|
+
);
|
|
686
|
+
case "Tuple":
|
|
687
|
+
return wrapIdv(
|
|
688
|
+
call(
|
|
689
|
+
tla(`Tuple_${expression.elements.length}`),
|
|
690
|
+
expression.elements.map((element) => encodeIdv(encoder, element, env, mode)),
|
|
691
|
+
),
|
|
692
|
+
);
|
|
693
|
+
case "Fcn":
|
|
694
|
+
return encodeFunction(encoder, expression, env, mode);
|
|
695
|
+
case "FcnApp": {
|
|
696
|
+
const encodedFunction = encodeIdv(encoder, expression.function, env, mode);
|
|
697
|
+
const args = expression.args.map((arg) => encodeIdv(encoder, arg, env, mode));
|
|
698
|
+
const argument = args.length === 1 ? args[0] : call(tla(`Tuple_${args.length}`), args);
|
|
699
|
+
return wrapIdv(`(${FUN_APP} ${encodedFunction} ${argument})`);
|
|
700
|
+
}
|
|
701
|
+
case "Arrow":
|
|
702
|
+
return wrapIdv(
|
|
703
|
+
call(FUN_SET, [
|
|
704
|
+
encodeIdv(encoder, expression.domain, env, mode),
|
|
705
|
+
encodeIdv(encoder, expression.range, env, mode),
|
|
706
|
+
]),
|
|
707
|
+
);
|
|
708
|
+
case "Record":
|
|
709
|
+
case "Rect": {
|
|
710
|
+
const names = expression.fields.map((field) => field.name);
|
|
711
|
+
const suffix = names.join("_");
|
|
712
|
+
encoder.recordFields.set(`Record_${suffix}`, names);
|
|
713
|
+
encoder.recordFields.set(`RecordSet_${suffix}`, names);
|
|
714
|
+
return wrapIdv(
|
|
715
|
+
call(
|
|
716
|
+
tla(`${expression.kind === "Record" ? "Record" : "RecordSet"}_${suffix}`),
|
|
717
|
+
expression.fields.map((field) => encodeIdv(encoder, field.value, env, mode)),
|
|
718
|
+
),
|
|
719
|
+
);
|
|
712
720
|
}
|
|
713
|
-
|
|
714
|
-
|
|
715
|
-
|
|
716
|
-
|
|
717
|
-
|
|
718
|
-
|
|
719
|
-
|
|
720
|
-
|
|
721
|
-
|
|
722
|
-
|
|
723
|
-
|
|
724
|
-
|
|
725
|
-
|
|
726
|
-
|
|
727
|
-
|
|
728
|
-
|
|
729
|
-
|
|
730
|
-
|
|
721
|
+
case "Except":
|
|
722
|
+
return wrapIdv(encodeExcept(encoder, expression, env, mode));
|
|
723
|
+
case "Dot":
|
|
724
|
+
return wrapIdv(
|
|
725
|
+
`(${FUN_APP} ${encodeIdv(encoder, expression.expression, env, mode)} ${tla(`StrLit_${expression.field}`)})`,
|
|
726
|
+
);
|
|
727
|
+
case "Case":
|
|
728
|
+
return encodeCase(encoder, expression, env, mode);
|
|
729
|
+
case "String":
|
|
730
|
+
return wrapIdv(tla(`StrLit_${expression.value}`));
|
|
731
|
+
case "Num":
|
|
732
|
+
if (expression.fraction !== "") throw new TlaUnsupportedError("a real number");
|
|
733
|
+
return {
|
|
734
|
+
isBool: false,
|
|
735
|
+
text: `(${CAST_INT} ${BigInt(expression.integer)})`,
|
|
736
|
+
integer: String(BigInt(expression.integer)),
|
|
737
|
+
};
|
|
738
|
+
case "At":
|
|
739
|
+
if (mode.at === undefined) throw new TlaUnsupportedError("@ outside EXCEPT");
|
|
740
|
+
return wrapIdv(mode.at);
|
|
741
|
+
case "Tquant":
|
|
742
|
+
case "Tsub":
|
|
743
|
+
case "Fair":
|
|
744
|
+
throw new TlaUnsupportedError("a temporal formula");
|
|
745
|
+
default:
|
|
746
|
+
throw new TlaUnsupportedError(`the expression ${expression.kind}`);
|
|
747
|
+
}
|
|
731
748
|
};
|
|
749
|
+
|
|
750
|
+
export const getEntries = (encoder: Encoder, line: string): Entry[] => [
|
|
751
|
+
...encoder.flattener.takeIntroduced(),
|
|
752
|
+
removeUnprimable(resolveTriggers(line, false)),
|
|
753
|
+
];
|
|
754
|
+
|
|
755
|
+
export const createEncoder = (session: EncodingSession): Encoder => ({
|
|
756
|
+
session,
|
|
757
|
+
flattener: createFlattener(),
|
|
758
|
+
anonymous: new Map(),
|
|
759
|
+
recordFields: new Map(),
|
|
760
|
+
context: createContext(),
|
|
761
|
+
declared: new Map(),
|
|
762
|
+
});
|