tla-ts 0.0.10-dev.99796fe03 → 0.0.10-dev.a17d6d9fa

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