tla-ts 0.0.3-dev.4cf9a33 → 0.0.3-dev.4fdd845

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 (81) hide show
  1. package/dist/cli.cjs +1 -1
  2. package/dist/cli.js +1 -1
  3. package/dist/index.cjs +1 -1
  4. package/dist/index.d.cts +164 -40
  5. package/dist/index.d.ts +164 -40
  6. package/dist/index.js +1 -1
  7. package/dist/parallel-worker.cjs +1 -1
  8. package/dist/parallel-worker.js +2 -2
  9. package/dist/parallel.cjs +1 -1
  10. package/dist/parallel.js +2 -2
  11. package/dist/run-cli.cjs +1351 -22
  12. package/dist/run-cli.js +1351 -22
  13. package/dist/transfer.cjs +83 -34
  14. package/dist/transfer.js +83 -34
  15. package/package.json +5 -1
  16. package/src/ast.ts +49 -6
  17. package/src/bags.ts +4 -7
  18. package/src/builtins.ts +29 -11
  19. package/src/bundled-modules.ts +3 -3
  20. package/src/canonical.ts +4 -3
  21. package/src/check.ts +1331 -367
  22. package/src/cli.ts +8 -1
  23. package/src/codegen.ts +68 -21
  24. package/src/config.ts +225 -206
  25. package/src/environment.ts +417 -124
  26. package/src/errors.ts +168 -9
  27. package/src/evaluate.ts +720 -177
  28. package/src/exit-codes.ts +6 -24
  29. package/src/index.ts +1 -0
  30. package/src/instances.ts +3 -1
  31. package/src/java-overrides.ts +104 -25
  32. package/src/levels.ts +149 -31
  33. package/src/lexer.ts +32 -4
  34. package/src/live-check.ts +204 -148
  35. package/src/liveness.ts +191 -122
  36. package/src/obligation-expression.ts +2 -2
  37. package/src/obligation-source.ts +2 -0
  38. package/src/parallel-worker.ts +6 -1
  39. package/src/parallel.ts +57 -6
  40. package/src/parser.ts +419 -122
  41. package/src/pcal-ast.ts +770 -0
  42. package/src/pcal-parse.ts +1523 -0
  43. package/src/pcal-tokenize.ts +516 -0
  44. package/src/pcal-translate.ts +1230 -0
  45. package/src/pcal-validate.ts +454 -0
  46. package/src/randomization.ts +24 -7
  47. package/src/resolve.ts +1334 -452
  48. package/src/run-cli.ts +1166 -181
  49. package/src/runtime.ts +16 -0
  50. package/src/sany-builtins.ts +147 -0
  51. package/src/sany-generator.ts +3112 -0
  52. package/src/sany-levels.ts +1208 -0
  53. package/src/sany-lexer.ts +545 -0
  54. package/src/sany-linter.ts +122 -0
  55. package/src/sany-modules.ts +1398 -0
  56. package/src/sany-nodes.ts +463 -0
  57. package/src/sany-parse-error.ts +2161 -0
  58. package/src/sany-report.ts +354 -0
  59. package/src/sany-selectors.ts +738 -0
  60. package/src/sany-source.ts +248 -0
  61. package/src/sany-xml.ts +1017 -0
  62. package/src/spec-description.ts +25 -5
  63. package/src/standard-modules.ts +203 -146
  64. package/src/standard-ranges.ts +116 -0
  65. package/src/state-graph.ts +29 -6
  66. package/src/subexpressions.ts +221 -161
  67. package/src/substitution-levels.ts +38 -17
  68. package/src/successors.ts +161 -167
  69. package/src/symmetry.ts +168 -50
  70. package/src/tableau.ts +3 -1
  71. package/src/tlc-ext.ts +13 -17
  72. package/src/tlc-messages.ts +329 -0
  73. package/src/tlc-module.ts +49 -21
  74. package/src/tlc-modules.ts +0 -4
  75. package/src/tlc-order.ts +55 -9
  76. package/src/tlc-random.ts +28 -3
  77. package/src/tlc-replay.ts +655 -0
  78. package/src/tlc-version.ts +18 -0
  79. package/src/transfer.ts +15 -3
  80. package/src/value-sources.ts +29 -0
  81. package/src/values.ts +683 -256
package/src/resolve.ts CHANGED
@@ -4,51 +4,121 @@ import {
4
4
  type AssumeProve,
5
5
  type Bound,
6
6
  type BoundPattern,
7
+ type Declaration,
7
8
  type Definition,
8
9
  type Expression,
10
+ type Fact,
9
11
  type Instance,
12
+ type LabelExpression,
10
13
  type Module,
11
14
  type NewSymbol,
12
15
  type OperatorParam,
13
16
  type Proof,
14
17
  type ProofStep,
18
+ type Selector,
15
19
  type SourceLocation,
16
20
  type SourceRange,
17
21
  type Theorem,
18
22
  } from "./ast";
19
- import {
20
- createSanyError,
21
- createSemanticError,
22
- formatRange,
23
- TlaSyntaxError,
24
- type SanyError,
25
- } from "./errors";
26
-
27
- export interface ModuleSymbol {
28
- key: string;
23
+ import { formatRange, TlaSyntaxError, type SanyError } from "./errors";
24
+
25
+ // The kinds of symbol SANY tells apart when it binds a name twice. A parameter is also a bound name,
26
+ // and a NEW symbol has a kind for each level.
27
+ export type SymbolKind =
28
+ | "Builtin"
29
+ | "Constant"
30
+ | "Variable"
31
+ | "Definition"
32
+ | "Instance"
33
+ | "Theorem"
34
+ | "Parameter"
35
+ | `New${NewSymbol["level"]}`;
36
+
37
+ // range is where SANY reports the symbol, and two symbols at one range are one node to SANY. params
38
+ // holds the arity of each parameter of a defined operator.
39
+ export interface Binding {
40
+ kind: SymbolKind;
29
41
  arity: number;
30
- declaration?: "Constant" | "Variable";
42
+ params?: number[];
43
+ range?: SourceRange;
44
+ }
45
+
46
+ export interface ModuleSymbol extends Binding {
47
+ key: string;
31
48
  }
32
49
 
33
50
  export type Symbols = Map<string, ModuleSymbol>;
34
51
 
35
- interface LocalName {
52
+ // A named theorem or proof step whose parts a name such as foo!lab or <1>2!1 selects. isInProof
53
+ // holds while SANY analyzes the proof of the theorem or step.
54
+ interface Goal {
55
+ statement: Expression | AssumeProve;
56
+ isSuffices: boolean;
57
+ isInProof: boolean;
58
+ }
59
+
60
+ // isPending holds for an operator a RECURSIVE declaration names until its definition.
61
+ interface LocalName extends Binding {
36
62
  name: string;
37
- arity: number;
38
63
  parent: LocalName | undefined;
64
+ goal?: Goal;
65
+ isPending?: boolean;
66
+ }
67
+
68
+ // A name the module binds, from position on.
69
+ interface ModuleBinding extends Binding {
70
+ position: SourceLocation;
71
+ isPending?: boolean;
39
72
  }
40
73
 
74
+ // errors and warnings collect what SANY reports while it goes on analyzing the unit, and bindings
75
+ // holds the names the module binds. A label may appear where hasLabelScope holds, in a definition, a
76
+ // named theorem, or a numbered step, except where isLabelForbidden holds, in the scope of a NEW in a
77
+ // nested ASSUME, or where isInExcept holds, in the new value of an EXCEPT. labelParams holds the
78
+ // names bound since the innermost definition, label, or step, which a label must take as parameters,
79
+ // and labels the labels there. isGenerated holds in a definition tla-ts generates for a LET INSTANCE,
80
+ // and in a subexpression that a name selects, which SANY analyzes where it is defined.
81
+ // getInstance gives what an INSTANCE in a LET or a proof instantiates.
41
82
  interface Unit {
42
83
  imported: Symbols;
84
+ getInstance: (instance: Instance) => InstancedModule;
43
85
  definitions: Map<string, Definition>;
44
86
  getKey: (definition: Definition) => string;
45
87
  location: SourceLocation;
46
88
  self: Definition | undefined;
47
89
  facts: Set<string>;
90
+ goals: Map<string, Goal>;
91
+ bindings: Map<string, ModuleBinding>;
92
+ errors: SanyError[];
93
+ warnings: SanyError[];
94
+ hasLabelScope: boolean;
95
+ isLabelForbidden: boolean;
96
+ isInExcept: boolean;
97
+ labelParams: string[];
98
+ labels: Set<string>;
99
+ isGenerated: boolean;
48
100
  }
49
101
 
102
+ interface SelectionError {
103
+ args: Expression[];
104
+ error: SanyError;
105
+ }
106
+
107
+ interface SelectionState {
108
+ node: Expression | NewSymbol | AssumeProve;
109
+ isGoal: boolean;
110
+ isSufficesOpen: boolean;
111
+ }
112
+
113
+ type Reference = Expression & { kind: "Identifier" | "Apply" | "Subexpression" };
114
+
50
115
  export const LOCAL_RESOLUTION = { kind: "Local" } as const;
51
116
 
117
+ // The subexpressions that names select, and for a name that selects none, the error SANY reports and
118
+ // the arguments it analyzes before it.
119
+ export const selections = new WeakSet<Expression>();
120
+ export const selectionErrors = new WeakMap<Expression, SelectionError>();
121
+
52
122
  const renamedArities = new WeakMap<Expression, number>();
53
123
 
54
124
  export const KEY_SEPARATOR = "@";
@@ -60,7 +130,7 @@ const isKey = (name: string) => {
60
130
  };
61
131
 
62
132
  const CORE_SYMBOLS: Symbols = new Map(
63
- ["~>", "-+->", "\\cdot"].map((name) => [name, { key: name, arity: 2 }]),
133
+ ["~>", "-+->", "\\cdot"].map((name) => [name, { key: name, arity: 2, kind: "Builtin" }]),
64
134
  );
65
135
 
66
136
  export const isBefore = (left: SourceLocation, right: SourceLocation) =>
@@ -69,6 +139,9 @@ export const isBefore = (left: SourceLocation, right: SourceLocation) =>
69
139
  export const getArity = (definition: Definition) =>
70
140
  definition.kind === "Operator" ? definition.params.length : 0;
71
141
 
142
+ export const getParamArities = (definition: Definition) =>
143
+ definition.kind === "Operator" ? definition.params.map((param) => param.arity) : [];
144
+
72
145
  const isInstantiated = (definition: Definition) => definition.name.includes("!");
73
146
 
74
147
  const lookupLocal = (scope: LocalName | undefined, name: string) => {
@@ -78,12 +151,99 @@ const lookupLocal = (scope: LocalName | undefined, name: string) => {
78
151
  return undefined;
79
152
  };
80
153
 
81
- const bindNames = (scope: LocalName | undefined, names: string[], arity = 0) =>
82
- names.reduce<LocalName | undefined>((parent, name) => ({ name, arity, parent }), scope);
154
+ // A name the module binds before the unit and before the range, which a copy of a subexpression
155
+ // that a reference selects keeps from its definition.
156
+ const getModuleBinding = (name: string, unit: Unit, range: SourceRange | undefined) => {
157
+ const binding = unit.bindings.get(name);
158
+ return binding &&
159
+ isBefore(binding.position, unit.location) &&
160
+ (!range || isBefore(binding.position, range.start))
161
+ ? binding
162
+ : undefined;
163
+ };
164
+
165
+ const isSameRange = (left: SourceRange | undefined, right: SourceRange | undefined) =>
166
+ left !== undefined && right !== undefined && formatRange(left) === formatRange(right);
167
+
168
+ // SymbolTable.addSymbol binds a name nothing binds yet. It rejects a built-in operator, a parameter
169
+ // or bound name already in use, and a symbol of another kind or arity than the one bound, and warns
170
+ // of any other duplicate. tla-ts binds a symbol SANY never sees, such as one it generates. Tells
171
+ // whether to bind the added symbol.
172
+ const isBindable = (name: string, current: Binding | undefined, added: Binding, unit: Unit) => {
173
+ if (current === undefined) return true;
174
+ if (isSameRange(current.range, added.range)) return false;
175
+ const range = added.range;
176
+ if (range === undefined || unit.isGenerated || (current.kind !== "Builtin" && !current.range)) {
177
+ return true;
178
+ }
179
+ const location = formatRange(range);
180
+ const existing = current.range && formatRange(current.range);
181
+ if (current.kind === "Builtin") {
182
+ unit.errors.push({
183
+ location,
184
+ message: `Symbol ${name} is a built-in operator, and cannot be redefined.`,
185
+ });
186
+ } else if (
187
+ added.kind === "Parameter" ||
188
+ current.kind !== added.kind ||
189
+ current.arity !== added.arity
190
+ ) {
191
+ unit.errors.push({
192
+ location,
193
+ message: `Multiply-defined symbol '${name}': this definition or declaration conflicts \nwith the one at ${existing}.`,
194
+ });
195
+ } else {
196
+ unit.warnings.push({
197
+ location,
198
+ message: `Multiple declarations or definitions for symbol ${name}. \nThis duplicates the one at ${existing}.`,
199
+ });
200
+ }
201
+ return false;
202
+ };
203
+
204
+ const bindName = (
205
+ scope: LocalName | undefined,
206
+ name: string,
207
+ added: Binding,
208
+ unit: Unit,
209
+ ): LocalName | undefined =>
210
+ isBindable(
211
+ name,
212
+ lookupLocal(scope, name) ?? getModuleBinding(name, unit, added.range),
213
+ added,
214
+ unit,
215
+ )
216
+ ? { ...added, name, parent: scope }
217
+ : scope;
218
+
219
+ // Binds the names of a module from the unit on.
220
+ const bindModuleName = (name: string, added: Binding, unit: Unit) => {
221
+ if (isBindable(name, unit.bindings.get(name), added, unit)) {
222
+ unit.bindings.set(name, { ...added, position: unit.location });
223
+ }
224
+ };
225
+
226
+ const bindNames = (
227
+ scope: LocalName | undefined,
228
+ names: string[],
229
+ ranges: SourceRange[] | undefined,
230
+ unit: Unit,
231
+ ) =>
232
+ names.reduce(
233
+ (parent, name, index) =>
234
+ bindName(parent, name, { kind: "Parameter", arity: 0, range: ranges?.[index] }, unit),
235
+ scope,
236
+ );
83
237
 
84
- const bindParams = (scope: LocalName | undefined, params: OperatorParam[]) =>
85
- params.reduce<LocalName | undefined>(
86
- (parent, param) => ({ name: param.name, arity: param.arity, parent }),
238
+ const bindParams = (scope: LocalName | undefined, params: OperatorParam[], unit: Unit) =>
239
+ params.reduce(
240
+ (parent, param) =>
241
+ bindName(
242
+ parent,
243
+ param.name,
244
+ { kind: "Parameter", arity: param.arity, range: param.location?.range },
245
+ unit,
246
+ ),
87
247
  scope,
88
248
  );
89
249
 
@@ -106,10 +266,18 @@ const getVisibleDefinition = (name: string, unit: Unit) => {
106
266
  const findSymbol = (name: string, unit: Unit): ModuleSymbol | undefined => {
107
267
  const definition = getVisibleDefinition(name, unit);
108
268
  return definition
109
- ? { key: unit.getKey(definition), arity: getArity(definition) }
269
+ ? {
270
+ key: unit.getKey(definition),
271
+ arity: getArity(definition),
272
+ params: getParamArities(definition),
273
+ kind: "Definition",
274
+ }
110
275
  : unit.imported.get(name);
111
276
  };
112
277
 
278
+ const findBinding = (name: string, scope: LocalName | undefined, unit: Unit): Binding | undefined =>
279
+ lookupLocal(scope, name) ?? findSymbol(name, unit);
280
+
113
281
  // SANY reports a name at the range of its text.
114
282
  const getNameRange = (location: SourceLocation, name: string): SourceRange => ({
115
283
  module: location.range?.module ?? "",
@@ -134,6 +302,407 @@ const isOperatorSymbol = (name: string) =>
134
302
  const isStepName = (name: string) =>
135
303
  name.startsWith("<") && ((name[1] >= "0" && name[1] <= "9") || name[1] === "*");
136
304
 
305
+ export const getOperandIndex = (operand: number | "<<" | ">>", count: number) => {
306
+ if (typeof operand === "number") return operand >= 1 && operand <= count ? operand - 1 : -1;
307
+ if (operand === "<<") return count > 0 ? 0 : -1;
308
+ return count === 2 ? 1 : -1;
309
+ };
310
+
311
+ // The parts of a name such as F(x)!l(y), each with its own arguments. counts holds the number each
312
+ // part takes, when a part before the last takes some.
313
+ export const getNameSelectors = (
314
+ name: string,
315
+ args: Expression[],
316
+ counts: number[] | undefined,
317
+ ): Selector[] => {
318
+ const parts = name.split("!");
319
+ const partCounts =
320
+ counts ?? parts.map((_, index) => (index === parts.length - 1 ? args.length : 0));
321
+ return parts.map((part, index) => {
322
+ const start = partCounts.slice(0, index).reduce((sum, count) => sum + count, 0);
323
+ return { kind: "Name", name: part, args: args.slice(start, start + partCounts[index]) };
324
+ });
325
+ };
326
+
327
+ const getSelectors = (reference: Reference): Selector[] =>
328
+ reference.kind === "Subexpression"
329
+ ? reference.selectors
330
+ : reference.kind === "Identifier"
331
+ ? getNameSelectors(reference.name, [], undefined)
332
+ : getNameSelectors(reference.operator, reference.args, reference.argumentCounts);
333
+
334
+ const getBoundSets = (bounds: Bound[]) =>
335
+ bounds
336
+ .filter((bound, index) => index === 0 || bounds[index - 1].set !== bound.set)
337
+ .map((bound) => bound.set);
338
+
339
+ // The names a binder binds, its body, and the sets it binds them to, which a selector such as !1
340
+ // chooses from.
341
+ export const getBinder = (
342
+ expression: Expression,
343
+ ): { names: string[]; body: Expression; sets: Expression[] } | undefined => {
344
+ switch (expression.kind) {
345
+ case "Forall":
346
+ case "Exists":
347
+ case "FunctionConstruction":
348
+ return {
349
+ names: getBoundNames(expression.bounds),
350
+ body: expression.body,
351
+ sets: getBoundSets(expression.bounds),
352
+ };
353
+ case "SetMap":
354
+ return {
355
+ names: getBoundNames(expression.bounds),
356
+ body: expression.expression,
357
+ sets: getBoundSets(expression.bounds),
358
+ };
359
+ case "SetFilter":
360
+ return {
361
+ names: getPatternNames(expression.bound.pattern),
362
+ body: expression.predicate,
363
+ sets: [expression.bound.set],
364
+ };
365
+ case "Choose":
366
+ return {
367
+ names: getPatternNames(expression.pattern),
368
+ body: expression.body,
369
+ sets: expression.set ? [expression.set] : [],
370
+ };
371
+ case "UnboundedQuantifier":
372
+ case "Lambda":
373
+ return {
374
+ names: expression.kind === "Lambda" ? expression.params : expression.names,
375
+ body: expression.body,
376
+ sets: [],
377
+ };
378
+ default:
379
+ return undefined;
380
+ }
381
+ };
382
+
383
+ // The operands that a selector such as !1 chooses from, where they do not depend on bound names.
384
+ export const getOperands = (expression: Expression): Expression[] | undefined => {
385
+ switch (expression.kind) {
386
+ case "Apply":
387
+ return expression.args;
388
+ case "And":
389
+ case "Or":
390
+ return expression.operands;
391
+ case "If":
392
+ return [expression.condition, expression.consequent, expression.alternative];
393
+ case "Tuple":
394
+ case "SetEnumeration":
395
+ return expression.elements;
396
+ case "Record":
397
+ case "RecordSet":
398
+ return expression.fields.map((field) => field.value);
399
+ case "FunctionApplication":
400
+ return [
401
+ expression.function,
402
+ expression.args.length === 1
403
+ ? expression.args[0]
404
+ : { kind: "Tuple", elements: expression.args, location: expression.location },
405
+ ];
406
+ case "FieldAccess":
407
+ return [
408
+ expression.record,
409
+ { kind: "String", value: expression.field, location: expression.location },
410
+ ];
411
+ case "Prime":
412
+ case "Unchanged":
413
+ case "Enabled":
414
+ case "Always":
415
+ case "Eventually":
416
+ return [expression.expression];
417
+ case "BoxAction":
418
+ case "AngleAction":
419
+ return [expression.action, expression.subscript];
420
+ case "WeakFairness":
421
+ case "StrongFairness":
422
+ return [expression.subscript, expression.action];
423
+ case "FunctionSet":
424
+ return [expression.domain, expression.range];
425
+ case "Product":
426
+ return expression.factors;
427
+ case "Except":
428
+ return [expression.function];
429
+ default:
430
+ return undefined;
431
+ }
432
+ };
433
+
434
+ const isReference = (expression: Expression): expression is Reference =>
435
+ expression.kind === "Identifier" ||
436
+ expression.kind === "Apply" ||
437
+ expression.kind === "Subexpression";
438
+
439
+ const isInScopeOfDeclaration = (assumeProve: AssumeProve, clause: number) =>
440
+ assumeProve.assumptions.slice(0, clause).some((assumption) => assumption.kind === "NewSymbol");
441
+
442
+ const findLabel = (expression: Expression, name: string): LabelExpression | undefined => {
443
+ if (expression.kind === "Label") return expression.name === name ? expression : undefined;
444
+ if (expression.kind === "Lambda") return undefined;
445
+ if (expression.kind === "Let") return findLabel(expression.body, name);
446
+ return getChildren(expression).reduce<LabelExpression | undefined>(
447
+ (found, child) => found ?? findLabel(child, name),
448
+ undefined,
449
+ );
450
+ };
451
+
452
+ // SANY drops a label in the scope of a NEW in a nested ASSUME, after it reports the label.
453
+ const findClauseLabel = (
454
+ clause: Expression | NewSymbol | AssumeProve,
455
+ name: string,
456
+ isForbidden: boolean,
457
+ ): LabelExpression | undefined => {
458
+ if (clause.kind === "AssumeProve") {
459
+ return [...clause.assumptions, clause.conclusion].reduce<LabelExpression | undefined>(
460
+ (found, inner, index) =>
461
+ found ?? findClauseLabel(inner, name, isForbidden || isInScopeOfDeclaration(clause, index)),
462
+ undefined,
463
+ );
464
+ }
465
+ if (isForbidden) return undefined;
466
+ if (clause.kind === "NewSymbol") return clause.set && findLabel(clause.set, name);
467
+ return findLabel(clause, name);
468
+ };
469
+
470
+ const getLabelBody = (expression: Expression): Expression =>
471
+ expression.kind === "Label" ? getLabelBody(expression.body) : expression;
472
+
473
+ const getOperandName = (operand: number | "<<" | ">>") =>
474
+ typeof operand === "number" ? `argument selector ${operand}` : operand;
475
+
476
+ const SCOPE_MESSAGE = "within the scope of a declaration\n from outside that declaration's scope.";
477
+
478
+ // Generator.selectorToNode for a name that selects part of a theorem or step. A part in the scope of
479
+ // a NEW in its ASSUME may be selected only within the proof of the theorem, or only after the proof
480
+ // of a SUFFICES step. A label takes its own arguments, and an operand must exist, unless the part
481
+ // selected depends on bound names. A fact may select an ASSUME/PROVE or a NEW clause.
482
+ const checkSelection = (
483
+ reference: Reference,
484
+ selectors: Selector[],
485
+ goal: Goal,
486
+ scope: LocalName | undefined,
487
+ unit: Unit,
488
+ isFact: boolean,
489
+ ) => {
490
+ const report = (index: number | undefined, message: string) => {
491
+ const range =
492
+ (index === undefined ? undefined : reference.selectorRanges?.[index]) ??
493
+ reference.location.range;
494
+ if (range) unit.errors.push({ location: formatRange(range), message });
495
+ };
496
+ const isOutOfScope = goal.isSuffices === goal.isInProof;
497
+ const statement = goal.statement;
498
+ const state: SelectionState = {
499
+ node: statement,
500
+ isGoal: true,
501
+ isSufficesOpen: goal.isSuffices,
502
+ };
503
+ for (const [offset, selector] of selectors.slice(1).entries()) {
504
+ const index = offset + 1;
505
+ const node = state.node;
506
+ if (selector.kind === "Name") {
507
+ if (selectors[index - 1].kind !== "Name") {
508
+ const isLet =
509
+ node.kind !== "NewSymbol" &&
510
+ node.kind !== "AssumeProve" &&
511
+ getLabelBody(node).kind === "Let";
512
+ return isLet
513
+ ? undefined
514
+ : report(index - 1, "A name selector here must be from a LET clause.");
515
+ }
516
+ const clauses =
517
+ statement.kind === "AssumeProve"
518
+ ? [...statement.assumptions, statement.conclusion]
519
+ : [statement];
520
+ const found =
521
+ index === 1
522
+ ? clauses
523
+ .map((clause, position) => ({
524
+ position,
525
+ label: findClauseLabel(clause, selector.name, false),
526
+ }))
527
+ .find((item) => item.label !== undefined)
528
+ : {
529
+ position: 0,
530
+ label: node.kind === "Label" ? findLabel(node.body, selector.name) : undefined,
531
+ };
532
+ if (!found?.label) return report(index, `Cannot find label \`${selector.name}'.`);
533
+ if (
534
+ index === 1 &&
535
+ statement.kind === "AssumeProve" &&
536
+ isInScopeOfDeclaration(statement, found.position) &&
537
+ isOutOfScope
538
+ ) {
539
+ return report(
540
+ 1,
541
+ `Accessing subexpression labeled \`${selector.name}' of ASSUME/PROVE clause ${SCOPE_MESSAGE}`,
542
+ );
543
+ }
544
+ if (selector.args.length !== found.label.params.length) {
545
+ return report(index, `Label \`${selector.name}' used with wrong number of arguments.`);
546
+ }
547
+ state.node = found.label;
548
+ state.isGoal = false;
549
+ state.isSufficesOpen = false;
550
+ continue;
551
+ }
552
+ if (selector.kind !== "Operand") return;
553
+ const operand = getOperandName(selector.operand);
554
+ if (state.isSufficesOpen) {
555
+ if (getOperandIndex(selector.operand, 1) !== 0) {
556
+ return report(
557
+ index,
558
+ node.kind === "AssumeProve"
559
+ ? "Accessing non-existent subexpression of a SUFFICES"
560
+ : `Nonexistent operand specified by \`${operand}'.`,
561
+ );
562
+ }
563
+ state.isSufficesOpen = false;
564
+ continue;
565
+ }
566
+ if (node.kind === "NewSymbol") return;
567
+ if (node.kind !== "AssumeProve") {
568
+ const expression = getLabelBody(node);
569
+ if (["Number", "Decimal", "String"].includes(expression.kind)) {
570
+ return report(index, "Selecting subexpression of expression that has none.");
571
+ }
572
+ const kind =
573
+ expression.kind === "Identifier"
574
+ ? findBinding(expression.name, scope, unit)?.kind
575
+ : undefined;
576
+ if (kind === "Variable" || kind?.startsWith("New")) {
577
+ return report(index, `Choosing operand \`${operand}' of subexpression with no operands.`);
578
+ }
579
+ const sets = getBinder(expression)?.sets;
580
+ const operands =
581
+ expression.kind === "Identifier"
582
+ ? []
583
+ : sets
584
+ ? sets.length > 0
585
+ ? sets
586
+ : undefined
587
+ : expression.kind === "Except"
588
+ ? undefined
589
+ : getOperands(expression);
590
+ if (!operands) return;
591
+ const position = getOperandIndex(selector.operand, operands.length);
592
+ if (position === -1) return report(index, `Nonexistent operand specified by \`${operand}'.`);
593
+ state.node = operands[position];
594
+ state.isGoal = false;
595
+ continue;
596
+ }
597
+ const clauses = [...node.assumptions, node.conclusion];
598
+ const position = getOperandIndex(selector.operand, clauses.length);
599
+ if (position === -1) return report(index, `Nonexistent operand specified by \`${operand}'.`);
600
+ if (isInScopeOfDeclaration(node, position) && (!state.isGoal || isOutOfScope)) {
601
+ return report(index, `Accessing ASSUME/PROVE clause ${SCOPE_MESSAGE}`);
602
+ }
603
+ const clause = clauses[position];
604
+ if (clause.kind === "NewSymbol" && index !== selectors.length - 1) {
605
+ return report(index, "Selected a subexpression of a NEW clause of an ASSUME.");
606
+ }
607
+ state.node = clause;
608
+ state.isGoal = false;
609
+ }
610
+ if (isFact) return;
611
+ if (state.node.kind === "AssumeProve") {
612
+ report(undefined, "Selected ASSUME/PROVE instead of expression.");
613
+ }
614
+ if (state.node.kind === "NewSymbol") {
615
+ report(undefined, "Selected a NEW declaration as an expression or operator.");
616
+ }
617
+ };
618
+
619
+ // Generator.generateLabel reports a label where it may not appear, and skips the label's body.
620
+ const isLabelReported = (label: LabelExpression, unit: Unit) => {
621
+ const message = unit.isGenerated
622
+ ? undefined
623
+ : !unit.hasLabelScope
624
+ ? "Label not in definition or proof step."
625
+ : unit.isLabelForbidden
626
+ ? "Label not allowed within scope of declaration in nested ASSUME/PROVE."
627
+ : unit.isInExcept
628
+ ? "Labels inside EXCEPT clauses are not yet implemented."
629
+ : undefined;
630
+ if (message === undefined || !label.location.range) return false;
631
+ unit.errors.push({ location: formatRange(label.location.range), message });
632
+ return true;
633
+ };
634
+
635
+ // Generator.generateLabel reports, after the label's body, each parameter that names no bound name,
636
+ // then formalParamsEqual each parameter given twice, each name bound since the label scope began
637
+ // that the label leaves out, and the parameters it adds, and then a label of a name already used.
638
+ const checkLabel = (label: LabelExpression, scope: LocalName | undefined, unit: Unit) => {
639
+ const range = label.location.range;
640
+ if (!range || unit.isGenerated) return;
641
+ const location = formatRange(range);
642
+ const legal = label.params.filter((param, index) => {
643
+ const isLegal = lookupLocal(scope, param)?.kind === "Parameter";
644
+ const paramRange = label.paramRanges?.[index];
645
+ if (!isLegal && paramRange) {
646
+ unit.errors.push({
647
+ location: formatRange(paramRange),
648
+ message: `Illegal parameter ${param} of label \`${label.name}'.`,
649
+ });
650
+ }
651
+ return isLegal;
652
+ });
653
+ legal
654
+ .filter((param, index) => legal.indexOf(param) !== index)
655
+ .forEach((param) =>
656
+ unit.errors.push({
657
+ location,
658
+ message: `Repeated formal parameter ${param} \nin label \`${label.name}'.`,
659
+ }),
660
+ );
661
+ unit.labelParams
662
+ .filter((param) => !legal.includes(param))
663
+ .forEach((param) =>
664
+ unit.errors.push({
665
+ location,
666
+ message: `Label ${label.name} must contain formal parameter \`${param}'.`,
667
+ }),
668
+ );
669
+ const extra = [
670
+ ...new Set(legal.filter((param) => !unit.labelParams.includes(param))),
671
+ ...label.params.filter((param) => !legal.includes(param)),
672
+ ];
673
+ if (extra.length > 0) {
674
+ unit.errors.push({
675
+ location,
676
+ message: `Label ${label.name} declares extra parameter(s) ${extra.map((param) => `${param} `).join("")}`,
677
+ });
678
+ }
679
+ if (unit.labels.has(label.name)) {
680
+ unit.errors.push({ location, message: `Duplicate label \`${label.name}'.` });
681
+ }
682
+ unit.labels.add(label.name);
683
+ };
684
+
685
+ // Checks a name that selects part of a theorem or step, and tells whether it is one.
686
+ const checkReference = (
687
+ expression: Expression,
688
+ scope: LocalName | undefined,
689
+ unit: Unit,
690
+ isFact: boolean,
691
+ ) => {
692
+ if (!isReference(expression)) return false;
693
+ const selectors = getSelectors(expression);
694
+ const first = selectors[0];
695
+ const goal =
696
+ selectors.length > 1 && first.kind === "Name"
697
+ ? (lookupLocal(scope, first.name)?.goal ?? unit.goals.get(first.name))
698
+ : undefined;
699
+ if (goal) checkSelection(expression, selectors, goal, scope, unit, isFact);
700
+ return goal !== undefined;
701
+ };
702
+
703
+ // Generator.selectorToNode reports an unknown operator and goes on without analyzing its arguments,
704
+ // so its arity is undefined. It does the same for an operator given the wrong number of arguments,
705
+ // and for a name that selects nothing, after the arguments of the parts before.
137
706
  const getSymbolArity = (
138
707
  expression: Expression & { kind: "Identifier" | "Apply" | "OperatorReference" },
139
708
  name: string,
@@ -141,10 +710,13 @@ const getSymbolArity = (
141
710
  unit: Unit,
142
711
  ) => {
143
712
  const location = expression.location;
713
+ if (isSelectionReported(expression, scope, unit)) return undefined;
144
714
  const renamed = renamedArities.get(expression);
145
715
  if (renamed !== undefined) return renamed;
146
716
  if (isKey(name)) return expression.kind === "Apply" ? expression.args.length : 0;
147
- if (isStepName(name)) return 0;
717
+ if (checkReference(expression, scope, unit, false) || isStepName(name)) {
718
+ return expression.kind === "Apply" ? expression.args.length : 0;
719
+ }
148
720
  const local = lookupLocal(scope, name);
149
721
  if (local && expression.kind !== "OperatorReference") expression.resolution = LOCAL_RESOLUTION;
150
722
  if (local) return local.arity;
@@ -166,30 +738,31 @@ const getSymbolArity = (
166
738
  if (isSelected) {
167
739
  return expression.kind === "Apply" ? expression.args.length : 0;
168
740
  }
169
- const range = getNameRange(location, name === "-." ? "-" : name);
170
- if (!isOperatorSymbol(name)) throw createSemanticError(`Unknown operator: \`${name}'.`, range);
171
- const missing = {
172
- location: formatRange(range),
173
- message: `Could not find declaration or definition of symbol '${name}'.`,
174
- };
741
+ const spelling = (expression.kind === "Identifier" ? undefined : expression.spelling) ?? name;
742
+ const range = formatRange(getNameRange(location, spelling === "-." ? "-" : spelling));
743
+ if (!isOperatorSymbol(name)) {
744
+ unit.errors.push({ location: range, message: `Unknown operator: \`${name}'.` });
745
+ return undefined;
746
+ }
747
+ unit.errors.push({
748
+ location: range,
749
+ message: `Could not find declaration or definition of symbol '${spelling}'.`,
750
+ });
175
751
  const fixity = getFixity(expression);
176
- throw createSanyError(
177
- fixity && location.range
178
- ? [
179
- missing,
180
- {
181
- location: formatRange(location.range),
182
- message: `Couldn't resolve ${fixity} operator symbol \`${name}'.`,
183
- },
184
- ]
185
- : [missing],
186
- );
752
+ if (fixity && location.range) {
753
+ unit.errors.push({
754
+ location: formatRange(location.range),
755
+ message: `Couldn't resolve ${fixity} operator symbol \`${spelling}'.`,
756
+ });
757
+ }
758
+ return undefined;
187
759
  };
188
760
 
189
761
  const resolveBounds = (bounds: Bound[], scope: LocalName | undefined, unit: Unit) => {
190
762
  bounds.forEach((bound) => resolveExpression(bound.set, scope, unit));
191
763
  return bounds.reduce(
192
- (current, bound) => bindNames(current, getPatternNames(bound.pattern)),
764
+ (current, bound) =>
765
+ bindNames(current, getPatternNames(bound.pattern), bound.pattern.ranges, unit),
193
766
  scope,
194
767
  );
195
768
  };
@@ -205,94 +778,238 @@ const markRecursiveConstructions = (expression: Expression, name: string): void
205
778
  getChildren(expression).forEach((child) => markRecursiveConstructions(child, name));
206
779
  };
207
780
 
208
- const resolveDefinition = (definition: Definition, scope: LocalName | undefined, unit: Unit) => {
209
- const self = bindNames(scope, definition.kind === "Function" ? [definition.name] : []);
781
+ // Generator.processOperator binds the parameters, reports a name already bound unless a RECURSIVE
782
+ // declaration of this level awaits the definition, analyzes the body, and then binds the name.
783
+ // processFunction binds the bound names before it looks up the name, and binds the name only where
784
+ // nothing else does. recursive holds the declarations of this level. Tells whether to bind the name.
785
+ const resolveDefinition = (
786
+ definition: Definition,
787
+ scope: LocalName | undefined,
788
+ outer: Unit,
789
+ recursive: Set<Binding>,
790
+ ) => {
791
+ const unit = {
792
+ ...outer,
793
+ hasLabelScope: true,
794
+ labelParams: definition.kind === "Function" ? getBoundNames(definition.bounds) : [],
795
+ labels: new Set<string>(),
796
+ };
797
+ const name = definition.name;
798
+ const range = definition.location.range;
799
+ const report = (message: string) => {
800
+ if (range && !unit.isGenerated) unit.errors.push({ location: formatRange(range), message });
801
+ };
802
+ const inner =
803
+ definition.kind === "Function"
804
+ ? resolveBounds(definition.bounds, scope, unit)
805
+ : bindParams(scope, definition.params, unit);
806
+ const current = lookupLocal(inner, name) ?? getModuleBinding(name, unit, range);
807
+ const isDeclared = current?.isPending === true && recursive.has(current);
808
+ if (current?.isPending && !isDeclared) {
809
+ report(
810
+ `Recursive ${definition.kind === "Function" ? "function" : "operator"} ${name} defined at wrong LET/IN level.`,
811
+ );
812
+ } else if (current && !isDeclared) {
813
+ report(
814
+ definition.kind === "Function"
815
+ ? `Function name \`${name}' already defined or declared.`
816
+ : `Operator ${name} already defined or declared.`,
817
+ );
818
+ }
210
819
  if (definition.kind === "Function") {
211
- resolveExpression(definition.body, resolveBounds(definition.bounds, self, unit), unit);
212
- markRecursiveConstructions(definition.body, definition.name);
213
- return;
820
+ resolveExpression(
821
+ definition.body,
822
+ { name, kind: "Parameter", arity: 0, range, parent: inner },
823
+ unit,
824
+ );
825
+ markRecursiveConstructions(definition.body, name);
826
+ definition.isSelfReferential = isReferenced(definition.body, name);
827
+ } else resolveExpression(definition.body, inner, unit);
828
+ if (current && isDeclared) {
829
+ current.isPending = false;
830
+ current.range = range;
831
+ return false;
214
832
  }
215
- resolveExpression(definition.body, bindParams(self, definition.params), unit);
833
+ return definition.kind === "Function"
834
+ ? current === undefined
835
+ : isBindable(
836
+ name,
837
+ lookupLocal(scope, name) ?? getModuleBinding(name, unit, range),
838
+ { kind: "Definition", arity: getArity(definition), range },
839
+ unit,
840
+ );
216
841
  };
217
842
 
843
+ // SANY analyzes an INSTANCE in a LET where it appears, before the definitions that follow it, which
844
+ // tla-ts generates at its location and analyzes without reporting.
218
845
  const resolveDefinitions = (
219
846
  definitions: Definition[],
220
847
  scope: LocalName | undefined,
221
848
  unit: Unit,
849
+ instances: Instance[] = [],
222
850
  ) => {
223
- const recursiveScope = definitions
851
+ const recursive = new Set<Binding>();
852
+ const declared = definitions
224
853
  .filter((definition) => definition.isRecursive)
225
- .reduce<LocalName | undefined>(
226
- (parent, definition) => ({ name: definition.name, arity: getArity(definition), parent }),
227
- scope,
228
- );
229
- return definitions.reduce((current, definition) => {
230
- if (!isInstantiated(definition)) resolveDefinition(definition, current, unit);
231
- return { name: definition.name, arity: getArity(definition), parent: current };
232
- }, recursiveScope);
233
- };
234
-
235
- // OpDefNode#match: a parameter of arity 0 takes an expression, and a parameter of arity n takes an
236
- // operator of arity n whose own parameters take expressions.
237
- const checkArgument = (
238
- definition: Definition,
239
- index: number,
240
- arg: Expression,
241
- argArity: number,
242
- argDefinition: Definition | undefined,
243
- ) => {
244
- const param = definition.kind === "Operator" ? definition.params[index] : undefined;
245
- const location = arg.location;
246
- if (param?.arity === 0 && argArity > 0) {
247
- throw new TlaSyntaxError(
248
- `Operator used in argument number ${index + 1} has incorrect number of arguments at line ${location.line}, column ${location.column}`,
249
- );
250
- }
251
- const isHigherOrder =
252
- argDefinition?.kind === "Operator" && argDefinition.params.some((inner) => inner.arity > 0);
253
- if (param !== undefined && param.arity > 0 && (argArity !== param.arity || isHigherOrder)) {
254
- throw new TlaSyntaxError(
255
- `Argument number ${index + 1} to operator '${definition.name}' should be a ${param.arity}-parameter operator at line ${location.line}, column ${location.column}`,
256
- );
257
- }
854
+ .reduce<LocalName | undefined>((parent, definition) => {
855
+ if (lookupLocal(parent, definition.name)?.isPending) return parent;
856
+ const local: LocalName = {
857
+ name: definition.name,
858
+ arity: getArity(definition),
859
+ params: getParamArities(definition),
860
+ kind: "Definition",
861
+ parent,
862
+ isPending: true,
863
+ };
864
+ recursive.add(local);
865
+ return local;
866
+ }, scope);
867
+ const pending = unit.isGenerated ? [] : [...instances];
868
+ const resolveInstances = (
869
+ current: LocalName | undefined,
870
+ isDue: (instance: Instance) => boolean,
871
+ ) => {
872
+ const count = pending.findIndex((instance) => !isDue(instance));
873
+ return pending
874
+ .splice(0, count === -1 ? pending.length : count)
875
+ .reduce((parent, instance) => resolveInstance(instance, parent, unit), current);
876
+ };
877
+ const resolved = definitions.reduce<LocalName | undefined>((previous, definition) => {
878
+ const current = isKey(definition.name)
879
+ ? previous
880
+ : resolveInstances(previous, (instance) => !isBefore(definition.location, instance.location));
881
+ const local: LocalName = {
882
+ name: definition.name,
883
+ arity: getArity(definition),
884
+ kind: "Definition",
885
+ range: definition.location.range,
886
+ parent: current,
887
+ };
888
+ if (isInstantiated(definition)) return local;
889
+ const isInstanced = instances.some((instance) => instance.location === definition.location);
890
+ const isGenerated = unit.isGenerated || definition.isLocal || isKey(definition.name);
891
+ const inner = isInstanced
892
+ ? { ...unit, isGenerated: true, errors: [], warnings: [] }
893
+ : isGenerated
894
+ ? { ...unit, isGenerated }
895
+ : unit;
896
+ return resolveDefinition(definition, current, inner, recursive)
897
+ ? { ...local, params: getParamArities(definition) }
898
+ : current;
899
+ }, declared);
900
+ return resolveInstances(resolved, () => true);
258
901
  };
259
902
 
260
- const getArgumentName = (arg: Expression) =>
261
- arg.kind === "Identifier"
262
- ? arg.name
263
- : arg.kind === "OperatorReference"
264
- ? arg.operator
265
- : undefined;
266
-
903
+ // Generator.generateExprOrOpArg analyzes an argument as an expression, unless a defined operator
904
+ // takes an operator in its place, which a name, a built-in operator, or a LAMBDA of the parameter's
905
+ // arity must give. OpDefNode#match then reports each argument that gives no such operator, or one
906
+ // whose own parameters take operators. tla-ts lets an operator whose parameters it does not know
907
+ // take any argument.
267
908
  const resolveApply = (
268
909
  expression: Expression & { kind: "Apply" },
269
910
  scope: LocalName | undefined,
270
911
  unit: Unit,
271
912
  ) => {
272
913
  const operator = expression.operator;
273
- const callee = lookupLocal(scope, operator) ? undefined : getVisibleDefinition(operator, unit);
914
+ const callee = findBinding(operator, scope, unit);
274
915
  const arity = getSymbolArity(expression, operator, scope, unit);
916
+ if (arity === undefined) return;
275
917
  if (arity !== expression.args.length) {
276
- throw createSemanticError(
277
- `The operator ${operator} requires ${arity} arguments.`,
278
- expression.argumentsRange ?? getNameRange(expression.location, operator),
279
- );
918
+ unit.errors.push({
919
+ location: formatRange(
920
+ expression.argumentsRange ?? getNameRange(expression.location, operator),
921
+ ),
922
+ message: `The operator ${operator} requires ${arity} arguments.`,
923
+ });
924
+ return;
280
925
  }
281
- expression.args.forEach((arg, index) => {
282
- const name = getArgumentName(arg);
283
- const argDefinition =
284
- name === undefined || lookupLocal(scope, name) ? undefined : getVisibleDefinition(name, unit);
285
- const argArity = resolveArgument(arg, scope, unit);
286
- if (callee) checkArgument(callee, index, arg, argArity, argDefinition);
287
- });
926
+ const params = callee && (callee.kind === "Definition" ? callee.params : []);
927
+ if (params === undefined) {
928
+ expression.args.forEach((arg) => resolveArgument(arg, scope, unit));
929
+ return;
930
+ }
931
+ const report = (range: SourceRange | undefined, message: string) => {
932
+ if (range) unit.errors.push({ location: formatRange(range), message });
933
+ };
934
+ expression.args
935
+ .map((arg, index) => {
936
+ const expected = params[index] ?? 0;
937
+ // A prefix operator argument such as SUBSET, which tla-ts reads as a LAMBDA, has no range.
938
+ const range = arg.location.range;
939
+ if (expected === 0) {
940
+ if (arg.kind === "Lambda" && range) {
941
+ report(range, "LAMBDA expression used where an expression is required.");
942
+ } else if (arg.kind === "OperatorReference") {
943
+ // SANY fails here with an internal error, so tla-ts words it as it does for a name.
944
+ const argArity = getSymbolArity(arg, arg.operator, scope, unit);
945
+ if (argArity !== undefined) {
946
+ report(range, `The operator ${arg.operator} requires ${argArity} arguments.`);
947
+ }
948
+ } else resolveExpression(arg, scope, unit);
949
+ return true;
950
+ }
951
+ // A name that selects a subexpression gives an operator of the names it leaves unbound.
952
+ if (arg.kind === "Lambda") {
953
+ resolveExpression(arg, scope, unit);
954
+ const isMatched = arg.params.length === expected;
955
+ if (!isMatched && selections.has(arg)) {
956
+ report(
957
+ range,
958
+ `Expected arity ${expected} but found operator of arity ${arg.params.length}.`,
959
+ );
960
+ } else if (!isMatched && range) {
961
+ report(
962
+ expression.selectorRanges?.at(-1) ?? getNameRange(expression.location, operator),
963
+ `Lambda expression with arity ${arg.params.length} used as argument ${index + 1} of operator \`${operator}', \nbut an operator of arity ${expected} is required.`,
964
+ );
965
+ }
966
+ return isMatched;
967
+ }
968
+ if (arg.kind === "Subexpression") {
969
+ resolveExpression(arg, scope, unit);
970
+ return true;
971
+ }
972
+ if (arg.kind !== "Identifier" && arg.kind !== "OperatorReference") {
973
+ report(
974
+ range,
975
+ `An expression appears as argument number ${index + 1} (counting from 1) to operator '${operator}', in a position an operator is required.`,
976
+ );
977
+ return false;
978
+ }
979
+ const name = arg.kind === "Identifier" ? arg.name : arg.operator;
980
+ const argParams = findBinding(name, scope, unit)?.params ?? [];
981
+ const argArity = getSymbolArity(arg, name, scope, unit);
982
+ if (arg.kind === "Identifier" && argArity !== undefined && argArity !== expected) {
983
+ report(
984
+ getNameRange(arg.location, name),
985
+ `Expected arity ${expected} but found operator of arity ${argArity}.`,
986
+ );
987
+ }
988
+ return argArity === expected && argParams.every((param) => param === 0);
989
+ })
990
+ .forEach((isMatched, index) => {
991
+ if (!isMatched) {
992
+ report(
993
+ expression.location.range,
994
+ `Argument number ${index + 1} to operator '${operator}' \nshould be a ${params[index]}-parameter operator.`,
995
+ );
996
+ }
997
+ });
288
998
  };
289
999
 
290
1000
  // An argument may name an operator that takes arguments of its own.
291
1001
  const resolveArgument = (arg: Expression, scope: LocalName | undefined, unit: Unit) => {
292
- if (arg.kind === "Identifier") return getSymbolArity(arg, arg.name, scope, unit);
293
- if (arg.kind === "OperatorReference") return getSymbolArity(arg, arg.operator, scope, unit);
294
- resolveExpression(arg, scope, unit);
295
- return arg.kind === "Lambda" ? arg.params.length : 0;
1002
+ if (arg.kind === "Identifier") getSymbolArity(arg, arg.name, scope, unit);
1003
+ else resolveExpression(arg, scope, unit);
1004
+ };
1005
+
1006
+ // Reports the error of a name that selects nothing, after the arguments SANY analyzes before it.
1007
+ const isSelectionReported = (expression: Expression, scope: LocalName | undefined, unit: Unit) => {
1008
+ const failed = selectionErrors.get(expression);
1009
+ if (!failed) return false;
1010
+ failed.args.forEach((arg) => resolveArgument(arg, scope, unit));
1011
+ unit.errors.push(failed.error);
1012
+ return true;
296
1013
  };
297
1014
 
298
1015
  const resolveExpression = (
@@ -300,8 +1017,16 @@ const resolveExpression = (
300
1017
  scope: LocalName | undefined,
301
1018
  unit: Unit,
302
1019
  ): void => {
1020
+ if (selections.has(expression) && !unit.isGenerated) {
1021
+ resolveExpression(expression, scope, { ...unit, isGenerated: true });
1022
+ return;
1023
+ }
303
1024
  const resolveAll = (expressions: Expression[]) =>
304
1025
  expressions.forEach((child) => resolveExpression(child, scope, unit));
1026
+ const bindLabelParams = (names: string[]) => ({
1027
+ ...unit,
1028
+ labelParams: [...unit.labelParams, ...names],
1029
+ });
305
1030
  switch (expression.kind) {
306
1031
  case "Number":
307
1032
  case "Decimal":
@@ -311,11 +1036,11 @@ const resolveExpression = (
311
1036
  case "Identifier": {
312
1037
  const name = expression.name;
313
1038
  const arity = getSymbolArity(expression, name, scope, unit);
314
- if (arity > 0) {
315
- throw createSemanticError(
316
- `The operator ${name} requires ${arity} arguments.`,
317
- getNameRange(expression.location, name),
318
- );
1039
+ if (arity !== undefined && arity > 0) {
1040
+ unit.errors.push({
1041
+ location: formatRange(getNameRange(expression.location, name)),
1042
+ message: `The operator ${name} requires ${arity} arguments.`,
1043
+ });
319
1044
  }
320
1045
  return;
321
1046
  }
@@ -326,7 +1051,11 @@ const resolveExpression = (
326
1051
  resolveApply(expression, scope, unit);
327
1052
  return;
328
1053
  case "Lambda":
329
- resolveExpression(expression.body, bindNames(scope, expression.params), unit);
1054
+ resolveExpression(
1055
+ expression.body,
1056
+ bindNames(scope, expression.params, expression.paramRanges, unit),
1057
+ bindLabelParams(expression.params),
1058
+ );
330
1059
  return;
331
1060
  case "And":
332
1061
  case "Or":
@@ -349,24 +1078,32 @@ const resolveExpression = (
349
1078
  case "Let":
350
1079
  resolveExpression(
351
1080
  expression.body,
352
- resolveDefinitions(expression.definitions, scope, unit),
1081
+ resolveDefinitions(expression.definitions, scope, unit, expression.instances),
353
1082
  unit,
354
1083
  );
355
1084
  return;
356
1085
  case "Forall":
357
1086
  case "Exists":
358
1087
  case "FunctionConstruction":
359
- resolveExpression(expression.body, resolveBounds(expression.bounds, scope, unit), unit);
1088
+ resolveExpression(
1089
+ expression.body,
1090
+ resolveBounds(expression.bounds, scope, unit),
1091
+ bindLabelParams(getBoundNames(expression.bounds)),
1092
+ );
360
1093
  return;
361
1094
  case "UnboundedQuantifier":
362
- resolveExpression(expression.body, bindNames(scope, expression.names), unit);
1095
+ resolveExpression(
1096
+ expression.body,
1097
+ bindNames(scope, expression.names, expression.nameRanges, unit),
1098
+ bindLabelParams(expression.names),
1099
+ );
363
1100
  return;
364
1101
  case "Choose":
365
1102
  if (expression.set) resolveExpression(expression.set, scope, unit);
366
1103
  resolveExpression(
367
1104
  expression.body,
368
- bindNames(scope, getPatternNames(expression.pattern)),
369
- unit,
1105
+ bindNames(scope, getPatternNames(expression.pattern), expression.pattern.ranges, unit),
1106
+ bindLabelParams(getPatternNames(expression.pattern)),
370
1107
  );
371
1108
  return;
372
1109
  case "SetEnumeration":
@@ -374,38 +1111,40 @@ const resolveExpression = (
374
1111
  resolveAll(expression.elements);
375
1112
  return;
376
1113
  case "SetFilter":
377
- resolveExpression(expression.predicate, resolveBounds([expression.bound], scope, unit), unit);
1114
+ resolveExpression(
1115
+ expression.predicate,
1116
+ resolveBounds([expression.bound], scope, unit),
1117
+ bindLabelParams(getPatternNames(expression.bound.pattern)),
1118
+ );
378
1119
  return;
379
1120
  case "SetMap":
380
- resolveExpression(expression.expression, resolveBounds(expression.bounds, scope, unit), unit);
1121
+ resolveExpression(
1122
+ expression.expression,
1123
+ resolveBounds(expression.bounds, scope, unit),
1124
+ bindLabelParams(getBoundNames(expression.bounds)),
1125
+ );
381
1126
  return;
382
1127
  case "FunctionSet":
383
1128
  resolveAll([expression.domain, expression.range]);
384
1129
  return;
385
1130
  case "Record":
386
- case "RecordSet": {
387
- const repeated = expression.fields.filter((field, index) =>
388
- expression.fields.slice(0, index).some((earlier) => earlier.name === field.name),
389
- );
390
- if (repeated.length > 0) {
391
- throw createSanyError(
392
- repeated.map((field) => ({
1131
+ case "RecordSet":
1132
+ expression.fields.forEach((field, index) => {
1133
+ if (expression.fields.slice(0, index).some((earlier) => earlier.name === field.name)) {
1134
+ unit.errors.push({
393
1135
  location: formatRange(field.location.range ?? getNameRange(field.location, field.name)),
394
1136
  message: "Non-unique fields in constructor.",
395
- })),
396
- );
397
- }
398
- resolveAll(expression.fields.map((field) => field.value));
1137
+ });
1138
+ }
1139
+ resolveExpression(field.value, scope, unit);
1140
+ });
399
1141
  return;
400
- }
401
1142
  case "Except":
402
- resolveAll([
403
- expression.function,
404
- ...expression.updates.flatMap((update) => [
405
- ...update.path.flatMap((step) => (step.kind === "Index" ? step.args : [])),
406
- update.value,
407
- ]),
408
- ]);
1143
+ resolveExpression(expression.function, scope, unit);
1144
+ expression.updates.forEach((update) => {
1145
+ resolveAll(update.path.flatMap((step) => (step.kind === "Index" ? step.args : [])));
1146
+ resolveExpression(update.value, scope, { ...unit, isInExcept: true });
1147
+ });
409
1148
  return;
410
1149
  case "FunctionApplication":
411
1150
  resolveAll([expression.function, ...expression.args]);
@@ -425,34 +1164,66 @@ const resolveExpression = (
425
1164
  resolveAll([expression.subscript, expression.action]);
426
1165
  return;
427
1166
  case "Label":
428
- resolveExpression(expression.body, scope, unit);
1167
+ if (isLabelReported(expression, unit)) return;
1168
+ resolveExpression(expression.body, scope, { ...unit, labelParams: [], labels: new Set() });
1169
+ checkLabel(expression, scope, unit);
429
1170
  return;
430
- case "Subexpression":
1171
+ case "Subexpression": {
1172
+ if (isSelectionReported(expression, scope, unit)) return;
431
1173
  expression.selectors
432
1174
  .flatMap((selector) => ("args" in selector ? selector.args : []))
433
1175
  .forEach((arg) => resolveArgument(arg, scope, unit));
1176
+ checkReference(expression, scope, unit, false);
1177
+ }
434
1178
  }
435
1179
  };
436
1180
 
1181
+ // Generator.generateUseOrHide looks up a fact that is a name as it looks up a name in an expression,
1182
+ // except that the name may select an ASSUME/PROVE or a NEW clause or name a theorem or assumption,
1183
+ // and analyzes any other fact as an expression.
1184
+ const checkFacts = (facts: Fact[], scope: LocalName | undefined, unit: Unit) =>
1185
+ facts.forEach((fact) => {
1186
+ if (fact.kind === "ModuleFact" || checkReference(fact, scope, unit, true)) return;
1187
+ const name =
1188
+ fact.kind === "Identifier" ? fact.name : fact.kind === "Apply" ? fact.operator : "";
1189
+ if (!unit.facts.has(name)) resolveExpression(fact, scope, unit);
1190
+ });
1191
+
437
1192
  const resolveNewSymbol = (symbol: NewSymbol, scope: LocalName | undefined, unit: Unit) => {
438
1193
  if (symbol.set) resolveExpression(symbol.set, scope, unit);
439
- return { name: symbol.name, arity: symbol.arity, parent: scope };
1194
+ return bindName(
1195
+ scope,
1196
+ symbol.name,
1197
+ { kind: `New${symbol.level}`, arity: symbol.arity, range: symbol.nameRange },
1198
+ unit,
1199
+ );
440
1200
  };
441
1201
 
442
- // The NEW symbols of an ASSUME stay in scope for its conclusion and the proof that follows.
1202
+ // The NEW symbols of an ASSUME stay in scope for its conclusion and the proof that follows. SANY
1203
+ // forbids a label in the scope of a NEW in a nested ASSUME.
443
1204
  const resolveAssumeProve = (
444
1205
  assumeProve: AssumeProve,
445
1206
  scope: LocalName | undefined,
446
1207
  unit: Unit,
1208
+ isNested = false,
447
1209
  ): LocalName | undefined => {
448
- const assumed = assumeProve.assumptions.reduce((current, assumption) => {
449
- if (assumption.kind === "NewSymbol") return resolveNewSymbol(assumption, current, unit);
450
- if (assumption.kind === "AssumeProve") resolveAssumeProve(assumption, current, unit);
451
- else resolveExpression(assumption, current, unit);
452
- return current;
453
- }, scope);
454
- resolveExpression(assumeProve.conclusion, assumed, unit);
455
- return assumed;
1210
+ const assumed = assumeProve.assumptions.reduce(
1211
+ (current, assumption) => {
1212
+ if (assumption.kind === "NewSymbol") {
1213
+ return {
1214
+ scope: resolveNewSymbol(assumption, current.scope, current.unit),
1215
+ unit: isNested ? { ...current.unit, isLabelForbidden: true } : current.unit,
1216
+ };
1217
+ }
1218
+ if (assumption.kind === "AssumeProve") {
1219
+ resolveAssumeProve(assumption, current.scope, current.unit, true);
1220
+ } else resolveExpression(assumption, current.scope, current.unit);
1221
+ return current;
1222
+ },
1223
+ { scope, unit },
1224
+ );
1225
+ resolveExpression(assumeProve.conclusion, assumed.scope, assumed.unit);
1226
+ return assumed.scope;
456
1227
  };
457
1228
 
458
1229
  const resolveStatement = (
@@ -467,44 +1238,92 @@ const resolveStatement = (
467
1238
 
468
1239
  // SANY resolves the expressions of a proof, while its facts and DEF clauses may also name
469
1240
  // theorems, assumptions, and modules.
470
- const resolveProof = (proof: Proof | undefined, scope: LocalName | undefined, unit: Unit) => {
1241
+ const resolveProof = (proof: Proof | undefined, scope: LocalName | undefined, outer: Unit) => {
1242
+ const unit = outer.hasLabelScope ? { ...outer, hasLabelScope: false } : outer;
1243
+ if (proof?.kind === "By") checkFacts(proof.facts, scope, unit);
471
1244
  if (proof?.kind !== "Steps") return;
472
1245
  proof.steps.reduce((current, step) => resolveStep(step, current, unit), scope);
473
1246
  };
474
1247
 
1248
+ // A step binds the name of the INSTANCE after the names it adds.
1249
+ const resolveStepInstance = (instance: Instance, scope: LocalName | undefined, unit: Unit) => {
1250
+ const instanced = resolveInstance(instance, scope, unit);
1251
+ return instance.name === undefined
1252
+ ? instanced
1253
+ : bindName(
1254
+ instanced,
1255
+ instance.name,
1256
+ { kind: "Instance", arity: instance.params.length, range: instance.location.range },
1257
+ unit,
1258
+ );
1259
+ };
1260
+
475
1261
  const resolveStep = (
476
1262
  step: ProofStep,
477
1263
  scope: LocalName | undefined,
478
1264
  unit: Unit,
479
1265
  ): LocalName | undefined => {
480
1266
  const body = step.body;
1267
+ const stepUnit =
1268
+ step.name === undefined
1269
+ ? unit
1270
+ : { ...unit, hasLabelScope: true, labelParams: [], labels: new Set<string>() };
481
1271
  switch (body.kind) {
1272
+ // The NEW symbols of a SUFFICES ASSUME are in scope after its proof, and those of any other
1273
+ // ASSUME in its proof.
482
1274
  case "Assert": {
483
- const assumed = resolveStatement(body.statement, scope, unit);
484
- resolveProof(step.proof, assumed, unit);
485
- return body.isSuffices ? assumed : scope;
1275
+ const assumed = resolveStatement(body.statement, scope, stepUnit);
1276
+ const proofScope = body.isSuffices ? scope : assumed;
1277
+ const name = step.name;
1278
+ if (name === undefined) {
1279
+ resolveProof(step.proof, proofScope, unit);
1280
+ return body.isSuffices ? assumed : scope;
1281
+ }
1282
+ const goal = { statement: body.statement, isSuffices: body.isSuffices, isInProof: true };
1283
+ resolveProof(step.proof, { name, arity: 0, kind: "Theorem", parent: proofScope, goal }, unit);
1284
+ goal.isInProof = false;
1285
+ return { name, arity: 0, kind: "Theorem", parent: body.isSuffices ? assumed : scope, goal };
486
1286
  }
1287
+ case "Use":
1288
+ case "Hide":
1289
+ checkFacts(body.facts, scope, unit);
1290
+ return scope;
1291
+ case "Instance":
1292
+ return resolveStepInstance(body, scope, stepUnit);
487
1293
  case "Define":
488
- return resolveDefinitions(
489
- body.definitions.flatMap((definition) =>
490
- definition.kind === "Instance" ? [] : [definition],
491
- ),
1294
+ return body.definitions.reduce(
1295
+ (current, definition) =>
1296
+ definition.kind === "Instance"
1297
+ ? resolveStepInstance(definition, current, stepUnit)
1298
+ : resolveDefinitions([definition], current, unit),
492
1299
  scope,
493
- unit,
494
1300
  );
495
1301
  case "Have":
496
1302
  case "Case":
497
- resolveExpression(body.expression, scope, unit);
1303
+ resolveExpression(body.expression, scope, stepUnit);
498
1304
  resolveProof(step.proof, scope, unit);
499
1305
  return scope;
500
1306
  case "Witness":
501
- body.expressions.forEach((expression) => resolveExpression(expression, scope, unit));
1307
+ body.expressions.forEach((expression) => resolveExpression(expression, scope, stepUnit));
502
1308
  return scope;
503
1309
  case "Take":
504
- return bindNames(resolveBounds(body.bounds, scope, unit), body.names);
1310
+ return bindNames(
1311
+ resolveBounds(body.bounds, scope, stepUnit),
1312
+ body.names,
1313
+ body.nameRanges,
1314
+ stepUnit,
1315
+ );
505
1316
  case "Pick": {
506
- const picked = bindNames(resolveBounds(body.bounds, scope, unit), body.names);
507
- resolveExpression(body.body, picked, unit);
1317
+ const picked = bindNames(
1318
+ resolveBounds(body.bounds, scope, stepUnit),
1319
+ body.names,
1320
+ body.nameRanges,
1321
+ stepUnit,
1322
+ );
1323
+ resolveExpression(body.body, picked, {
1324
+ ...stepUnit,
1325
+ labelParams: [...stepUnit.labelParams, ...getBoundNames(body.bounds), ...body.names],
1326
+ });
508
1327
  resolveProof(step.proof, scope, unit);
509
1328
  return picked;
510
1329
  }
@@ -514,358 +1333,421 @@ const resolveStep = (
514
1333
  }
515
1334
  };
516
1335
 
1336
+ // SANY binds the name of a theorem after its statement and before its proof.
517
1337
  const resolveTheorem = (theorem: Theorem, unit: Unit) => {
518
1338
  const isDefinition = theorem.name !== undefined && theorem.statement.kind !== "AssumeProve";
519
1339
  const scope = isDefinition ? undefined : resolveStatement(theorem.statement, undefined, unit);
1340
+ if (theorem.name !== undefined) {
1341
+ bindModuleName(
1342
+ theorem.name,
1343
+ { kind: "Theorem", arity: 0, range: theorem.location.range },
1344
+ unit,
1345
+ );
1346
+ }
1347
+ const goal = unit.goals.get(theorem.name ?? "");
1348
+ if (goal) goal.isInProof = true;
520
1349
  resolveProof(theorem.proof, scope, unit);
1350
+ if (goal) goal.isInProof = false;
521
1351
  };
522
1352
 
523
- interface ModuleUnit {
524
- imported: Symbols;
525
- importedAt: Map<string, SourceLocation>;
526
- definitions: Map<string, Definition>;
527
- getKey: (definition: Definition) => string;
1353
+ // The declarations of the module an INSTANCE instantiates, the names the INSTANCE adds, and the
1354
+ // module that instantiates it.
1355
+ export interface InstancedModule {
1356
+ declarations: Declaration[];
1357
+ symbols: Symbols;
1358
+ instancer: string;
528
1359
  }
529
1360
 
530
- interface ModuleName {
531
- name: string;
532
- kind: "Definition" | "Constant" | "Variable";
1361
+ // What SANY reports at a location as it links a module, such as a conflict between the modules it
1362
+ // extends.
1363
+ export interface ModuleReport {
533
1364
  location: SourceLocation;
534
- isRecursive: boolean;
1365
+ errors: SanyError[];
1366
+ warnings: SanyError[];
535
1367
  }
536
1368
 
537
- type IsDefined = (name: string) => boolean;
1369
+ // bound holds the names in scope where the module starts: the built-in operators, the names of the
1370
+ // module that encloses it, and those of the modules it extends. instanced holds the names each
1371
+ // INSTANCE adds, getInstance what an INSTANCE in a LET or a proof instantiates, facts the theorems
1372
+ // and assumptions the modules it extends or instantiates export, and warnings the warnings SANY
1373
+ // reports for the spec.
1374
+ export interface ModuleUnit {
1375
+ imported: Symbols;
1376
+ getInstance: (instance: Instance) => InstancedModule;
1377
+ bound: Symbols;
1378
+ definitions: Map<string, Definition>;
1379
+ getKey: (definition: Definition) => string;
1380
+ instanced: Map<Instance, Symbols>;
1381
+ facts: Set<string>;
1382
+ reports: ModuleReport[];
1383
+ warnings: SanyError[];
1384
+ }
538
1385
 
539
- const createRedefinitionError = (name: string, location: SourceLocation) =>
540
- new TlaSyntaxError(
541
- `Multiply-defined symbol '${name}' at line ${location.line}, column ${location.column}`,
542
- );
1386
+ export const MODULE_START: SourceLocation = { line: 0, column: 0 };
543
1387
 
544
- const bindUnique = (
545
- scope: LocalName | undefined,
546
- names: string[],
547
- isDefined: IsDefined,
548
- location: SourceLocation,
549
- ) =>
550
- names.reduce<LocalName | undefined>((parent, name) => {
551
- if (lookupLocal(parent, name) || isDefined(name)) throw createRedefinitionError(name, location);
552
- return { name, arity: 0, parent };
553
- }, scope);
1388
+ // A named theorem or assumption is linked as a definition too.
1389
+ export const isTheoremDefinition = (module: Module, definition: Definition) =>
1390
+ [...module.theorems, ...module.assumptions].some(
1391
+ (item) =>
1392
+ item.name === definition.name &&
1393
+ item.location.line === definition.location.line &&
1394
+ item.location.column === definition.location.column,
1395
+ );
554
1396
 
555
- const checkBoundNames = (
556
- bounds: Bound[],
557
- scope: LocalName | undefined,
558
- isDefined: IsDefined,
559
- location: SourceLocation,
560
- ) => {
561
- bounds.forEach((bound) => checkNames(bound.set, scope, isDefined));
562
- return bounds.reduce(
563
- (current, bound) => bindUnique(current, getPatternNames(bound.pattern), isDefined, location),
564
- scope,
1397
+ const createSymbols = (module: Module, imported: Symbols) => {
1398
+ const symbols = new Map([...CORE_SYMBOLS, ...imported]);
1399
+ module.constants.forEach((constant) =>
1400
+ symbols.set(constant.name, { key: constant.name, arity: constant.arity, kind: "Constant" }),
1401
+ );
1402
+ module.variables.forEach((variable) =>
1403
+ symbols.set(variable.name, { key: variable.name, arity: 0, kind: "Variable" }),
565
1404
  );
1405
+ return symbols;
566
1406
  };
567
1407
 
568
- const checkDefinitionNames = (
569
- definition: Definition,
570
- scope: LocalName | undefined,
571
- isDefined: IsDefined,
1408
+ // Generator.processSubst analyzes the explicit substitutions in the order they appear, then the
1409
+ // implicit ones, and then reports each declaration left without one. The parameters of the INSTANCE
1410
+ // are in scope.
1411
+ const checkSubstitutions = (
1412
+ instance: Instance,
1413
+ declarations: Declaration[],
1414
+ instancer: string,
1415
+ outer: LocalName | undefined,
1416
+ unit: Unit,
572
1417
  ) => {
573
- if (definition.kind === "Function") {
574
- const self = bindNames(scope, [definition.name]);
575
- const bound = checkBoundNames(definition.bounds, self, isDefined, definition.location);
576
- checkNames(definition.body, bound, isDefined);
577
- return;
578
- }
579
- const params = bindUnique(
580
- scope,
581
- definition.params.map((param) => param.name),
582
- isDefined,
583
- definition.location,
1418
+ const scope = instance.params.reduce<LocalName | undefined>(
1419
+ (parent, param) => ({ name: param.name, arity: param.arity, kind: "Parameter", parent }),
1420
+ outer,
584
1421
  );
585
- checkNames(definition.body, params, isDefined);
586
- };
587
-
588
- const checkNames = (
589
- expression: Expression,
590
- scope: LocalName | undefined,
591
- isDefined: IsDefined,
592
- ): void => {
593
- const location = expression.location;
594
- switch (expression.kind) {
595
- case "Lambda":
596
- checkNames(
597
- expression.body,
598
- bindUnique(scope, expression.params, isDefined, location),
599
- isDefined,
600
- );
601
- return;
602
- case "Let": {
603
- const recursive = expression.definitions
604
- .filter((definition) => definition.isRecursive)
605
- .map((definition) => definition.name);
606
- const inner = expression.definitions.reduce((current, definition) => {
607
- if (lookupLocal(current, definition.name) || isDefined(definition.name)) {
608
- throw createRedefinitionError(definition.name, definition.location);
609
- }
610
- checkDefinitionNames(definition, bindNames(current, recursive), isDefined);
611
- return bindNames(current, [definition.name]);
612
- }, scope);
613
- checkNames(
614
- expression.body,
615
- bindUnique(
616
- inner,
617
- (expression.instances ?? []).flatMap((instance) =>
618
- instance.name === undefined ? [] : [instance.name],
619
- ),
620
- isDefined,
621
- location,
622
- ),
623
- isDefined,
624
- );
1422
+ const resolveSubstitute = (declaration: Declaration, expression: Expression) => {
1423
+ if (declaration.arity === 0 || expression.kind !== "Identifier") {
1424
+ resolveExpression(expression, scope, unit);
625
1425
  return;
626
1426
  }
627
- case "Forall":
628
- case "Exists":
629
- case "FunctionConstruction":
630
- checkNames(
631
- expression.body,
632
- checkBoundNames(expression.bounds, scope, isDefined, location),
633
- isDefined,
634
- );
635
- return;
636
- case "SetFilter":
637
- checkNames(
638
- expression.predicate,
639
- checkBoundNames([expression.bound], scope, isDefined, location),
640
- isDefined,
641
- );
642
- return;
643
- case "SetMap":
644
- checkNames(
645
- expression.expression,
646
- checkBoundNames(expression.bounds, scope, isDefined, location),
647
- isDefined,
648
- );
649
- return;
650
- case "UnboundedQuantifier":
651
- checkNames(
652
- expression.body,
653
- bindUnique(scope, expression.names, isDefined, location),
654
- isDefined,
655
- );
656
- return;
657
- case "Choose":
658
- if (expression.set) checkNames(expression.set, scope, isDefined);
659
- checkNames(
660
- expression.body,
661
- bindUnique(scope, getPatternNames(expression.pattern), isDefined, location),
662
- isDefined,
1427
+ const arity = getSymbolArity(expression, expression.name, scope, unit);
1428
+ if (arity !== undefined && arity !== declaration.arity) {
1429
+ throw new TlaSyntaxError(
1430
+ `An operator must be substituted for symbol '${declaration.name}', and it must have arity ${declaration.arity} in the instance of ${instance.module} at line ${instance.location.line}, column ${instance.location.column}`,
663
1431
  );
664
- return;
665
- default:
666
- getChildren(expression).forEach((child) => checkNames(child, scope, isDefined));
667
- }
668
- };
669
-
670
- const getModuleNames = (module: Module) => [
671
- ...module.definitions.map((definition): ModuleName => ({
672
- name: definition.name,
673
- kind: "Definition",
674
- location: definition.location,
675
- isRecursive: definition.isRecursive,
676
- })),
677
- ...module.instances.flatMap((instance): ModuleName[] =>
678
- instance.name === undefined
679
- ? []
680
- : [
681
- {
682
- name: instance.name,
683
- kind: "Definition",
684
- location: instance.location,
685
- isRecursive: false,
686
- },
687
- ],
688
- ),
689
- ...module.constants.map((constant): ModuleName => ({
690
- name: constant.name,
691
- kind: "Constant",
692
- location: constant.location,
693
- isRecursive: false,
694
- })),
695
- ...module.variables.map((variable): ModuleName => ({
696
- name: variable.name,
697
- kind: "Variable",
698
- location: variable.location,
699
- isRecursive: false,
700
- })),
701
- ];
702
-
703
- export const checkRedefinitions = (module: Module, unit: ModuleUnit) => {
704
- const byName = new Map<string, ModuleName[]>();
705
- getModuleNames(module)
706
- .sort((left, right) => (isBefore(left.location, right.location) ? -1 : 1))
707
- .forEach((entry) => byName.set(entry.name, [...(byName.get(entry.name) ?? []), entry]));
708
- const isImportedBefore = (name: string, location: SourceLocation) => {
709
- if (!unit.imported.has(name) && !CORE_SYMBOLS.has(name)) return false;
710
- const importedAt = unit.importedAt.get(name);
711
- return importedAt === undefined || isBefore(importedAt, location);
1432
+ }
712
1433
  };
713
- byName.forEach((entries) =>
714
- entries.forEach((entry, index) => {
715
- const isDuplicate = entries
716
- .slice(0, index)
717
- .some(
718
- (earlier) =>
719
- earlier.kind === "Definition" ||
720
- entry.kind === "Definition" ||
721
- earlier.kind !== entry.kind,
722
- );
723
- // A module may declare again a constant or variable that it extends or that encloses it.
724
- const isRedeclared = unit.imported.get(entry.name)?.declaration === entry.kind;
725
- if (isDuplicate || (!isRedeclared && isImportedBefore(entry.name, entry.location)))
726
- throw createRedefinitionError(entry.name, entry.location);
727
- }),
728
- );
729
- const getIsDefined =
730
- (location: SourceLocation): IsDefined =>
731
- (name) =>
732
- (byName.get(name) ?? []).some(
733
- (entry) => entry.isRecursive || isBefore(entry.location, location),
734
- ) || isImportedBefore(name, location);
735
- module.definitions.forEach((definition) =>
736
- checkDefinitionNames(definition, undefined, getIsDefined(definition.location)),
737
- );
738
- module.assumptions.forEach((assumption) =>
739
- checkNames(assumption.expression, undefined, getIsDefined(assumption.location)),
740
- );
741
- module.instances.forEach((instance) => {
742
- const isDefined = getIsDefined(instance.location);
743
- const params = bindUnique(
744
- undefined,
745
- instance.params.map((param) => param.name),
746
- isDefined,
747
- instance.location,
748
- );
749
- instance.substitutions.forEach((substitution) =>
750
- checkNames(substitution.expression, params, isDefined),
751
- );
1434
+ const substitutions = new Map<string, Expression>();
1435
+ instance.substitutions.forEach((substitution) => {
1436
+ const name = substitution.name;
1437
+ const declaration = declarations.find((item) => item.name === name);
1438
+ if (!declaration) {
1439
+ unit.errors.push({
1440
+ location: formatRange(substitution.nameRange),
1441
+ message: `Identifier '${name}' is not a legal target of a substitution. \nA legal target must be a declared CONSTANT or VARIABLE in the module being instantiated. \n(Also, check for warnings about multiple declarations of this same identifier.)`,
1442
+ });
1443
+ return;
1444
+ }
1445
+ const expression = substitution.expression;
1446
+ resolveSubstitute(declaration, expression);
1447
+ const range = expression.location.range;
1448
+ if (!substitutions.has(name)) substitutions.set(name, expression);
1449
+ else if (range) {
1450
+ unit.errors.push({
1451
+ location: formatRange(range),
1452
+ message: `Multiple substitutions for symbol '${name}' in substitution.`,
1453
+ });
1454
+ }
1455
+ });
1456
+ const implicit = declarations.filter((declaration) => !substitutions.has(declaration.name));
1457
+ const isMissing = (declaration: Declaration) =>
1458
+ !lookupLocal(scope, declaration.name) && !findSymbol(declaration.name, unit);
1459
+ implicit
1460
+ .filter((declaration) => !isMissing(declaration))
1461
+ .forEach((declaration) => {
1462
+ const expression: Expression = {
1463
+ kind: "Identifier",
1464
+ name: declaration.name,
1465
+ location: instance.location,
1466
+ };
1467
+ resolveSubstitute(declaration, expression);
1468
+ substitutions.set(declaration.name, expression);
1469
+ });
1470
+ implicit.filter(isMissing).forEach((declaration) => {
1471
+ const range = instance.location.range;
1472
+ const declared = declaration.location.range;
1473
+ if (range && declared) {
1474
+ unit.errors.push({
1475
+ location: formatRange(range),
1476
+ message: `Substitution missing for symbol ${declaration.name} declared at ${formatRange(declared)} \nand instantiated in module ${instancer}.`,
1477
+ });
1478
+ }
752
1479
  });
1480
+ return substitutions;
753
1481
  };
754
1482
 
755
- const createSymbols = (module: Module, imported: Symbols) => {
756
- const symbols = new Map([...CORE_SYMBOLS, ...imported]);
757
- module.constants.forEach((constant) =>
758
- symbols.set(constant.name, { key: constant.name, arity: constant.arity }),
759
- );
760
- module.variables.forEach((variable) =>
761
- symbols.set(variable.name, { key: variable.name, arity: 0 }),
1483
+ // Generator.processSubst analyzes an INSTANCE in a LET or a proof, which then binds the names the
1484
+ // INSTANCE adds.
1485
+ const resolveInstance = (instance: Instance, scope: LocalName | undefined, unit: Unit) => {
1486
+ const instanced = unit.getInstance(instance);
1487
+ checkSubstitutions(instance, instanced.declarations, instanced.instancer, scope, unit);
1488
+ return [...instanced.symbols].reduce(
1489
+ (parent, [name, symbol]) => bindName(parent, name, symbol, unit),
1490
+ scope,
762
1491
  );
763
- return symbols;
764
1492
  };
765
1493
 
1494
+ // tla-ts reports what SANY goes on after with an INSTANCE of the module.
766
1495
  export const resolveSubstitutions = (
767
1496
  instance: Instance,
768
- declarations: OperatorParam[],
1497
+ declarations: Declaration[],
769
1498
  module: Module,
770
1499
  unit: ModuleUnit,
771
1500
  ) => {
772
- const scope = bindParams(undefined, instance.params);
773
- const context: Unit = {
774
- imported: createSymbols(module, unit.imported),
1501
+ const imported = createSymbols(module, unit.imported);
1502
+ const report: ModuleReport = { location: instance.location, errors: [], warnings: [] };
1503
+ unit.reports.push(report);
1504
+ return checkSubstitutions(instance, declarations, module.name, undefined, {
1505
+ imported,
1506
+ getInstance: unit.getInstance,
775
1507
  definitions: unit.definitions,
776
1508
  getKey: unit.getKey,
777
1509
  location: instance.location,
778
1510
  self: undefined,
779
1511
  facts: new Set(),
780
- };
781
- const explicit = new Map(instance.substitutions.map((item) => [item.name, item.expression]));
782
- const position = `in the instance of ${instance.module} at line ${instance.location.line}, column ${instance.location.column}`;
783
- explicit.forEach((_, name) => {
784
- if (declarations.every((declaration) => declaration.name !== name)) {
785
- throw new TlaSyntaxError(
786
- `Identifier '${name}' is not a legal target of a substitution ${position}`,
787
- );
788
- }
1512
+ goals: new Map(),
1513
+ bindings: new Map(
1514
+ [...imported].map(([name, symbol]) => [name, { ...symbol, position: MODULE_START }]),
1515
+ ),
1516
+ errors: report.errors,
1517
+ warnings: report.warnings,
1518
+ hasLabelScope: false,
1519
+ isLabelForbidden: false,
1520
+ isInExcept: false,
1521
+ labelParams: [],
1522
+ labels: new Set(),
1523
+ isGenerated: false,
789
1524
  });
790
- return new Map(
791
- declarations.map((declaration): [string, Expression] => {
792
- const name = declaration.name;
793
- if (!explicit.has(name) && !lookupLocal(scope, name) && !findSymbol(name, context)) {
794
- throw new TlaSyntaxError(`Substitution missing for symbol ${name} ${position}`);
795
- }
796
- const expression: Expression = explicit.get(name) ?? {
797
- kind: "Identifier",
798
- name,
799
- location: instance.location,
800
- };
801
- if (declaration.arity === 0 || expression.kind !== "Identifier") {
802
- resolveExpression(expression, scope, context);
803
- return [name, expression];
804
- }
805
- if (getSymbolArity(expression, expression.name, scope, context) !== declaration.arity) {
806
- throw new TlaSyntaxError(
807
- `An operator must be substituted for symbol '${name}', and it must have arity ${declaration.arity} ${position}`,
808
- );
809
- }
810
- return [name, expression];
811
- }),
812
- );
813
1525
  };
814
1526
 
815
- // SANY reports the errors of every unit it checks, in the order of the units in the module.
816
- export const collectSemanticErrors = (units: { location: SourceLocation; check: () => void }[]) => {
1527
+ // SANY reports the errors of every unit it checks, in the order of the units in the module, after
1528
+ // the warnings it reports for the spec. A unit reports to its lists what SANY goes on after, and
1529
+ // throws the error that stops it. An error tla-ts cannot word as SANY does yields to the errors the
1530
+ // unit reported before it. Returns the errors.
1531
+ export const collectSemanticErrors = (
1532
+ units: {
1533
+ location: SourceLocation;
1534
+ check: (reported: SanyError[], warned: SanyError[]) => void;
1535
+ }[],
1536
+ warnings: SanyError[],
1537
+ ) => {
817
1538
  const errors: SanyError[] = [];
1539
+ const add = (list: SanyError[], item: SanyError) => {
1540
+ if (
1541
+ list.every(
1542
+ (existing) => existing.location !== item.location || existing.message !== item.message,
1543
+ )
1544
+ ) {
1545
+ list.push(item);
1546
+ }
1547
+ };
818
1548
  units
819
- .toSorted((left, right) => (isBefore(left.location, right.location) ? -1 : 1))
1549
+ .toSorted((left, right) =>
1550
+ isBefore(left.location, right.location)
1551
+ ? -1
1552
+ : isBefore(right.location, left.location)
1553
+ ? 1
1554
+ : 0,
1555
+ )
820
1556
  .forEach((unit) => {
1557
+ const reported: SanyError[] = [];
1558
+ const warned: SanyError[] = [];
821
1559
  try {
822
- unit.check();
1560
+ unit.check(reported, warned);
823
1561
  } catch (error) {
824
- if (!(error instanceof TlaSyntaxError) || !error.sany) throw error;
825
- error.sany.errors
826
- .filter((item) =>
827
- errors.every(
828
- (existing) =>
829
- existing.location !== item.location || existing.message !== item.message,
830
- ),
831
- )
832
- .forEach((item) => errors.push(item));
1562
+ if (!(error instanceof TlaSyntaxError) || (!error.sany && reported.length === 0)) {
1563
+ throw error;
1564
+ }
1565
+ reported.push(...(error.sany?.errors ?? []));
833
1566
  }
1567
+ reported.forEach((item) => add(errors, item));
1568
+ warned.forEach((item) => add(warnings, item));
834
1569
  });
835
- if (errors.length > 0) throw createSanyError(errors);
1570
+ return errors;
836
1571
  };
837
1572
 
1573
+ // SANY binds the names of a module in the order of its units, and reports a RECURSIVE declaration
1574
+ // that no definition follows at the end. Returns the errors.
838
1575
  export const resolveModule = (module: Module, unit: ModuleUnit) => {
839
1576
  const symbols = createSymbols(module, unit.imported);
840
- const facts = new Set(
841
- [...module.theorems, ...module.assumptions].flatMap((fact) => fact.name ?? []),
1577
+ const facts = new Set([
1578
+ ...unit.facts,
1579
+ ...[...module.theorems, ...module.assumptions].flatMap((fact) => fact.name ?? []),
1580
+ ]);
1581
+ const goals = new Map(
1582
+ module.theorems.flatMap((theorem): [string, Goal][] =>
1583
+ theorem.name !== undefined && theorem.statement.kind === "AssumeProve"
1584
+ ? [[theorem.name, { statement: theorem.statement, isSuffices: false, isInProof: false }]]
1585
+ : [],
1586
+ ),
1587
+ );
1588
+ const bindings = new Map<string, ModuleBinding>(
1589
+ [...CORE_SYMBOLS, ...unit.bound].map(([name, symbol]) => [
1590
+ name,
1591
+ { ...symbol, position: MODULE_START },
1592
+ ]),
842
1593
  );
843
- const createUnit = (location: SourceLocation, self: Definition | undefined) => ({
1594
+ const recursive = new Set<Binding>();
1595
+ const declarations: { declaration: Declaration; binding: ModuleBinding | undefined }[] = [];
1596
+ const createUnit = (
1597
+ location: SourceLocation,
1598
+ self: Definition | undefined,
1599
+ errors: SanyError[],
1600
+ warnings: SanyError[],
1601
+ hasLabelScope: boolean,
1602
+ ): Unit => ({
844
1603
  imported: symbols,
1604
+ getInstance: unit.getInstance,
845
1605
  definitions: unit.definitions,
846
1606
  getKey: unit.getKey,
847
1607
  location,
848
1608
  self,
849
1609
  facts,
1610
+ goals,
1611
+ bindings,
1612
+ errors,
1613
+ warnings,
1614
+ hasLabelScope,
1615
+ isLabelForbidden: false,
1616
+ isInExcept: false,
1617
+ labelParams: [],
1618
+ labels: new Set(),
1619
+ isGenerated: false,
850
1620
  });
851
- collectSemanticErrors([
852
- ...module.definitions.map((definition) => ({
853
- location: definition.location,
854
- check: () =>
855
- resolveDefinition(definition, undefined, createUnit(definition.location, definition)),
856
- })),
857
- ...module.assumptions.map((assumption) => ({
858
- location: assumption.location,
859
- check: () =>
860
- resolveExpression(
861
- assumption.expression,
862
- undefined,
863
- createUnit(assumption.location, undefined),
1621
+ const bindDeclarations = (declarations: Declaration[], kind: "Constant" | "Variable") =>
1622
+ declarations.map((declaration) => ({
1623
+ location: declaration.location,
1624
+ check: (errors: SanyError[], warnings: SanyError[]) =>
1625
+ bindModuleName(
1626
+ declaration.name,
1627
+ { kind, arity: declaration.arity, range: declaration.location.range },
1628
+ createUnit(declaration.location, undefined, errors, warnings, false),
864
1629
  ),
865
- })),
866
- ...module.theorems.map((theorem) => ({
867
- location: theorem.location,
868
- check: () => resolveTheorem(theorem, createUnit(theorem.location, undefined)),
869
- })),
870
- ]);
1630
+ }));
1631
+ return collectSemanticErrors(
1632
+ [
1633
+ ...unit.reports.map((report) => ({
1634
+ location: report.location,
1635
+ check: (errors: SanyError[], warnings: SanyError[]) => {
1636
+ errors.push(...report.errors);
1637
+ warnings.push(...report.warnings);
1638
+ },
1639
+ })),
1640
+ ...bindDeclarations(module.constants, "Constant"),
1641
+ ...bindDeclarations(module.variables, "Variable"),
1642
+ ...module.units
1643
+ .flatMap((item) => (item.kind === "Recursive" ? item.declarations : []))
1644
+ .map((declaration) => ({
1645
+ location: declaration.location,
1646
+ check: (errors: SanyError[], warnings: SanyError[]) => {
1647
+ const binding: ModuleBinding = {
1648
+ kind: "Definition",
1649
+ arity: declaration.arity,
1650
+ range: declaration.location.range,
1651
+ position: declaration.location,
1652
+ isPending: true,
1653
+ };
1654
+ const isBound = isBindable(
1655
+ declaration.name,
1656
+ bindings.get(declaration.name),
1657
+ binding,
1658
+ createUnit(declaration.location, undefined, errors, warnings, false),
1659
+ );
1660
+ if (isBound) {
1661
+ bindings.set(declaration.name, binding);
1662
+ recursive.add(binding);
1663
+ }
1664
+ declarations.push({ declaration, binding: isBound ? binding : undefined });
1665
+ },
1666
+ })),
1667
+ ...module.definitions.map((definition) => ({
1668
+ location: definition.location,
1669
+ check: (errors: SanyError[], warnings: SanyError[]) => {
1670
+ const inner = createUnit(definition.location, definition, errors, warnings, true);
1671
+ if (isTheoremDefinition(module, definition)) {
1672
+ resolveExpression(definition.body, undefined, inner);
1673
+ } else if (resolveDefinition(definition, undefined, inner, recursive)) {
1674
+ bindings.set(definition.name, {
1675
+ kind: "Definition",
1676
+ arity: getArity(definition),
1677
+ range: definition.location.range,
1678
+ position: definition.location,
1679
+ });
1680
+ }
1681
+ },
1682
+ })),
1683
+ ...module.instances.map((instance) => ({
1684
+ location: instance.location,
1685
+ check: (errors: SanyError[], warnings: SanyError[]) => {
1686
+ const inner = createUnit(instance.location, undefined, errors, warnings, false);
1687
+ bindParams(undefined, instance.params, inner);
1688
+ unit.instanced
1689
+ .get(instance)
1690
+ ?.forEach((symbol, name) => bindModuleName(name, symbol, inner));
1691
+ if (instance.name !== undefined) {
1692
+ bindModuleName(
1693
+ instance.name,
1694
+ { kind: "Instance", arity: instance.params.length, range: instance.location.range },
1695
+ inner,
1696
+ );
1697
+ }
1698
+ },
1699
+ })),
1700
+ ...module.assumptions.map((assumption) => ({
1701
+ location: assumption.location,
1702
+ check: (errors: SanyError[], warnings: SanyError[]) => {
1703
+ const inner = createUnit(
1704
+ assumption.location,
1705
+ undefined,
1706
+ errors,
1707
+ warnings,
1708
+ assumption.name !== undefined,
1709
+ );
1710
+ resolveExpression(assumption.expression, undefined, inner);
1711
+ if (assumption.name !== undefined) {
1712
+ bindModuleName(
1713
+ assumption.name,
1714
+ { kind: "Theorem", arity: 0, range: assumption.location.range },
1715
+ inner,
1716
+ );
1717
+ }
1718
+ },
1719
+ })),
1720
+ ...module.theorems.map((theorem) => ({
1721
+ location: theorem.location,
1722
+ check: (errors: SanyError[], warnings: SanyError[]) =>
1723
+ resolveTheorem(
1724
+ theorem,
1725
+ createUnit(theorem.location, undefined, errors, warnings, theorem.name !== undefined),
1726
+ ),
1727
+ })),
1728
+ ...module.uses.map((use) => ({
1729
+ location: use.location,
1730
+ check: (errors: SanyError[], warnings: SanyError[]) =>
1731
+ checkFacts(
1732
+ use.facts,
1733
+ undefined,
1734
+ createUnit(use.location, undefined, errors, warnings, false),
1735
+ ),
1736
+ })),
1737
+ {
1738
+ location: module.location.range?.end ?? module.location,
1739
+ check: (errors: SanyError[]) =>
1740
+ declarations.forEach((item) => {
1741
+ const range = item.declaration.location.range;
1742
+ if (range && (!item.binding || item.binding.isPending)) {
1743
+ errors.push({
1744
+ location: formatRange(range),
1745
+ message: `Symbol ${item.declaration.name} declared in RECURSIVE statement but not defined.`,
1746
+ });
1747
+ }
1748
+ }),
1749
+ },
1750
+ ],
1751
+ unit.warnings,
1752
+ );
871
1753
  };