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.
Files changed (172) hide show
  1. package/dist/compile.cjs +6 -6
  2. package/dist/compile.js +10 -10
  3. package/dist/deciders.cjs +29 -29
  4. package/dist/deciders.js +40 -40
  5. package/dist/index.cjs +1 -1
  6. package/dist/index.js +1 -1
  7. package/dist/parallel-worker.cjs +1 -1
  8. package/dist/parallel-worker.js +1 -1
  9. package/dist/prove-worker.cjs +1 -1
  10. package/dist/prove-worker.js +1 -1
  11. package/dist/prove.cjs +54 -54
  12. package/dist/prove.js +52 -52
  13. package/dist/run.cjs +42 -42
  14. package/dist/run.js +44 -44
  15. package/dist/tlapm.cjs +2 -2
  16. package/dist/tlapm.js +2 -2
  17. package/dist/transfer.cjs +39 -39
  18. package/dist/transfer.js +41 -41
  19. package/dist/worker.cjs +4 -4
  20. package/dist/worker.js +4 -4
  21. package/package.json +1 -1
  22. package/src/ast.ts +44 -39
  23. package/src/builtins.ts +4 -13
  24. package/src/check-failure.ts +116 -0
  25. package/src/check-trace.ts +282 -0
  26. package/src/check.ts +152 -518
  27. package/src/cli/options.ts +6 -31
  28. package/src/cli/shared.ts +1 -1
  29. package/src/cli/tlapm.ts +14 -13
  30. package/src/cli/tlc-arguments.ts +222 -210
  31. package/src/cli/tlc-output.ts +687 -0
  32. package/src/cli/tlc-usage.ts +1 -1
  33. package/src/cli/tlc.ts +34 -701
  34. package/src/cli/xml-exporter.ts +23 -33
  35. package/src/codegen.ts +5 -10
  36. package/src/coverage.ts +3 -10
  37. package/src/dependencies.ts +8 -13
  38. package/src/dfid.ts +16 -16
  39. package/src/environment-config.ts +315 -0
  40. package/src/environment.ts +45 -333
  41. package/src/errors.ts +3 -2
  42. package/src/evaluate.ts +5 -4
  43. package/src/fingerprints.ts +65 -1
  44. package/src/instances.ts +47 -10
  45. package/src/java-hash.ts +7 -0
  46. package/src/json.ts +4 -7
  47. package/src/levels.ts +39 -42
  48. package/src/liveness-checker.ts +24 -37
  49. package/src/liveness.ts +47 -54
  50. package/src/obligations/action.ts +4 -11
  51. package/src/obligations/anonymize.ts +4 -2
  52. package/src/obligations/expression.ts +18 -2
  53. package/src/obligations/generate.ts +45 -38
  54. package/src/obligations/index.ts +2 -2
  55. package/src/obligations/module.ts +27 -38
  56. package/src/obligations/normalize.ts +2 -1
  57. package/src/obligations/simplify.ts +39 -44
  58. package/src/obligations/source.ts +47 -57
  59. package/src/obligations/temporal.ts +5 -5
  60. package/src/parallel-worker.ts +10 -30
  61. package/src/parallel.ts +22 -45
  62. package/src/parser.ts +19 -34
  63. package/src/prover/decide-pool.ts +3 -3
  64. package/src/prover/deciders.ts +3 -3
  65. package/src/prover/isabelle/encode.ts +1 -1
  66. package/src/prover/isabelle/isar/inner-syntax.ts +9 -4
  67. package/src/prover/isabelle/isar/method.ts +14 -25
  68. package/src/prover/isabelle/isar/theory.ts +11 -10
  69. package/src/prover/isabelle/isar/type-check.ts +6 -6
  70. package/src/prover/isabelle/provers/blast/blast.ts +7 -63
  71. package/src/prover/isabelle/provers/hypsubst.ts +17 -26
  72. package/src/prover/isabelle/pure/bicompose.ts +9 -25
  73. package/src/prover/isabelle/pure/conv.ts +2 -8
  74. package/src/prover/isabelle/pure/drule.ts +9 -2
  75. package/src/prover/isabelle/pure/logic.ts +1 -1
  76. package/src/prover/isabelle/pure/raw-simplifier.ts +4 -13
  77. package/src/prover/isabelle/pure/rewriter.ts +5 -9
  78. package/src/prover/isabelle/pure/table.ts +2 -1
  79. package/src/prover/isabelle/pure/tactical.ts +42 -35
  80. package/src/prover/isabelle/pure/thm.ts +14 -11
  81. package/src/prover/isabelle/tla/classical-setup.ts +17 -14
  82. package/src/prover/isabelle/tla/context.ts +7 -2
  83. package/src/prover/isabelle/tla/logic.ts +10 -21
  84. package/src/prover/isabelle/tla/simpdata.ts +1 -10
  85. package/src/prover/prep/action.ts +11 -19
  86. package/src/prover/prep/fingerprint.ts +2 -5
  87. package/src/prover/prep/methods.ts +24 -3
  88. package/src/prover/prove.ts +87 -64
  89. package/src/prover/smt/context.ts +1 -2
  90. package/src/prover/smt/data.ts +418 -406
  91. package/src/prover/smt/encode.ts +30 -18
  92. package/src/prover/smt/rewrite.ts +657 -626
  93. package/src/prover/smt/solver/ast.ts +0 -22
  94. package/src/prover/smt/solver/auf-solver.ts +2 -5
  95. package/src/prover/smt/solver/context.ts +3 -3
  96. package/src/prover/smt/solver/e-matching.ts +1 -1
  97. package/src/prover/smt/solver/expr-safe-replace.ts +1 -1
  98. package/src/prover/smt/solver/internalizer.ts +1 -2
  99. package/src/prover/smt/solver/lp/dioph-eq.ts +1 -8
  100. package/src/prover/smt/solver/lp/hnf-cutter.ts +1 -1
  101. package/src/prover/smt/solver/lp/nla-core.ts +2 -6
  102. package/src/prover/smt/solver/mam-compiler.ts +4 -2
  103. package/src/prover/smt/solver/model-checker.ts +1 -1
  104. package/src/prover/smt/solver/model-finder.ts +12 -17
  105. package/src/prover/smt/solver/model-macro-solver.ts +11 -19
  106. package/src/prover/smt/solver/nlsat/algebraic.ts +9 -9
  107. package/src/prover/smt/solver/nlsat/atoms.ts +20 -4
  108. package/src/prover/smt/solver/nlsat/explain.ts +7 -22
  109. package/src/prover/smt/solver/nlsat/levelwise.ts +1 -6
  110. package/src/prover/smt/solver/nlsat/polynomial.ts +12 -3
  111. package/src/prover/smt/solver/nlsat/solver.ts +12 -24
  112. package/src/prover/smt/solver/nlsat/upolynomial-factorization.ts +1 -1
  113. package/src/prover/smt/solver/proto-model.ts +0 -4
  114. package/src/prover/smt/solver/quantifier-analyzer.ts +10 -10
  115. package/src/prover/smt/solver/quantifier-manager.ts +1 -5
  116. package/src/prover/smt/solver/smtlib-parser.ts +78 -94
  117. package/src/prover/smt/solver/theory-lra-bounds.ts +1 -2
  118. package/src/prover/smt/solver/theory-lra-internalize.ts +5 -16
  119. package/src/prover/tlapm/cache.ts +28 -18
  120. package/src/prover/tlapm/tlapm.ts +15 -9
  121. package/src/prover/verdict.ts +7 -0
  122. package/src/prover/zenon/check/check.ts +1 -2
  123. package/src/prover/zenon/check/records.ts +1 -1
  124. package/src/prover/zenon/check/relations.ts +2 -1
  125. package/src/prover/zenon/check/rewrites.ts +2 -15
  126. package/src/prover/zenon/check/sets.ts +40 -58
  127. package/src/prover/zenon/check/terms.ts +1 -2
  128. package/src/prover/zenon/eqrel.ts +2 -0
  129. package/src/prover/zenon/expr.ts +7 -0
  130. package/src/prover/zenon/index-table.ts +9 -19
  131. package/src/prover/zenon/isar.ts +35 -35
  132. package/src/prover/zenon/llproof.ts +2 -11
  133. package/src/prover/zenon/mltoll.ts +12 -28
  134. package/src/prover/zenon/parse.ts +3 -6
  135. package/src/prover/zenon/search.ts +4 -14
  136. package/src/prover/zenon/tla/functions.ts +2 -2
  137. package/src/prover/zenon/tla/llproof.ts +9 -11
  138. package/src/prover/zenon/tla/records.ts +1 -6
  139. package/src/prover/zenon/tla/sets.ts +15 -14
  140. package/src/prover/zenon/tla/tla.ts +7 -6
  141. package/src/resolve.ts +55 -72
  142. package/src/sany/generation.ts +394 -0
  143. package/src/sany/generator-def-entries.ts +210 -0
  144. package/src/sany/generator-definitions.ts +686 -0
  145. package/src/sany/generator-expressions.ts +1100 -0
  146. package/src/sany/generator-proofs.ts +662 -0
  147. package/src/sany/generator.ts +155 -2625
  148. package/src/sany/lexer.ts +17 -16
  149. package/src/sany/nodes.ts +6 -13
  150. package/src/sany/report.ts +3 -6
  151. package/src/sany/selectors.ts +35 -38
  152. package/src/sany/xml.ts +23 -55
  153. package/src/search.ts +65 -27
  154. package/src/simulate.ts +157 -133
  155. package/src/spec-description.ts +33 -48
  156. package/src/standard-modules.ts +16 -32
  157. package/src/state-graph.ts +2 -7
  158. package/src/substitution-levels.ts +5 -4
  159. package/src/successors.ts +5 -7
  160. package/src/tlc/messages.ts +20 -15
  161. package/src/tlc/order.ts +2 -9
  162. package/src/tlc/random.ts +4 -4
  163. package/src/tlc/replay.ts +8 -15
  164. package/src/tlc/tlc-operators.ts +2 -3
  165. package/src/tlc/trace-spec.ts +25 -45
  166. package/src/typescript/actions.ts +2 -4
  167. package/src/typescript/collections.ts +34 -20
  168. package/src/typescript/compile.ts +1 -3
  169. package/src/typescript/formula.ts +5 -3
  170. package/src/typescript/model.ts +4 -5
  171. package/src/typescript/steps.ts +20 -18
  172. package/src/values.ts +63 -158
@@ -0,0 +1,1100 @@
1
+ import type { Bound, Declaration, Definition, Expression, Instance } from "../ast";
2
+ import { TlaSyntaxError } from "../errors";
3
+ import { createLevelFields } from "./builtins";
4
+ import {
5
+ createContext,
6
+ type ExprNode,
7
+ type ExprOrOpArgNode,
8
+ type FormalParamNode,
9
+ formatSanyLocation,
10
+ getSymbolArity,
11
+ type InstanceNode,
12
+ isAbsent,
13
+ type LabelNode,
14
+ type LetInNode,
15
+ type OpApplNode,
16
+ type OpArgNode,
17
+ type OpDeclNode,
18
+ type OpDefNode,
19
+ type SanyLocation,
20
+ type SymbolNode,
21
+ type ThmOrAssumpDefNode,
22
+ } from "./nodes";
23
+ import { getSelectorItems, isGeneralId, type SelectorItem } from "./selectors";
24
+ import {
25
+ findNameTokens,
26
+ findToken,
27
+ getArgumentSpan,
28
+ getExpressionSpan,
29
+ getMatchingIndex,
30
+ getPreComments,
31
+ getSpanLocation,
32
+ getTokenIndex,
33
+ getTokenLocation,
34
+ getTokenSource,
35
+ isToken,
36
+ type SourceFile,
37
+ type TokenSpan,
38
+ } from "./source";
39
+ import {
40
+ applyBuiltin,
41
+ createFormalParam,
42
+ createNullNode,
43
+ createOpArg,
44
+ createOpDef,
45
+ createString,
46
+ getBuiltin,
47
+ getLocation,
48
+ type ModuleGeneration,
49
+ popLabels,
50
+ pushLabelScope,
51
+ resolveName,
52
+ resolveSymbol,
53
+ resolveSynonym,
54
+ withContext,
55
+ } from "./generation";
56
+ import { getOperandSpan } from "./generator-def-entries";
57
+ import {
58
+ checkForUndefinedRecursiveOps,
59
+ getDefinitionSpan,
60
+ processFunction,
61
+ processModuleDefinition,
62
+ processOperator,
63
+ processRecursive,
64
+ } from "./generator-definitions";
65
+
66
+ const isIdentifier = (name: string) => /^[A-Za-z0-9_]+$/.test(name);
67
+
68
+ const isSelector = (name: string) => name !== "!!" && name.includes("!");
69
+
70
+ interface BoundSymbols {
71
+ bounded: FormalParamNode[][];
72
+ tupleOrs: boolean[];
73
+ ranges: ExprNode[];
74
+ }
75
+
76
+ type LetUnit =
77
+ | { kind: "Recursive"; declarations: Declaration[] }
78
+ | { kind: "Instance"; instance: Instance }
79
+ | { kind: "Definition"; definition: Definition };
80
+
81
+ const getNumeralDigits = (text: string) =>
82
+ BigInt(text.startsWith("\\") ? `0${text.slice(1).replace(/^h/i, "x")}` : text).toString();
83
+
84
+ const OPERATOR_ARGUMENT_KINDS = new Set<Expression["kind"]>([
85
+ "Identifier",
86
+ "Subexpression",
87
+ "OperatorReference",
88
+ "Lambda",
89
+ ]);
90
+
91
+ const isOperatorArgument = (argument: Expression) => {
92
+ const items = argument.kind === "Apply" ? getSelectorItems(argument) : undefined;
93
+ return OPERATOR_ARGUMENT_KINDS.has(argument.kind) || (items !== undefined && isGeneralId(items));
94
+ };
95
+
96
+ const POSTFIX_OPERATOR_TEXTS = new Set(["'", "^+", "^*", "^#"]);
97
+
98
+ const getOperatorNodeKind = (
99
+ expression: Expression & { kind: "OperatorReference" | "Lambda" },
100
+ text: string,
101
+ ) => {
102
+ if (POSTFIX_OPERATOR_TEXTS.has(text)) return "N_GenPostfixOp";
103
+ return expression.kind === "Lambda" || text === "~" || text === "-."
104
+ ? "N_GenNonExpPrefixOp"
105
+ : "N_GenInfixOp";
106
+ };
107
+
108
+ const locateSelectorItems = (file: SourceFile, items: SelectorItem[], span: TokenSpan) => {
109
+ let cursor = span.start;
110
+ return items.map((item): SelectorItem => {
111
+ const text = item.op === "Name" ? item.name : item.op === "Null" ? "(" : String(item.op);
112
+ const index = findToken(file, cursor, span.end, text);
113
+ if (index === -1) return item;
114
+ if (item.op === "Null") {
115
+ const close = getMatchingIndex(file, index);
116
+ cursor = close + 1;
117
+ return { ...item, location: getSpanLocation(file, { start: index, end: close }) };
118
+ }
119
+ cursor = index + 1;
120
+ const location = getTokenLocation(file, index);
121
+ if (item.args === undefined || !isToken(file, index + 1, "(")) return { ...item, location };
122
+ const close = getMatchingIndex(file, index + 1);
123
+ cursor = close + 1;
124
+ return {
125
+ ...item,
126
+ location,
127
+ argsLocation: getSpanLocation(file, { start: index + 1, end: close }),
128
+ };
129
+ });
130
+ };
131
+
132
+ export const generateSelector = (
133
+ generation: ModuleGeneration,
134
+ expression: Expression,
135
+ expectedArity: number,
136
+ isFact: boolean,
137
+ isDef: boolean,
138
+ ) => {
139
+ const items = getSelectorItems(expression);
140
+ if (items === undefined) throw new TlaSyntaxError(`Expected a name, found ${expression.kind}`);
141
+ return generation.selectorToNode(
142
+ locateSelectorItems(generation.file, items, getExpressionSpan(generation.file, expression)),
143
+ expectedArity,
144
+ isFact,
145
+ isDef,
146
+ getLocation(generation.file, expression),
147
+ );
148
+ };
149
+
150
+ const generateSelectorExpression = (generation: ModuleGeneration, expression: Expression) => {
151
+ const node = generateSelector(generation, expression, 0, false, false);
152
+ if (node.kind !== "OpAppl") throw new TlaSyntaxError("Expected an expression");
153
+ return node;
154
+ };
155
+
156
+ const checkRecursion = (generation: ModuleGeneration, node: ExprNode) => {
157
+ if (node.kind !== "OpAppl") return;
158
+ const recursive = generation.functions.find((entry) => entry.name === node.operator.name);
159
+ if (recursive) recursive.node.operator = getBuiltin(generation, "$RecursiveFcnSpec");
160
+ };
161
+
162
+ const getBoundGroups = (bounds: Bound[]) =>
163
+ bounds.reduce<Bound[][]>((groups, bound) => {
164
+ const last = groups[groups.length - 1];
165
+ const isSameGroup =
166
+ last !== undefined &&
167
+ last[0].set === bound.set &&
168
+ bound.pattern.kind === "Name" &&
169
+ last[0].pattern.kind === "Name";
170
+ if (isSameGroup) last.push(bound);
171
+ else groups.push([bound]);
172
+ return groups;
173
+ }, []);
174
+
175
+ export const generateBounds = (
176
+ generation: ModuleGeneration,
177
+ bounds: Bound[],
178
+ searchStart: number,
179
+ ) =>
180
+ generateBoundsWithRanges(
181
+ generation,
182
+ bounds,
183
+ searchStart,
184
+ getBoundGroups(bounds).map((group) => generateExpression(generation, group[0].set)),
185
+ );
186
+
187
+ export const generateWithParams = (
188
+ generation: ModuleGeneration,
189
+ params: FormalParamNode[],
190
+ expression: Expression,
191
+ ) => {
192
+ const scope = generation.labelScopes.at(-1);
193
+ scope?.params.push(params);
194
+ const node = generateExpression(generation, expression);
195
+ scope?.params.pop();
196
+ return node;
197
+ };
198
+
199
+ const generateBoundApplication = (
200
+ generation: ModuleGeneration,
201
+ name: string,
202
+ bounds: Bound[],
203
+ searchStart: number,
204
+ body: Expression,
205
+ location: SanyLocation,
206
+ ) =>
207
+ withContext(generation, createContext(), () => {
208
+ const symbols = generateBounds(generation, bounds, searchStart);
209
+ const operand = generateWithParams(generation, symbols.bounded.flat(), body);
210
+ return applyBuiltin(generation, name, [operand], location, symbols);
211
+ });
212
+
213
+ const generateLambda = (
214
+ generation: ModuleGeneration,
215
+ expression: Expression & { kind: "Lambda" },
216
+ ): OpDefNode => {
217
+ const span = getExpressionSpan(generation.file, expression);
218
+ const nameIndexes = findNameTokens(generation.file, span.start, span.end, expression.params);
219
+ return withContext(generation, createContext(), () => {
220
+ const params = expression.params.map((name, index) =>
221
+ createFormalParam(
222
+ generation,
223
+ name,
224
+ 0,
225
+ getTokenLocation(generation.file, nameIndexes[index]),
226
+ true,
227
+ ),
228
+ );
229
+ const body = generateWithParams(generation, params, expression.body);
230
+ return createOpDef(generation, {
231
+ name: "LAMBDA",
232
+ params,
233
+ body,
234
+ location: getSpanLocation(generation.file, span),
235
+ preComments: getPreComments(generation.file, span.start),
236
+ });
237
+ });
238
+ };
239
+
240
+ const getOperatorArgumentName = (file: SourceFile, argument: Expression) =>
241
+ argument.kind === "OperatorReference"
242
+ ? argument.operator
243
+ : argument.kind === "Lambda" && argument.body.kind === "Apply"
244
+ ? argument.body.operator
245
+ : file.tokens[getTokenIndex(file, argument.location)].text;
246
+
247
+ export const generateOperatorArgument = (
248
+ generation: ModuleGeneration,
249
+ argument: Expression,
250
+ target: OpDeclNode,
251
+ ): OpArgNode | OpApplNode => {
252
+ const location = getLocation(generation.file, argument);
253
+ if (argument.kind === "Lambda") {
254
+ if (argument.location.range !== undefined && argument.operator === undefined)
255
+ return createOpArg(generation, generateLambda(generation, argument), location);
256
+ return createOpArg(
257
+ generation,
258
+ resolveName(generation, getOperatorArgumentName(generation.file, argument), location),
259
+ location,
260
+ );
261
+ }
262
+ if (!isOperatorArgument(argument)) {
263
+ generation.addError(
264
+ location,
265
+ `Arity ${target.arity} operator (not an expression) is expected \nto substitute for CONSTANT '${target.name}'.`,
266
+ );
267
+ return createNullNode(generation);
268
+ }
269
+ if (argument.kind === "OperatorReference") {
270
+ return createOpArg(generation, resolveName(generation, argument.operator, location), location);
271
+ }
272
+ const node = generateSelector(generation, argument, target.arity, false, false);
273
+ if (node.kind === "OpArg" || (node.kind === "OpAppl" && node.nullKind !== undefined)) return node;
274
+ throw new TlaSyntaxError(
275
+ `Expected an operator argument at line ${location.beginLine}, column ${location.beginColumn}`,
276
+ );
277
+ };
278
+
279
+ export const generateArgument = (
280
+ generation: ModuleGeneration,
281
+ operator: SymbolNode,
282
+ index: number,
283
+ argument: Expression,
284
+ operatorLocation: SanyLocation,
285
+ ): ExprOrOpArgNode => {
286
+ const isDefinition =
287
+ operator.kind === "OpDef" &&
288
+ (operator.defKind === "UserDefined" || operator.defKind === "ModuleInstance");
289
+ const expectedArity = isDefinition ? (operator.params?.[index]?.arity ?? 0) : 0;
290
+ if (expectedArity === 0) return generateExpression(generation, argument);
291
+ const span = getExpressionSpan(generation.file, argument);
292
+ const location = getSpanLocation(generation.file, span);
293
+ const position = `${index + 1} (counting from 1)`;
294
+ const argumentSpan = getArgumentSpan(generation.file, span);
295
+ if (argumentSpan !== span || !isOperatorArgument(argument)) {
296
+ generation.addError(
297
+ getSpanLocation(generation.file, argumentSpan),
298
+ `An expression appears as argument number ${position} to operator '${operator.name}', in a position an operator is required.`,
299
+ );
300
+ return createNullNode(generation);
301
+ }
302
+ if (
303
+ argument.kind === "Identifier" ||
304
+ argument.kind === "Subexpression" ||
305
+ argument.kind === "Apply"
306
+ ) {
307
+ const node = generateSelector(generation, argument, expectedArity, false, false);
308
+ if (node.kind === "OpArg" || node.kind === "OpAppl") return node;
309
+ throw new TlaSyntaxError(`Expected an operator argument at ${formatSanyLocation(location)}`);
310
+ }
311
+ if (
312
+ argument.kind === "Lambda" &&
313
+ argument.location.range !== undefined &&
314
+ argument.operator === undefined
315
+ ) {
316
+ const lambda = generateLambda(generation, argument);
317
+ const arity = getSymbolArity(lambda);
318
+ if (arity === expectedArity) return createOpArg(generation, lambda, location);
319
+ generation.addError(
320
+ operatorLocation,
321
+ `Lambda expression with arity ${arity} used as argument ${index + 1} of operator \`${operator.name}', \nbut an operator of arity ${expectedArity} is required.`,
322
+ );
323
+ return createNullNode(generation);
324
+ }
325
+ const name = getOperatorArgumentName(generation.file, argument);
326
+ const symbol = resolveSymbol(generation.contexts, resolveSynonym(name));
327
+ if (symbol === undefined) {
328
+ generation.addError(location, `Could not find declaration or definition of symbol '${name}'.`);
329
+ return createNullNode(generation);
330
+ }
331
+ const arity = getSymbolArity(symbol);
332
+ if (arity === expectedArity) return createOpArg(generation, symbol, location);
333
+ generation.addError(
334
+ operatorLocation,
335
+ `Operator with incorrect arity passed as argument. \nOperator '${symbol.name}' of arity ${arity} is argument number ${position} to operator \`${formatSanyLocation(operator.location)}', \nbut an operator of arity ${expectedArity} was expected.`,
336
+ );
337
+ return createNullNode(generation);
338
+ };
339
+
340
+ const generateJunction = (
341
+ generation: ModuleGeneration,
342
+ expression: Expression & { kind: "And" | "Or" },
343
+ ) => {
344
+ const location = getLocation(generation.file, expression);
345
+ if (expression.isBulleted) {
346
+ return applyBuiltin(
347
+ generation,
348
+ expression.kind === "And" ? "$ConjList" : "$DisjList",
349
+ expression.operands.map((operand) => generateExpression(generation, operand)),
350
+ location,
351
+ );
352
+ }
353
+ const span = getExpressionSpan(generation.file, expression);
354
+ const name = expression.kind === "And" ? "\\land" : "\\lor";
355
+ const [first, ...rest] = expression.operands;
356
+ return rest.reduce<ExprNode>(
357
+ (left, operand, index) => {
358
+ const operandSpan = getOperandSpan(generation.file, operand);
359
+ const end = index === rest.length - 1 ? span.end : operandSpan.end;
360
+ return applyBuiltin(
361
+ generation,
362
+ name,
363
+ [left, generateExpression(generation, operand)],
364
+ getSpanLocation(generation.file, { start: span.start, end }),
365
+ );
366
+ },
367
+ generateExpression(generation, first),
368
+ );
369
+ };
370
+
371
+ const generateCase = (generation: ModuleGeneration, expression: Expression & { kind: "Case" }) => {
372
+ const span = getExpressionSpan(generation.file, expression);
373
+ const arms = expression.arms.map((arm, index) => {
374
+ const condition = getOperandSpan(generation.file, arm.condition);
375
+ const isLast = index === expression.arms.length - 1 && expression.other === undefined;
376
+ const body = getOperandSpan(generation.file, arm.body);
377
+ const operands = [
378
+ generateExpression(generation, arm.condition),
379
+ generateExpression(generation, arm.body),
380
+ ];
381
+ return applyBuiltin(
382
+ generation,
383
+ "$Pair",
384
+ operands,
385
+ getSpanLocation(generation.file, {
386
+ start: condition.start,
387
+ end: isLast ? span.end : body.end,
388
+ }),
389
+ );
390
+ });
391
+ const other = expression.other;
392
+ if (other) {
393
+ const body = getOperandSpan(generation.file, other);
394
+ const otherIndex = findTokenBefore(generation.file, body.start, "OTHER");
395
+ arms.push(
396
+ applyBuiltin(
397
+ generation,
398
+ "$Pair",
399
+ [undefined, generateExpression(generation, other)],
400
+ getSpanLocation(generation.file, { start: otherIndex, end: span.end }),
401
+ ),
402
+ );
403
+ }
404
+ return applyBuiltin(generation, "$Case", arms, getSpanLocation(generation.file, span));
405
+ };
406
+
407
+ const findTokenBefore = (file: SourceFile, index: number, text: string) => {
408
+ for (let current = index; current >= 0; current--) {
409
+ if (isToken(file, current, text)) return current;
410
+ }
411
+ return index;
412
+ };
413
+
414
+ const generateExcept = (
415
+ generation: ModuleGeneration,
416
+ expression: Expression & { kind: "Except" },
417
+ ) => {
418
+ const span = getExpressionSpan(generation.file, expression);
419
+ const location = getSpanLocation(generation.file, span);
420
+ const operands: ExprOrOpArgNode[] = [generateExpression(generation, expression.function)];
421
+ const exceptNode = applyBuiltin(generation, "$Except", operands, location);
422
+ const functionSpan = getExpressionSpan(generation.file, expression.function);
423
+ let cursor = findToken(generation.file, functionSpan.end + 1, span.end, "EXCEPT") + 1;
424
+ expression.updates.forEach((update) => {
425
+ const bang = findToken(generation.file, cursor, span.end, "!");
426
+ const valueSpan = getOperandSpan(generation.file, update.value);
427
+ const specLocation = getSpanLocation(generation.file, { start: bang, end: valueSpan.end });
428
+ let pathCursor = bang + 1;
429
+ const components = update.path.map((step): ExprNode => {
430
+ if (step.kind === "Field") {
431
+ const nameIndex = findNameOrKeyword(generation.file, pathCursor, step.name);
432
+ pathCursor = nameIndex + 1;
433
+ return createString(generation, step.name, getTokenLocation(generation.file, nameIndex));
434
+ }
435
+ const open = findToken(generation.file, pathCursor, span.end, "[");
436
+ const close = getMatchingIndex(generation.file, open);
437
+ pathCursor = close + 1;
438
+ if (step.args.length === 1) return generateExpression(generation, step.args[0]);
439
+ return applyBuiltin(
440
+ generation,
441
+ "$Tuple",
442
+ step.args.map((innerArgument) => generateExpression(generation, innerArgument)),
443
+ getSpanLocation(generation.file, { start: open, end: close }),
444
+ );
445
+ });
446
+ const sequence = applyBuiltin(generation, "$Seq", components, specLocation);
447
+ const pair = applyBuiltin(generation, "$Pair", [sequence], specLocation);
448
+ generation.exceptSpecStack.push(pair);
449
+ generation.exceptStack.push(exceptNode);
450
+ pair.operands.push(generateExpression(generation, update.value));
451
+ generation.exceptSpecStack.pop();
452
+ generation.exceptStack.pop();
453
+ operands.push(pair);
454
+ cursor = valueSpan.end + 1;
455
+ });
456
+ return exceptNode;
457
+ };
458
+
459
+ export const findNameOrKeyword = (file: SourceFile, start: number, name: string) => {
460
+ for (let index = start; index < file.tokens.length; index++) {
461
+ if (file.tokens[index].text === name && file.tokens[index].kind !== "String") return index;
462
+ }
463
+ return start;
464
+ };
465
+
466
+ const generateRecordFields = (
467
+ generation: ModuleGeneration,
468
+ operator: "$RcdConstructor" | "$SetOfRcds",
469
+ expression: Expression & { kind: "Record" | "RecordSet" },
470
+ ) => {
471
+ const span = getExpressionSpan(generation.file, expression);
472
+ let cursor = span.start + 1;
473
+ const pairs = expression.fields.map((field, fieldIndex) => {
474
+ const nameIndex = findNameOrKeyword(generation.file, cursor, field.name);
475
+ const valueSpan = getOperandSpan(generation.file, field.value);
476
+ cursor = valueSpan.end + 1;
477
+ if (expression.fields.slice(0, fieldIndex).some((other) => other.name === field.name)) {
478
+ generation.addError(
479
+ getTokenLocation(generation.file, nameIndex),
480
+ "Non-unique fields in constructor.",
481
+ );
482
+ }
483
+ return applyBuiltin(
484
+ generation,
485
+ "$Pair",
486
+ [
487
+ createString(generation, field.name, getTokenLocation(generation.file, nameIndex)),
488
+ generateExpression(generation, field.value),
489
+ ],
490
+ getSpanLocation(generation.file, { start: nameIndex, end: valueSpan.end }),
491
+ );
492
+ });
493
+ const record = applyBuiltin(generation, operator, pairs, getSpanLocation(generation.file, span));
494
+ generation.currentModule.records.push(record);
495
+ return record;
496
+ };
497
+
498
+ const getTokenPosition = (file: SourceFile, index: number) => ({
499
+ line: file.tokens[index].line,
500
+ column: file.tokens[index].column,
501
+ });
502
+
503
+ const getRecursiveDeclarations = (file: SourceFile, start: number) => {
504
+ const declarations: Declaration[] = [];
505
+ let index = start;
506
+ while (file.tokens[index]?.kind === "Identifier") {
507
+ const end = isToken(file, index + 1, "(") ? getMatchingIndex(file, index + 1) : index;
508
+ const arity = file.tokens.slice(index + 1, end).filter((token) => token.text === "_").length;
509
+ declarations.push({
510
+ name: file.tokens[index].text,
511
+ arity,
512
+ location: {
513
+ ...getTokenPosition(file, index),
514
+ range: {
515
+ module: file.name,
516
+ start: getTokenPosition(file, index),
517
+ end: getTokenPosition(file, end),
518
+ },
519
+ },
520
+ });
521
+ if (!isToken(file, end + 1, ",")) break;
522
+ index = end + 2;
523
+ }
524
+ return declarations;
525
+ };
526
+
527
+ const getLetUnits = (file: SourceFile, expression: Expression & { kind: "Let" }) => {
528
+ const units = [
529
+ ...expression.definitions.map((definition) => ({
530
+ unit: { kind: "Definition", definition } satisfies LetUnit,
531
+ span: getDefinitionSpan(file, definition),
532
+ })),
533
+ ...(expression.instances ?? []).map((instance) => ({
534
+ unit: { kind: "Instance", instance } satisfies LetUnit,
535
+ span: getDefinitionSpan(file, instance),
536
+ })),
537
+ ];
538
+ const letStart = getExpressionSpan(file, expression).start;
539
+ const bodyStart = getOperandSpan(file, expression.body).start;
540
+ const recursives: { unit: LetUnit; span: TokenSpan }[] = [];
541
+ for (let index = letStart + 1; index < bodyStart; index++) {
542
+ const isInUnit = units.some((entry) => entry.span.start <= index && index <= entry.span.end);
543
+ if (isToken(file, index, "RECURSIVE") && !isInUnit) {
544
+ recursives.push({
545
+ unit: { kind: "Recursive", declarations: getRecursiveDeclarations(file, index + 1) },
546
+ span: { start: index, end: index },
547
+ });
548
+ }
549
+ }
550
+ return [...units, ...recursives]
551
+ .toSorted((first, second) => first.span.start - second.span.start)
552
+ .map((entry) => entry.unit);
553
+ };
554
+
555
+ const generateLet = (
556
+ generation: ModuleGeneration,
557
+ expression: Expression & { kind: "Let" },
558
+ ): LetInNode => {
559
+ const context = createContext();
560
+ return withContext(generation, context, () => {
561
+ generation.curLevel++;
562
+ generation.unresolvedCount[generation.curLevel] = 0;
563
+ const opDefs: (OpDefNode | ThmOrAssumpDefNode)[] = [];
564
+ const instances: InstanceNode[] = [];
565
+ getLetUnits(generation.file, expression).forEach((unit) => {
566
+ if (unit.kind === "Recursive") processRecursive(generation, unit.declarations);
567
+ else if (unit.kind === "Instance") {
568
+ processModuleDefinition(generation, unit.instance, opDefs, instances);
569
+ } else if (unit.definition.kind === "Function") {
570
+ processFunction(generation, unit.definition, opDefs);
571
+ } else processOperator(generation, unit.definition, opDefs);
572
+ });
573
+ checkForUndefinedRecursiveOps(generation);
574
+ generation.curLevel = Math.max(generation.curLevel - 1, 0);
575
+ const body = generateExpression(generation, expression.body);
576
+ return {
577
+ ...createLevelFields(generation.getId()),
578
+ kind: "LetIn",
579
+ opDefs,
580
+ instances,
581
+ body,
582
+ context,
583
+ location: getLocation(generation.file, expression),
584
+ };
585
+ });
586
+ };
587
+
588
+ const generateChoose = (
589
+ generation: ModuleGeneration,
590
+ expression: Expression & { kind: "Choose" },
591
+ ) => {
592
+ const span = getExpressionSpan(generation.file, expression);
593
+ const location = getSpanLocation(generation.file, span);
594
+ return withContext(generation, createContext(), () => {
595
+ const pattern = expression.pattern;
596
+ const names = pattern.kind === "Name" ? [pattern.name] : pattern.names;
597
+ if (expression.set === undefined) {
598
+ const indexes = findNameTokens(generation.file, span.start, span.end, names);
599
+ const params = names.map((name, index) =>
600
+ createFormalParam(
601
+ generation,
602
+ name,
603
+ 0,
604
+ getTokenLocation(generation.file, pattern.kind === "Name" ? span.start : indexes[index]),
605
+ true,
606
+ ),
607
+ );
608
+ const body = generateWithParams(generation, params, expression.body);
609
+ return applyBuiltin(generation, "$UnboundedChoose", [body], location, { unbounded: params });
610
+ }
611
+ const range = generateExpression(generation, expression.set);
612
+ const setSpan = getExpressionSpan(generation.file, expression.set);
613
+ const indexes = findNameTokens(generation.file, span.start, setSpan.start, names);
614
+ const params = names.map((name, index) =>
615
+ createFormalParam(
616
+ generation,
617
+ name,
618
+ 0,
619
+ getTokenLocation(generation.file, indexes[index]),
620
+ true,
621
+ ),
622
+ );
623
+ const body = generateWithParams(generation, params, expression.body);
624
+ return applyBuiltin(generation, "$BoundedChoose", [body], location, {
625
+ bounded: [params],
626
+ tupleOrs: [pattern.kind === "Tuple"],
627
+ ranges: [range],
628
+ });
629
+ });
630
+ };
631
+
632
+ const getUnresolvedOperator = (
633
+ generation: ModuleGeneration,
634
+ expression: Expression & { kind: "Apply" },
635
+ ) => {
636
+ if (
637
+ isIdentifier(expression.operator) ||
638
+ isSelector(expression.operator) ||
639
+ expression.args.length > 2
640
+ ) {
641
+ return undefined;
642
+ }
643
+ if (resolveSymbol(generation.contexts, resolveSynonym(expression.operator)) !== undefined) {
644
+ return undefined;
645
+ }
646
+ const span = getExpressionSpan(generation.file, expression);
647
+ if (
648
+ generation.file.tokens[span.start].text === expression.operator &&
649
+ isToken(generation.file, span.start + 1, "(")
650
+ ) {
651
+ return undefined;
652
+ }
653
+ const firstSpan = getOperandSpan(generation.file, expression.args[0]);
654
+ const isPrefix = expression.args.length === 1 && firstSpan.start !== span.start;
655
+ const index = isPrefix ? span.start : firstSpan.end + 1;
656
+ const text = getTokenSource(generation.file, index);
657
+ return {
658
+ index,
659
+ name: isPrefix && text === "-" ? "-." : text,
660
+ fixity: isPrefix ? "prefix" : expression.args.length === 2 ? "infix" : "postfix",
661
+ };
662
+ };
663
+
664
+ export const generateExpression = (
665
+ generation: ModuleGeneration,
666
+ expression: Expression,
667
+ ): ExprNode => {
668
+ const location = getLocation(generation.file, expression);
669
+ switch (expression.kind) {
670
+ case "Number":
671
+ return {
672
+ ...createLevelFields(generation.getId()),
673
+ kind: "Numeral",
674
+ value: getNumeralDigits(expression.text ?? String(expression.value)),
675
+ location,
676
+ };
677
+ case "Decimal": {
678
+ const [integralPart, fractionalPart] = expression.text.split(".");
679
+ const mantissa = BigInt(integralPart + fractionalPart);
680
+ const isLong = mantissa <= 9223372036854775807n;
681
+ return {
682
+ ...createLevelFields(generation.getId()),
683
+ kind: "Decimal",
684
+ mantissa: mantissa.toString(),
685
+ exponent: isLong ? String(-fractionalPart.length) : String(fractionalPart.length),
686
+ integralPart,
687
+ fractionalPart,
688
+ location,
689
+ };
690
+ }
691
+ case "String":
692
+ return createString(generation, expression.value, location);
693
+ case "Identifier": {
694
+ const node = generateSelectorExpression(generation, expression);
695
+ checkRecursion(generation, node);
696
+ return node;
697
+ }
698
+ case "Apply": {
699
+ const unresolved = getUnresolvedOperator(generation, expression);
700
+ if (unresolved !== undefined) {
701
+ generation.addError(
702
+ getTokenLocation(generation.file, unresolved.index),
703
+ `Could not find declaration or definition of symbol '${unresolved.name}'.`,
704
+ );
705
+ generation.addError(
706
+ location,
707
+ `Couldn't resolve ${unresolved.fixity} operator symbol \`${unresolved.name}'.`,
708
+ );
709
+ return { ...createNullNode(generation), nullKind: "absent" };
710
+ }
711
+ const node = generateSelectorExpression(generation, expression);
712
+ if (isSelector(expression.operator) || isIdentifier(expression.operator)) {
713
+ checkRecursion(generation, node);
714
+ }
715
+ return node;
716
+ }
717
+ case "Bracket":
718
+ generation.addError(
719
+ getTokenLocation(generation.file, getExpressionSpan(generation.file, expression).start),
720
+ "Unsupported expression type `['.",
721
+ );
722
+ return { ...createNullNode(generation), nullKind: "absent" };
723
+ case "OperatorReference":
724
+ case "Lambda": {
725
+ const text =
726
+ generation.file.tokens[getExpressionSpan(generation.file, expression).start].text;
727
+ generation.addError(
728
+ location,
729
+ text === "LAMBDA"
730
+ ? "LAMBDA expression used where an expression is required."
731
+ : `Unsupported expression type \`${getOperatorNodeKind(expression, text)}'.`,
732
+ );
733
+ return { ...createNullNode(generation), nullKind: "absent" };
734
+ }
735
+ case "And":
736
+ case "Or":
737
+ return generateJunction(generation, expression);
738
+ case "Prime":
739
+ return applyBuiltin(
740
+ generation,
741
+ "'",
742
+ [generateExpression(generation, expression.expression)],
743
+ location,
744
+ );
745
+ case "Unchanged":
746
+ return applyBuiltin(
747
+ generation,
748
+ "UNCHANGED",
749
+ [generateExpression(generation, expression.expression)],
750
+ location,
751
+ );
752
+ case "Enabled":
753
+ return applyBuiltin(
754
+ generation,
755
+ "ENABLED",
756
+ [generateExpression(generation, expression.expression)],
757
+ location,
758
+ );
759
+ case "Always":
760
+ return applyBuiltin(
761
+ generation,
762
+ "[]",
763
+ [generateExpression(generation, expression.expression)],
764
+ location,
765
+ );
766
+ case "Eventually":
767
+ return applyBuiltin(
768
+ generation,
769
+ "<>",
770
+ [generateExpression(generation, expression.expression)],
771
+ location,
772
+ );
773
+ case "If":
774
+ return applyBuiltin(
775
+ generation,
776
+ "$IfThenElse",
777
+ [
778
+ generateExpression(generation, expression.condition),
779
+ generateExpression(generation, expression.consequent),
780
+ generateExpression(generation, expression.alternative),
781
+ ],
782
+ location,
783
+ );
784
+ case "Case":
785
+ return generateCase(generation, expression);
786
+ case "Let":
787
+ return generateLet(generation, expression);
788
+ case "Forall":
789
+ case "Exists":
790
+ return generateBoundApplication(
791
+ generation,
792
+ expression.kind === "Forall" ? "$BoundedForall" : "$BoundedExists",
793
+ expression.bounds,
794
+ getExpressionSpan(generation.file, expression).start,
795
+ expression.body,
796
+ location,
797
+ );
798
+ case "UnboundedQuantifier": {
799
+ const span = getExpressionSpan(generation.file, expression);
800
+ const bodySpan = getExpressionSpan(generation.file, expression.body);
801
+ const indexes = findNameTokens(generation.file, span.start, bodySpan.start, expression.names);
802
+ const name = expression.isTemporal
803
+ ? expression.quantifier === "Forall"
804
+ ? "$TemporalForall"
805
+ : "$TemporalExists"
806
+ : expression.quantifier === "Forall"
807
+ ? "$UnboundedForall"
808
+ : "$UnboundedExists";
809
+ return withContext(generation, createContext(), () => {
810
+ const params = expression.names.map((paramName, index) =>
811
+ createFormalParam(
812
+ generation,
813
+ paramName,
814
+ 0,
815
+ getTokenLocation(generation.file, indexes[index]),
816
+ true,
817
+ ),
818
+ );
819
+ const body = generateWithParams(generation, params, expression.body);
820
+ return applyBuiltin(generation, name, [body], location, { unbounded: params });
821
+ });
822
+ }
823
+ case "Choose":
824
+ return generateChoose(generation, expression);
825
+ case "SetEnumeration":
826
+ return applyBuiltin(
827
+ generation,
828
+ "$SetEnumerate",
829
+ expression.elements.map((element) => generateExpression(generation, element)),
830
+ location,
831
+ );
832
+ case "Tuple":
833
+ return applyBuiltin(
834
+ generation,
835
+ "$Tuple",
836
+ expression.elements.map((element) => generateExpression(generation, element)),
837
+ location,
838
+ );
839
+ case "SetFilter": {
840
+ const range = generateExpression(generation, expression.bound.set);
841
+ const span = getExpressionSpan(generation.file, expression);
842
+ return withContext(generation, createContext(), () => {
843
+ const bounds = generateBoundsWithRanges(generation, [expression.bound], span.start, [
844
+ range,
845
+ ]);
846
+ const body = generateWithParams(generation, bounds.bounded.flat(), expression.predicate);
847
+ return applyBuiltin(generation, "$SubsetOf", [body], location, bounds);
848
+ });
849
+ }
850
+ case "SetMap":
851
+ return generateBoundApplication(
852
+ generation,
853
+ "$SetOfAll",
854
+ expression.bounds,
855
+ getExpressionSpan(generation.file, expression.expression).end + 1,
856
+ expression.expression,
857
+ location,
858
+ );
859
+ case "FunctionConstruction":
860
+ return generateBoundApplication(
861
+ generation,
862
+ "$FcnConstructor",
863
+ expression.bounds,
864
+ getExpressionSpan(generation.file, expression).start,
865
+ expression.body,
866
+ location,
867
+ );
868
+ case "FunctionSet":
869
+ return applyBuiltin(
870
+ generation,
871
+ "$SetOfFcns",
872
+ [
873
+ generateExpression(generation, expression.domain),
874
+ generateExpression(generation, expression.range),
875
+ ],
876
+ location,
877
+ );
878
+ case "Record":
879
+ return generateRecordFields(generation, "$RcdConstructor", expression);
880
+ case "RecordSet":
881
+ return generateRecordFields(generation, "$SetOfRcds", expression);
882
+ case "Except":
883
+ return generateExcept(generation, expression);
884
+ case "ExceptAt": {
885
+ const except = generation.exceptStack[generation.exceptStack.length - 1];
886
+ const component = generation.exceptSpecStack[generation.exceptSpecStack.length - 1];
887
+ if (except === undefined || component === undefined) {
888
+ generation.addError(location, "@ used where its meaning is not defined.");
889
+ return createNullNode(generation);
890
+ }
891
+ return {
892
+ ...createLevelFields(generation.getId()),
893
+ kind: "At",
894
+ except,
895
+ component,
896
+ location: component.location,
897
+ };
898
+ }
899
+ case "FunctionApplication": {
900
+ const functionNode = generateExpression(generation, expression.function);
901
+ if (isAbsent(functionNode)) return functionNode;
902
+ checkRecursion(generation, functionNode);
903
+ const operator = functionNode.kind === "OpAppl" ? functionNode.operator : undefined;
904
+ const body =
905
+ operator?.kind === "OpDef" && operator.defKind === "UserDefined"
906
+ ? operator.body
907
+ : undefined;
908
+ if (
909
+ body?.kind === "OpAppl" &&
910
+ (body.operator.name === "$NonRecursiveFcnSpec" ||
911
+ body.operator.name === "$RecursiveFcnSpec")
912
+ ) {
913
+ const paramCount = (body.bounded ?? []).reduce(
914
+ (count, params, index) => count + (body.tupleOrs?.[index] ? 1 : params.length),
915
+ 0,
916
+ );
917
+ if (expression.args.length >= 2 && paramCount !== expression.args.length) {
918
+ generation.addError(
919
+ location,
920
+ `Function '${operator?.name}' is defined with ${paramCount} parameters, but is applied to ${expression.args.length} arguments.`,
921
+ );
922
+ return createNullNode(generation);
923
+ }
924
+ }
925
+ const argument =
926
+ expression.args.length === 1
927
+ ? generateExpression(generation, expression.args[0])
928
+ : applyBuiltin(
929
+ generation,
930
+ "$Tuple",
931
+ expression.args.map((innerArgument) => generateExpression(generation, innerArgument)),
932
+ location,
933
+ );
934
+ return applyBuiltin(generation, "$FcnApply", [functionNode, argument], location);
935
+ }
936
+ case "FieldAccess": {
937
+ const record = generateExpression(generation, expression.record);
938
+ const span = getExpressionSpan(generation.file, expression);
939
+ return applyBuiltin(
940
+ generation,
941
+ "$RcdSelect",
942
+ [
943
+ record,
944
+ createString(generation, expression.field, getTokenLocation(generation.file, span.end)),
945
+ ],
946
+ location,
947
+ );
948
+ }
949
+ case "Product":
950
+ return applyBuiltin(
951
+ generation,
952
+ "$CartesianProd",
953
+ expression.factors.map((factor) => generateExpression(generation, factor)),
954
+ location,
955
+ );
956
+ case "BoxAction":
957
+ case "AngleAction":
958
+ return applyBuiltin(
959
+ generation,
960
+ expression.kind === "BoxAction" ? "$SquareAct" : "$AngleAct",
961
+ [
962
+ generateExpression(generation, expression.action),
963
+ generateExpression(generation, expression.subscript),
964
+ ],
965
+ location,
966
+ );
967
+ case "WeakFairness":
968
+ case "StrongFairness":
969
+ return applyBuiltin(
970
+ generation,
971
+ expression.kind === "WeakFairness" ? "$WF" : "$SF",
972
+ [
973
+ generateExpression(generation, expression.subscript),
974
+ generateExpression(generation, expression.action),
975
+ ],
976
+ location,
977
+ );
978
+ case "Label":
979
+ return generateLabel(generation, expression);
980
+ case "Subexpression":
981
+ return generateSelectorExpression(generation, expression);
982
+ }
983
+ };
984
+
985
+ const generateBoundsWithRanges = (
986
+ generation: ModuleGeneration,
987
+ bounds: Bound[],
988
+ searchStart: number,
989
+ ranges: ExprNode[],
990
+ ): BoundSymbols => {
991
+ const groups = getBoundGroups(bounds);
992
+ let cursor = searchStart;
993
+ const bounded = groups.map((group) => {
994
+ const setSpan = getExpressionSpan(generation.file, group[0].set);
995
+ const names = group.flatMap((bound) =>
996
+ bound.pattern.kind === "Name" ? [bound.pattern.name] : bound.pattern.names,
997
+ );
998
+ const indexes = findNameTokens(generation.file, cursor, setSpan.start, names);
999
+ cursor = setSpan.end + 1;
1000
+ return names.map((name, index) =>
1001
+ createFormalParam(
1002
+ generation,
1003
+ name,
1004
+ 0,
1005
+ getTokenLocation(generation.file, indexes[index]),
1006
+ true,
1007
+ ),
1008
+ );
1009
+ });
1010
+ return {
1011
+ bounded,
1012
+ tupleOrs: groups.map((group) => group[0].pattern.kind === "Tuple"),
1013
+ ranges,
1014
+ };
1015
+ };
1016
+
1017
+ const generateLabel = (
1018
+ generation: ModuleGeneration,
1019
+ expression: Expression & { kind: "Label" },
1020
+ ): LabelNode | OpApplNode => {
1021
+ const location = getLocation(generation.file, expression);
1022
+ const scope = generation.labelScopes.at(-1);
1023
+ if (scope === undefined) {
1024
+ generation.addError(location, "Label not in definition or proof step.");
1025
+ return createNullNode(generation);
1026
+ }
1027
+ if (
1028
+ generation.assumeProveState.isDeclared
1029
+ .slice(2, generation.assumeProveState.depth + 1)
1030
+ .some(Boolean)
1031
+ ) {
1032
+ generation.addError(
1033
+ location,
1034
+ "Label not allowed within scope of declaration in nested ASSUME/PROVE.",
1035
+ );
1036
+ return createNullNode(generation);
1037
+ }
1038
+ if (generation.exceptStack.length > 0 && generation.exceptSpecStack.length > 0) {
1039
+ generation.addError(location, "Labels inside EXCEPT clauses are not yet implemented.");
1040
+ return createNullNode(generation);
1041
+ }
1042
+ pushLabelScope(generation);
1043
+ const body = generateExpression(generation, expression.body);
1044
+ const labels = popLabels(generation);
1045
+ const paramIndexes = findNameTokens(
1046
+ generation.file,
1047
+ getExpressionSpan(generation.file, expression).start,
1048
+ getExpressionSpan(generation.file, expression.body).start,
1049
+ expression.params,
1050
+ );
1051
+ const params = expression.params.map((name, index) => {
1052
+ const symbol = resolveSymbol(generation.contexts, name);
1053
+ if (symbol?.kind === "FormalParam") return symbol;
1054
+ const paramLocation = getTokenLocation(generation.file, paramIndexes[index]);
1055
+ generation.addError(paramLocation, `Illegal parameter ${name} of label \`${expression.name}'.`);
1056
+ return createFormalParam(generation, name, 0, paramLocation, false);
1057
+ });
1058
+ const label: LabelNode = {
1059
+ ...createLevelFields(generation.getId()),
1060
+ kind: "Label",
1061
+ name: expression.name,
1062
+ params,
1063
+ body,
1064
+ labels,
1065
+ isAssumeProve: false,
1066
+ location,
1067
+ };
1068
+ const named = new Set<FormalParamNode>();
1069
+ params.forEach((param) => {
1070
+ if (named.has(param)) {
1071
+ generation.addError(
1072
+ location,
1073
+ `Repeated formal parameter ${param.name} \nin label \`${label.name}'.`,
1074
+ );
1075
+ }
1076
+ named.add(param);
1077
+ });
1078
+ scope.params.flat().forEach((param) => {
1079
+ if (!named.delete(param)) {
1080
+ generation.addError(
1081
+ location,
1082
+ `Label ${label.name} must contain formal parameter \`${param.name}'.`,
1083
+ );
1084
+ }
1085
+ });
1086
+ if (named.size > 0) {
1087
+ const extras = [...named].map((param) => `${param.name} `).join("");
1088
+ generation.addError(location, `Label ${label.name} declares extra parameter(s) ${extras}`);
1089
+ }
1090
+ if (scope.labels.has(label.name))
1091
+ generation.addError(location, `Duplicate label \`${label.name}'.`);
1092
+ else scope.labels.set(label.name, label);
1093
+ const goal = generation.assumeProveState.goal;
1094
+ if (goal)
1095
+ generation.labelGoals.set(label, {
1096
+ scope: goal,
1097
+ clause: generation.assumeProveState.goalClause,
1098
+ });
1099
+ return label;
1100
+ };