tla-ts 0.0.3-dev.c949d82 → 0.0.3-dev.ccbff8c

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