tla-ts 0.0.3-dev.d9ff6f2 → 0.0.3-dev.e5b05b9

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