tla-ts 0.0.3-dev.3ce2f00 → 0.0.3-dev.3ef4193

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (81) hide show
  1. package/dist/cli.cjs +1 -1
  2. package/dist/cli.js +1 -1
  3. package/dist/index.cjs +1 -1
  4. package/dist/index.d.cts +164 -46
  5. package/dist/index.d.ts +164 -46
  6. package/dist/index.js +1 -1
  7. package/dist/parallel-worker.cjs +1 -1
  8. package/dist/parallel-worker.js +2 -2
  9. package/dist/parallel.cjs +1 -1
  10. package/dist/parallel.js +2 -2
  11. package/dist/run-cli.cjs +1351 -22
  12. package/dist/run-cli.js +1351 -22
  13. package/dist/transfer.cjs +83 -33
  14. package/dist/transfer.js +83 -33
  15. package/package.json +5 -1
  16. package/src/ast.ts +54 -7
  17. package/src/bags.ts +4 -7
  18. package/src/builtins.ts +29 -17
  19. package/src/bundled-modules.ts +3 -3
  20. package/src/canonical.ts +4 -3
  21. package/src/check.ts +1317 -428
  22. package/src/cli.ts +8 -1
  23. package/src/codegen.ts +68 -21
  24. package/src/config.ts +225 -206
  25. package/src/environment.ts +417 -129
  26. package/src/errors.ts +155 -18
  27. package/src/evaluate.ts +713 -259
  28. package/src/exit-codes.ts +6 -24
  29. package/src/fingerprints.ts +1 -2
  30. package/src/index.ts +1 -0
  31. package/src/instances.ts +3 -1
  32. package/src/java-overrides.ts +104 -25
  33. package/src/levels.ts +122 -22
  34. package/src/lexer.ts +32 -4
  35. package/src/live-check.ts +204 -148
  36. package/src/liveness.ts +191 -122
  37. package/src/obligation-expression.ts +2 -2
  38. package/src/obligation-source.ts +2 -0
  39. package/src/parallel-worker.ts +6 -1
  40. package/src/parallel.ts +57 -6
  41. package/src/parser.ts +408 -168
  42. package/src/pcal-ast.ts +770 -0
  43. package/src/pcal-parse.ts +1523 -0
  44. package/src/pcal-tokenize.ts +516 -0
  45. package/src/pcal-translate.ts +1230 -0
  46. package/src/pcal-validate.ts +454 -0
  47. package/src/randomization.ts +24 -7
  48. package/src/resolve.ts +1379 -448
  49. package/src/run-cli.ts +1161 -196
  50. package/src/runtime.ts +16 -0
  51. package/src/sany-builtins.ts +147 -0
  52. package/src/sany-generator.ts +3112 -0
  53. package/src/sany-levels.ts +1208 -0
  54. package/src/sany-lexer.ts +545 -0
  55. package/src/sany-linter.ts +122 -0
  56. package/src/sany-modules.ts +1398 -0
  57. package/src/sany-nodes.ts +463 -0
  58. package/src/sany-parse-error.ts +2161 -0
  59. package/src/sany-report.ts +354 -0
  60. package/src/sany-selectors.ts +738 -0
  61. package/src/sany-source.ts +248 -0
  62. package/src/sany-xml.ts +1017 -0
  63. package/src/spec-description.ts +25 -5
  64. package/src/standard-modules.ts +172 -129
  65. package/src/standard-ranges.ts +116 -0
  66. package/src/state-graph.ts +29 -6
  67. package/src/subexpressions.ts +221 -161
  68. package/src/substitution-levels.ts +5 -8
  69. package/src/successors.ts +141 -173
  70. package/src/symmetry.ts +168 -50
  71. package/src/tableau.ts +3 -1
  72. package/src/tlc-ext.ts +13 -17
  73. package/src/tlc-messages.ts +329 -0
  74. package/src/tlc-module.ts +49 -21
  75. package/src/tlc-modules.ts +0 -4
  76. package/src/tlc-order.ts +55 -9
  77. package/src/tlc-random.ts +28 -3
  78. package/src/tlc-replay.ts +655 -0
  79. package/src/tlc-version.ts +18 -0
  80. package/src/transfer.ts +15 -3
  81. package/src/values.ts +664 -317
package/src/parser.ts CHANGED
@@ -23,14 +23,29 @@ import type {
23
23
  UseOrHide,
24
24
  } from "./ast";
25
25
  import { createSanyError, formatRange, TlaSyntaxError } from "./errors";
26
- import { getNumeralValue, tokenize, type Token } from "./lexer";
26
+ import { getNumeralValue, readAtAsIdentifier, tokenize, type Token } from "./lexer";
27
+ import { getSanyParseError } from "./sany-parse-error";
27
28
 
28
- interface InfixOperator {
29
+ interface Precedence {
29
30
  low: number;
30
31
  high: number;
32
+ }
33
+
34
+ interface InfixOperator extends Precedence {
31
35
  isAssociative: boolean;
32
36
  }
33
37
 
38
+ // TLAplusParser.lastOp, the operator parsed last, and the operator an operand being parsed follows
39
+ // in its expression.
40
+ interface OperatorContext {
41
+ last?: Precedence;
42
+ preceding?: Precedence;
43
+ }
44
+
45
+ // SANY's precedences of a postfix operator and of the "[" of a function application.
46
+ const POSTFIX_PRECEDENCE: Precedence = { low: 15, high: 15 };
47
+ const FUNCTION_PRECEDENCE: Precedence = { low: 16, high: 16 };
48
+
34
49
  const createInfix = (low: number, high: number, isAssociative: boolean) => ({
35
50
  low,
36
51
  high,
@@ -141,6 +156,19 @@ const POSTFIX_OPERATORS = new Set(["^+", "^*", "^#"]);
141
156
 
142
157
  const PREFIX_OPERATOR_REFERENCES = new Set(["-", "~", "-."]);
143
158
 
159
+ // The prefix operators SANY reads in a definition's left-hand side, built-in ones included.
160
+ const DEFINABLE_PREFIX_OPERATORS = new Set([
161
+ "-.",
162
+ "~",
163
+ "[]",
164
+ "<>",
165
+ "ENABLED",
166
+ "UNCHANGED",
167
+ "SUBSET",
168
+ "UNION",
169
+ "DOMAIN",
170
+ ]);
171
+
144
172
  const EXPRESSION_PREFIXES = new Set([
145
173
  "-",
146
174
  "~",
@@ -169,6 +197,16 @@ const OPERATOR_ARGUMENTS = new Set([
169
197
  ...POSTFIX_OPERATORS,
170
198
  ]);
171
199
 
200
+ // A SANY InfixExpr or PostfixExpr.
201
+ const isOperatorExpression = (expression: Expression) =>
202
+ expression.kind === "Prime" ||
203
+ expression.kind === "Product" ||
204
+ ((expression.kind === "And" || expression.kind === "Or") && !expression.isBulleted) ||
205
+ (expression.kind === "Apply" &&
206
+ (expression.args.length === 2
207
+ ? INFIX_OPERATORS.has(expression.operator)
208
+ : POSTFIX_OPERATORS.has(expression.operator)));
209
+
172
210
  const isOperatorName = (text: string) =>
173
211
  INFIX_OPERATORS.has(text) || POSTFIX_OPERATORS.has(text) || text === "-.";
174
212
 
@@ -262,6 +300,7 @@ const FACT_KEYWORDS = new Set([
262
300
  "IF",
263
301
  "LAMBDA",
264
302
  "LET",
303
+ "MODULE",
265
304
  "SF_",
266
305
  "SUBSET",
267
306
  "UNCHANGED",
@@ -291,30 +330,33 @@ const BUILTIN_CONSTANTS = new Set(["TRUE", "FALSE", "BOOLEAN", "STRING"]);
291
330
 
292
331
  const NO_OFFSIDE = -1;
293
332
 
294
- const getModuleHeader = (name: string) => new RegExp(`^-{4,}\\s*MODULE\\s+${name}\\s*-{3,}$`);
295
-
296
- // The text of a module that starts on its own line in a file, as TLC's monolith extractor reads
297
- // modules that follow the root module.
333
+ // MonolithSpecExtractor.module: a module that no file defines can follow the root module in the
334
+ // root module's file, from its ---- MODULE line to the next ==== line.
298
335
  export const extractModule = (source: string, name: string) => {
336
+ const header = new RegExp(`^-{4,}\\s*MODULE\\s+${name}\\s*-{3,}$`);
299
337
  const lines = source.split(/\r?\n/);
300
- const start = lines.findIndex((line) => getModuleHeader(name).test(line));
338
+ const start = lines.findIndex((line) => header.test(line));
301
339
  if (start === -1) return undefined;
302
340
  const end = lines.findIndex((line, index) => index > start && line.startsWith("===="));
303
- return lines.slice(start, end === -1 ? undefined : end + 1).join("\n");
341
+ return `${lines.slice(start, end === -1 ? undefined : end + 1).join("\n")}\n`;
304
342
  };
305
343
 
306
- // isTlapm parses as tlapm does for proof obligations, which accepts and rejects some modules that
307
- // SANY does not.
308
- const parse = (source: string, isTlapm: boolean): Module => {
309
- const tokens = tokenize(source);
344
+ // The tlapm mode parses as tlapm does for proof obligations, which accepts and rejects some modules
345
+ // that SANY does not. The sany mode leaves the checks that SANY makes after parsing to the SANY
346
+ // generator.
347
+ type ParseMode = "tlc" | "tlapm" | "sany";
348
+
349
+ const parse = (source: string, mode: ParseMode): Module => {
350
+ const isTlapm = mode === "tlapm";
351
+ const tokens = isTlapm ? tokenize(source) : tokenize(source).map(readAtAsIdentifier);
310
352
  const cursor = { index: 0, offsideColumns: [] as number[] };
353
+ const operators: OperatorContext = {};
311
354
  // A RECURSIVE declaration covers the definitions of its own LET or module.
312
355
  const recursiveScopes: Set<string>[] = [];
313
356
  const factNames = new Set<string>();
314
357
  // The NEW, TAKE, and PICK names in scope, which a DEF clause cannot cite.
315
358
  const proofScopes: Set<string>[] = [];
316
- // A fact may cite an operator of a parameterized instance without the instance's arguments.
317
- const factStart = { index: -1 };
359
+ // SANY reports a location in a nested module as one in the module of its file.
318
360
  const openModules: Module[] = [];
319
361
 
320
362
  const isRecursiveName = (name: string) => recursiveScopes[recursiveScopes.length - 1].has(name);
@@ -329,15 +371,14 @@ const parse = (source: string, isTlapm: boolean): Module => {
329
371
  const tokenEnds: SourceLocation[] = [];
330
372
  const tokenRanges: SourceRange[] = [];
331
373
 
332
- const getRange = (startIndex: number) => {
333
- const endIndex = cursor.index - 1;
374
+ const getRange = (startIndex: number, endIndex = cursor.index - 1) => {
334
375
  const cached = startIndex === endIndex ? tokenRanges[startIndex] : undefined;
335
376
  if (cached) return cached;
336
377
  const last = tokens[endIndex];
337
378
  tokenStarts[startIndex] ??= getLocation(tokens[startIndex]);
338
379
  tokenEnds[endIndex] ??= { line: last.line, column: last.endColumn };
339
380
  const range = {
340
- module: openModules[openModules.length - 1].name,
381
+ module: openModules[0].name,
341
382
  start: tokenStarts[startIndex],
342
383
  end: tokenEnds[endIndex],
343
384
  };
@@ -435,8 +476,12 @@ const parse = (source: string, isTlapm: boolean): Module => {
435
476
  const createUnexpected = (message: string, token: Token = peekRaw()) =>
436
477
  createError(message, token, token);
437
478
 
479
+ // TLAplusParser.isFieldNameToken: a keyword or an underscore names a field or a module too.
438
480
  const isFieldName = (token: Token) =>
439
- (token.kind === "Identifier" || token.kind === "Keyword") && !isTlapmKeyword(token);
481
+ (token.kind === "Identifier" ||
482
+ token.kind === "Keyword" ||
483
+ (token.kind === "Operator" && token.text === "_")) &&
484
+ !isTlapmKeyword(token);
440
485
 
441
486
  const isAt = (text: string, offset = 0) => {
442
487
  const token = peek(offset);
@@ -472,7 +517,42 @@ const parse = (source: string, isTlapm: boolean): Module => {
472
517
  return token.text;
473
518
  };
474
519
 
475
- const withoutOffside = <Result>(parse: () => Result) => {
520
+ const expectName = () => {
521
+ const start = cursor.index;
522
+ return { name: expectIdentifier(), range: getRange(start) };
523
+ };
524
+
525
+ const getNames = (names: { name: string; range: SourceRange }[]) => ({
526
+ names: names.map((item) => item.name),
527
+ ranges: names.map((item) => item.range),
528
+ });
529
+
530
+ // TLAplusParser.Substitution: an identifier, or a prefix, infix or postfix operator.
531
+ const expectSubstitutionTarget = () => {
532
+ const token = peek();
533
+ const isOperator =
534
+ token.kind !== "String" &&
535
+ (DEFINABLE_PREFIX_OPERATORS.has(token.text) ||
536
+ INFIX_OPERATORS.has(token.text) ||
537
+ POSTFIX_OPERATORS.has(token.text) ||
538
+ token.text === "'");
539
+ if (!isOperator) return expectIdentifier();
540
+ cursor.index++;
541
+ return token.text;
542
+ };
543
+
544
+ // SANY takes a keyword for the name of a module, as it does for a field.
545
+ const keywordModuleName = { isUsed: false };
546
+ const expectModuleName = () => {
547
+ if (peek().kind === "Identifier" || !isFieldName(peek())) return expectIdentifier();
548
+ keywordModuleName.isUsed = true;
549
+ return advance().text;
550
+ };
551
+
552
+ // tlapm reads a bracketed expression apart from the junction list around it, whose alignment
553
+ // SANY keeps applying.
554
+ const withBracketLayout = <Result>(parse: () => Result) => {
555
+ if (!isTlapm) return parse();
476
556
  cursor.offsideColumns.push(NO_OFFSIDE);
477
557
  const result = parse();
478
558
  cursor.offsideColumns.pop();
@@ -514,10 +594,13 @@ const parse = (source: string, isTlapm: boolean): Module => {
514
594
  };
515
595
 
516
596
  const parsePattern = (): BoundPattern => {
517
- if (!accept("<<")) return { kind: "Name", name: expectIdentifier() };
518
- const names = parseSeparated(expectIdentifier);
597
+ if (!accept("<<")) {
598
+ const named = expectName();
599
+ return { kind: "Name", name: named.name, ranges: [named.range] };
600
+ }
601
+ const names = getNames(parseSeparated(expectName));
519
602
  expect(">>");
520
- return { kind: "Tuple", names };
603
+ return { kind: "Tuple", names: names.names, ranges: names.ranges };
521
604
  };
522
605
 
523
606
  const parseBounds = () =>
@@ -560,8 +643,9 @@ const parse = (source: string, isTlapm: boolean): Module => {
560
643
  );
561
644
  };
562
645
 
646
+ // SANY's OpOrExpr reads an operator as an argument only before what ends the argument, and as
647
+ // the start of an expression, such as -.(1), otherwise.
563
648
  const isStandalone = (operator: Token) => {
564
- if (!EXPRESSION_PREFIXES.has(operator.text)) return true;
565
649
  const token = peek(1);
566
650
  return (
567
651
  token.kind === "End" ||
@@ -600,7 +684,12 @@ const parse = (source: string, isTlapm: boolean): Module => {
600
684
  if (isOperatorAlone) {
601
685
  cursor.index++;
602
686
  return withRange(
603
- { kind: "OperatorReference", operator: token.text, location: getLocation(token) },
687
+ {
688
+ kind: "OperatorReference",
689
+ operator: token.text,
690
+ spelling: token.spelling,
691
+ location: getLocation(token),
692
+ },
604
693
  cursor.index - 1,
605
694
  );
606
695
  }
@@ -610,37 +699,47 @@ const parse = (source: string, isTlapm: boolean): Module => {
610
699
  cursor.index++;
611
700
  const location = getLocation(token);
612
701
  if (POSTFIX_OPERATORS.has(token.text)) {
613
- return { kind: "OperatorReference", operator: token.text, location };
702
+ return withRange(
703
+ { kind: "OperatorReference", operator: token.text, location },
704
+ cursor.index - 1,
705
+ );
614
706
  }
615
707
  const argument: Expression = { kind: "Identifier", name: "argument", location };
616
- return {
617
- kind: "Lambda",
618
- params: [argument.name],
619
- body: getOperatorApplication(token.text, argument, location),
620
- location,
621
- };
708
+ return withRange(
709
+ {
710
+ kind: "Lambda",
711
+ params: [argument.name],
712
+ body: getOperatorApplication(token.text, argument, location),
713
+ operator: token.text,
714
+ location: getLocation(token),
715
+ },
716
+ cursor.index - 1,
717
+ );
622
718
  }
623
719
  if (isAt("LAMBDA")) {
624
720
  const start = cursor.index;
625
721
  advance();
626
- const params = parseSeparated(expectIdentifier);
722
+ const params = getNames(parseSeparated(expectName));
627
723
  expect(":");
628
724
  const body = parseExpression();
629
- return withRange({ kind: "Lambda", params, body, location: getLocation(token) }, start);
725
+ return withRange(
726
+ {
727
+ kind: "Lambda",
728
+ params: params.names,
729
+ paramRanges: params.ranges,
730
+ body,
731
+ location: getLocation(token),
732
+ },
733
+ start,
734
+ );
630
735
  }
631
- const argument = parseExpression();
632
- // SANY reads an argument that only names an operator of a parameterized instance, such as
633
- // I!Op, as that operator, which takes the arguments of the instance too.
634
- if (argument.kind === "Identifier") missingArguments.delete(argument);
635
- return argument;
736
+ return parseExpression();
636
737
  };
637
738
 
638
- const missingArguments = new Map<Expression, { location: string; message: string }>();
639
-
640
739
  const lastArguments: { range: SourceRange | undefined } = { range: undefined };
641
740
 
642
741
  const parseArguments = () =>
643
- withoutOffside(() => {
742
+ withBracketLayout(() => {
644
743
  const start = cursor.index;
645
744
  expect("(");
646
745
  const args = parseSeparated(parseArgument);
@@ -667,18 +766,25 @@ const parse = (source: string, isTlapm: boolean): Module => {
667
766
  };
668
767
 
669
768
  const parseBracket = (start: Token): Expression =>
670
- withoutOffside(() => {
769
+ withBracketLayout(() => {
671
770
  const location = getLocation(start);
672
- if (peek().kind === "Identifier" && (isAt("|->", 1) || isAt(":", 1))) {
673
- const kind = isAt("|->", 1) ? "Record" : "RecordSet";
674
- const fields = parseSeparated(() => {
771
+ // SANY takes a keyword for the first field of a record, as it does for a selected field.
772
+ const isIdentifier = peek().kind === "Identifier";
773
+ const isRecord = isAt("|->", 1) && (isIdentifier || isFieldName(peek()));
774
+ if (isRecord || (isIdentifier && isAt(":", 1))) {
775
+ const kind = isRecord ? "Record" : "RecordSet";
776
+ const parseField = (readName: () => string) => {
675
777
  const fieldStart = cursor.index;
676
778
  const fieldLocation = getLocation(peek());
677
- const name = expectIdentifier();
779
+ const name = readName();
678
780
  fieldLocation.range = getRange(fieldStart);
679
- expect(kind === "Record" ? "|->" : ":");
781
+ expect(isRecord ? "|->" : ":");
680
782
  return { name, value: parseExpression(), location: fieldLocation };
681
- });
783
+ };
784
+ const fields = [
785
+ parseField(() => (isIdentifier ? expectIdentifier() : advance().text)),
786
+ ...(accept(",") ? parseSeparated(() => parseField(expectIdentifier)) : []),
787
+ ];
682
788
  expect("]");
683
789
  return { kind, fields, location };
684
790
  }
@@ -716,17 +822,29 @@ const parse = (source: string, isTlapm: boolean): Module => {
716
822
  expect("]");
717
823
  return { kind: "Except", function: expression, updates, location };
718
824
  }
825
+ if (!isTlapm && !isAt("]_")) {
826
+ const args = [expression];
827
+ while (accept(",")) args.push(parseExpression());
828
+ expect("]");
829
+ return { kind: "Bracket", args, location };
830
+ }
719
831
  expect("]_");
720
- return {
721
- kind: "BoxAction",
722
- action: expression,
723
- subscript: parseSubscript(),
724
- location,
725
- };
832
+ return { kind: "BoxAction", action: expression, subscript: parseSubscript(), location };
726
833
  });
727
834
 
835
+ // SANY reads the set after the \in of {x \in S} as a whole expression, whatever operators it has.
836
+ const parseSetMembership = (): Expression => {
837
+ const start = cursor.index;
838
+ const element = withRange(parsePrefix(), start);
839
+ const location = getLocation(advance());
840
+ return withRange(
841
+ { kind: "Apply", operator: "\\in", args: [element, parseExpression()], location },
842
+ start,
843
+ );
844
+ };
845
+
728
846
  const parseBrace = (start: Token): Expression =>
729
- withoutOffside(() => {
847
+ withBracketLayout(() => {
730
848
  const location = getLocation(start);
731
849
  if (accept("}")) return { kind: "SetEnumeration", elements: [], location };
732
850
  if (isBoundAhead() && (peek(1).text === "\\in" || isAt("<<"))) {
@@ -741,7 +859,8 @@ const parse = (source: string, isTlapm: boolean): Module => {
741
859
  }
742
860
  cursor.index = checkpoint;
743
861
  }
744
- const first = parseExpression();
862
+ const first =
863
+ peek().kind === "Identifier" && isAt("\\in", 1) ? parseSetMembership() : parseExpression();
745
864
  if (accept(":")) {
746
865
  const bounds = parseBounds();
747
866
  expect("}");
@@ -755,7 +874,7 @@ const parse = (source: string, isTlapm: boolean): Module => {
755
874
 
756
875
  const parseTuple = (start: Token): Expression => {
757
876
  const location = getLocation(start);
758
- const elements = withoutOffside(() =>
877
+ const elements = withBracketLayout(() =>
759
878
  isAt(">>") || isAt(">>_") ? [] : parseSeparated(() => parseExpression()),
760
879
  );
761
880
  if (accept(">>_")) {
@@ -776,12 +895,13 @@ const parse = (source: string, isTlapm: boolean): Module => {
776
895
  expect(":");
777
896
  return { kind, bounds, body: parseExpression(), location };
778
897
  }
779
- const names = parseSeparated(expectIdentifier);
898
+ const names = getNames(parseSeparated(expectName));
780
899
  expect(":");
781
900
  return {
782
901
  kind: "UnboundedQuantifier",
783
902
  quantifier: start.text === "\\A" || start.text === "\\AA" ? "Forall" : "Exists",
784
- names,
903
+ names: names.names,
904
+ nameRanges: names.ranges,
785
905
  body: parseExpression(),
786
906
  isTemporal,
787
907
  location,
@@ -835,9 +955,8 @@ const parse = (source: string, isTlapm: boolean): Module => {
835
955
  return { kind: "Name", name: token.text, args: isAt("(") ? parseArguments() : [] };
836
956
  };
837
957
 
838
- const parsePrimary = (): Expression => {
958
+ const parsePrimary = (preceding?: Precedence): Expression => {
839
959
  const start = cursor.index;
840
- const isFactStart = start === factStart.index;
841
960
  const token = advance();
842
961
  const location = getLocation(token);
843
962
  if (isTlapm && token.kind === "Keyword" && token.text === "LAMBDA") {
@@ -861,36 +980,47 @@ const parse = (source: string, isTlapm: boolean): Module => {
861
980
  if (token.kind === "Identifier" || isStep) {
862
981
  const name = isStep ? (getStepName(token) ?? token.text) : token.text;
863
982
  if (isLabelAhead()) {
864
- const params = accept("(") ? parseSeparated(expectIdentifier) : [];
865
- if (params.length > 0) expect(")");
983
+ const params = getNames(accept("(") ? parseSeparated(expectName) : []);
984
+ if (params.names.length > 0) expect(")");
866
985
  expect("::");
867
- return { kind: "Label", name, params, body: parseExpression(), location };
986
+ const body = parseExpression();
987
+ // TLAplusParser.labelDoesNotChangeParse.
988
+ if (
989
+ !isTlapm &&
990
+ preceding !== undefined &&
991
+ operators.last !== undefined &&
992
+ isOperatorExpression(body) &&
993
+ preceding.high >= operators.last.low
994
+ ) {
995
+ throw createError("Removing the label would change expression parsing", token);
996
+ }
997
+ return {
998
+ kind: "Label",
999
+ name,
1000
+ params: params.names,
1001
+ paramRanges: params.ranges,
1002
+ body,
1003
+ location,
1004
+ };
868
1005
  }
869
1006
  const hasArguments = isAt("(");
1007
+ if (name === "@" && !hasArguments && !isSelectorAhead())
1008
+ return { kind: "ExceptAt", location };
870
1009
  const args = hasArguments ? parseArguments() : [];
1010
+ const argumentRanges = [hasArguments ? lastArguments.range : undefined];
871
1011
  if (!isSelectorAhead()) {
872
1012
  return hasArguments
873
1013
  ? { kind: "Apply", operator: name, args, argumentsRange: lastArguments.range, location }
874
1014
  : { kind: "Identifier", name, location };
875
1015
  }
876
- const instance = openModules
877
- .flatMap((module) => module.instances)
878
- .find((candidate) => candidate.name === name);
879
- const isMissingArguments =
880
- instance !== undefined &&
881
- !isFactStart &&
882
- !isTlapm &&
883
- instance.params.length !== args.length;
884
- if (isMissingArguments && args.length > 0) {
885
- throw createError(
886
- `The operator ${name} requires ${instance.params.length} arguments`,
887
- token,
888
- );
889
- }
890
1016
  const selectors: Selector[] = [{ kind: "Name", name, args }];
1017
+ const selectorRanges = [getRange(start, start)];
891
1018
  while (isSelectorAhead()) {
892
1019
  advance();
1020
+ selectorRanges.push(getRange(cursor.index, cursor.index));
1021
+ lastArguments.range = undefined;
893
1022
  selectors.push(parseSelector());
1023
+ argumentRanges.push(lastArguments.range);
894
1024
  }
895
1025
  const names = selectors.flatMap((selector) =>
896
1026
  selector.kind === "Name" ? [selector.name] : [],
@@ -902,35 +1032,42 @@ const parse = (source: string, isTlapm: boolean): Module => {
902
1032
  const argumentCounts = selectors.map((selector) =>
903
1033
  "args" in selector ? selector.args.length : 0,
904
1034
  );
905
- const argumentsRange = lastArguments.range;
906
- const reference: Expression =
907
- names.length < selectors.length
908
- ? { kind: "Subexpression", selectors, location }
909
- : qualifiedArgs.length === 0
910
- ? { kind: "Identifier", name: operator, location }
911
- : argumentCounts.slice(0, -1).some((count) => count > 0)
912
- ? {
913
- kind: "Apply",
914
- operator,
915
- args: qualifiedArgs,
916
- argumentCounts,
917
- argumentsRange,
918
- location,
919
- }
920
- : { kind: "Apply", operator, args: qualifiedArgs, argumentsRange, location };
921
- if (isMissingArguments) {
922
- missingArguments.set(reference, {
923
- location: formatRange(getRange(start)),
924
- message: `The operator ${name} requires ${instance.params.length} arguments.`,
925
- });
926
- }
927
- return reference;
1035
+ const argumentsRange = argumentRanges.at(-1) ?? getRange(start);
1036
+ return names.length < selectors.length
1037
+ ? { kind: "Subexpression", selectors, selectorRanges, argumentRanges, location }
1038
+ : qualifiedArgs.length === 0
1039
+ ? { kind: "Identifier", name: operator, selectorRanges, location }
1040
+ : argumentCounts.slice(0, -1).some((count) => count > 0)
1041
+ ? {
1042
+ kind: "Apply",
1043
+ operator,
1044
+ args: qualifiedArgs,
1045
+ argumentCounts,
1046
+ argumentsRange,
1047
+ selectorRanges,
1048
+ argumentRanges,
1049
+ location,
1050
+ }
1051
+ : {
1052
+ kind: "Apply",
1053
+ operator,
1054
+ args: qualifiedArgs,
1055
+ argumentsRange,
1056
+ selectorRanges,
1057
+ argumentRanges,
1058
+ location,
1059
+ };
928
1060
  }
929
- if (token.kind === "Operator" && isOperatorName(token.text) && isAt("("))
1061
+ // SANY reads an infix or postfix operator as a primary expression, with or without arguments.
1062
+ if (token.kind === "Operator" && isOperatorName(token.text) && isAt("(")) {
930
1063
  return { kind: "Apply", operator: token.text, args: parseArguments(), location };
1064
+ }
1065
+ if (token.kind === "Operator" && isOperatorName(token.text) && !isTlapm) {
1066
+ return { kind: "Identifier", name: token.text, location };
1067
+ }
931
1068
  switch (token.text) {
932
1069
  case "(": {
933
- const expression = withoutOffside(() => parseExpression());
1070
+ const expression = withBracketLayout(() => parseExpression());
934
1071
  expect(")");
935
1072
  return expression;
936
1073
  }
@@ -986,7 +1123,7 @@ const parse = (source: string, isTlapm: boolean): Module => {
986
1123
  case "WF_":
987
1124
  case "SF_": {
988
1125
  const subscript = parseSubscript();
989
- const action = withoutOffside(() => {
1126
+ const action = withBracketLayout(() => {
990
1127
  expect("(");
991
1128
  const expression = parseExpression();
992
1129
  expect(")");
@@ -1003,7 +1140,25 @@ const parse = (source: string, isTlapm: boolean): Module => {
1003
1140
  throw createUnexpected(`Unexpected ${describe(token)}`, token);
1004
1141
  };
1005
1142
 
1143
+ // SANY rejects the operator after a prefix operator's operand unless it binds looser than the
1144
+ // prefix operator.
1145
+ const parsePrefixOperand = (operator: Token, low: number, high: number) => {
1146
+ operators.last = operators.preceding = { low, high };
1147
+ const operand = parseExpression(high + 1);
1148
+ const next = peek();
1149
+ const nextHigh =
1150
+ next.text === "'" || POSTFIX_OPERATORS.has(next.text)
1151
+ ? POSTFIX_PRECEDENCE.high
1152
+ : INFIX_OPERATORS.get(next.text)?.high;
1153
+ if (!isTlapm && next.kind === "Operator" && nextHigh !== undefined && nextHigh >= low) {
1154
+ throw createError(`Precedence conflict between ${operator.text} and ${next.text}`, next);
1155
+ }
1156
+ return operand;
1157
+ };
1158
+
1006
1159
  const parsePrefix = (): Expression => {
1160
+ const preceding = operators.preceding;
1161
+ operators.preceding = undefined;
1007
1162
  const token = peek();
1008
1163
  const location = getLocation(token);
1009
1164
  if (token.kind === "Operator" && (token.text === "/\\" || token.text === "\\/")) {
@@ -1013,35 +1168,46 @@ const parse = (source: string, isTlapm: boolean): Module => {
1013
1168
  switch (token.text) {
1014
1169
  case "~":
1015
1170
  advance();
1016
- return { kind: "Apply", operator: "~", args: [parseExpression(5)], location };
1171
+ return {
1172
+ kind: "Apply",
1173
+ operator: "~",
1174
+ args: [parsePrefixOperand(token, 4, 4)],
1175
+ location,
1176
+ };
1017
1177
  case "-":
1018
1178
  advance();
1019
1179
  return {
1020
1180
  kind: "Apply",
1021
1181
  operator: "-.",
1022
- args: [parseExpression(NEGATION_PRECEDENCE + 1)],
1182
+ args: [parsePrefixOperand(token, NEGATION_PRECEDENCE, NEGATION_PRECEDENCE)],
1023
1183
  location,
1024
1184
  };
1025
1185
  case "[]":
1026
1186
  advance();
1027
- return { kind: "Always", expression: parseExpression(16), location };
1187
+ return { kind: "Always", expression: parsePrefixOperand(token, 4, 15), location };
1028
1188
  case "<>":
1029
1189
  advance();
1030
- return { kind: "Eventually", expression: parseExpression(16), location };
1190
+ return { kind: "Eventually", expression: parsePrefixOperand(token, 4, 15), location };
1031
1191
  case "ENABLED":
1032
1192
  advance();
1033
- return { kind: "Enabled", expression: parseExpression(16), location };
1193
+ return { kind: "Enabled", expression: parsePrefixOperand(token, 4, 15), location };
1034
1194
  case "UNCHANGED":
1035
1195
  advance();
1036
- return { kind: "Unchanged", expression: parseExpression(16), location };
1196
+ return { kind: "Unchanged", expression: parsePrefixOperand(token, 4, 15), location };
1037
1197
  case "SUBSET":
1038
1198
  case "UNION":
1039
1199
  case "DOMAIN":
1040
1200
  advance();
1041
- return { kind: "Apply", operator: token.text, args: [parseExpression(9)], location };
1201
+ return {
1202
+ kind: "Apply",
1203
+ operator: token.text,
1204
+ // tlapm gives these operators the precedence 8 of the TLA+ book, and SANY 10-13.
1205
+ args: [isTlapm ? parseExpression(9) : parsePrefixOperand(token, 10, 13)],
1206
+ location,
1207
+ };
1042
1208
  }
1043
1209
  }
1044
- return parsePrimary();
1210
+ return parsePrimary(preceding);
1045
1211
  };
1046
1212
 
1047
1213
  const parseExpression = (minimumPrecedence = 0): Expression => {
@@ -1057,11 +1223,13 @@ const parse = (source: string, isTlapm: boolean): Module => {
1057
1223
  const location = getLocation(token);
1058
1224
  if (token.text === "'" && minimumPrecedence <= 15) {
1059
1225
  advance();
1226
+ operators.last = POSTFIX_PRECEDENCE;
1060
1227
  state.left = withRange({ kind: "Prime", expression: state.left, location }, start);
1061
1228
  continue;
1062
1229
  }
1063
1230
  if (POSTFIX_OPERATORS.has(token.text) && minimumPrecedence <= 15) {
1064
1231
  advance();
1232
+ operators.last = POSTFIX_PRECEDENCE;
1065
1233
  state.left = withRange(
1066
1234
  { kind: "Apply", operator: token.text, args: [state.left], location },
1067
1235
  start,
@@ -1070,8 +1238,9 @@ const parse = (source: string, isTlapm: boolean): Module => {
1070
1238
  }
1071
1239
  if (token.text === "[") {
1072
1240
  advance();
1073
- const args = withoutOffside(() => parseSeparated(() => parseExpression()));
1074
- withoutOffside(() => expect("]"));
1241
+ const args = withBracketLayout(() => parseSeparated(() => parseExpression()));
1242
+ withBracketLayout(() => expect("]"));
1243
+ operators.last = FUNCTION_PRECEDENCE;
1075
1244
  state.left = withRange(
1076
1245
  { kind: "FunctionApplication", function: state.left, args, location },
1077
1246
  start,
@@ -1102,21 +1271,33 @@ const parse = (source: string, isTlapm: boolean): Module => {
1102
1271
  if (infix.low > NEGATION_PRECEDENCE && isAt("-")) {
1103
1272
  throw createError(`Precedence conflict between ${token.text} and -`, peek());
1104
1273
  }
1274
+ operators.last = operators.preceding = infix;
1105
1275
  const right = parseExpression(infix.high + 1);
1106
1276
  const left = state.left;
1107
1277
  if (token.text === "/\\" || token.text === "\\/") {
1108
1278
  const kind = token.text === "/\\" ? "And" : "Or";
1279
+ const prefixEnds = [getRange(start).end];
1109
1280
  state.left =
1110
1281
  left.kind === kind && previous?.text === token.text
1111
- ? { ...left, operands: [...left.operands, right] }
1112
- : { kind, operands: [left, right], location };
1282
+ ? {
1283
+ ...left,
1284
+ operands: [...left.operands, right],
1285
+ prefixEnds: [...(left.prefixEnds ?? []), ...prefixEnds],
1286
+ }
1287
+ : { kind, operands: [left, right], prefixEnds, location };
1113
1288
  } else if (token.text === "\\X") {
1114
1289
  state.left =
1115
1290
  left.kind === "Product" && previous?.text === "\\X"
1116
1291
  ? { ...left, factors: [...left.factors, right] }
1117
1292
  : { kind: "Product", factors: [left, right], location };
1118
1293
  } else {
1119
- state.left = { kind: "Apply", operator: token.text, args: [left, right], location };
1294
+ state.left = {
1295
+ kind: "Apply",
1296
+ operator: token.text,
1297
+ spelling: token.spelling,
1298
+ args: [left, right],
1299
+ location,
1300
+ };
1120
1301
  }
1121
1302
  state.left = withRange(state.left, start);
1122
1303
  state.previous = { ...infix, text: token.text };
@@ -1136,7 +1317,7 @@ const parse = (source: string, isTlapm: boolean): Module => {
1136
1317
  const body = parseExpression();
1137
1318
  const last = tokens[cursor.index - 1];
1138
1319
  const end = { line: last.line, column: last.endColumn };
1139
- return { body, bodyRange: { module: openModules[openModules.length - 1].name, start, end } };
1320
+ return { body, bodyRange: { module: openModules[0].name, start, end } };
1140
1321
  };
1141
1322
 
1142
1323
  const parseDefinition = (isLocal: boolean): Definition | Instance => {
@@ -1144,6 +1325,16 @@ const parse = (source: string, isTlapm: boolean): Module => {
1144
1325
  return withRange(parseDefinitionUnit(isLocal), start);
1145
1326
  };
1146
1327
 
1328
+ const toParam = (named: { name: string; range: SourceRange }): OperatorParam => ({
1329
+ name: named.name,
1330
+ arity: 0,
1331
+ location: {
1332
+ line: named.range.start.line,
1333
+ column: named.range.start.column,
1334
+ range: named.range,
1335
+ },
1336
+ });
1337
+
1147
1338
  const parseDefinitionUnit = (isLocal: boolean): Definition | Instance => {
1148
1339
  const token = peek();
1149
1340
  const location = getLocation(token);
@@ -1163,28 +1354,27 @@ const parse = (source: string, isTlapm: boolean): Module => {
1163
1354
  peek(2).kind === "Identifier" &&
1164
1355
  isAt("==", 3)
1165
1356
  ) {
1166
- const left = expectIdentifier();
1357
+ const left = expectName();
1167
1358
  const operator = advance().text;
1168
- const right = expectIdentifier();
1359
+ const right = expectName();
1169
1360
  expect("==");
1170
- return parseOperator(operator, [
1171
- { name: left, arity: 0 },
1172
- { name: right, arity: 0 },
1173
- ]);
1361
+ return parseOperator(operator, [toParam(left), toParam(right)]);
1174
1362
  }
1175
- const isPrefixDefinition = token.kind === "Operator" && token.text === "-.";
1363
+ const isPrefixDefinition =
1364
+ token.kind !== "String" && DEFINABLE_PREFIX_OPERATORS.has(token.text);
1176
1365
  const isPostfixDefinition =
1177
1366
  token.kind === "Identifier" && POSTFIX_OPERATORS.has(peek(1).text) && isAt("==", 2);
1178
1367
  if (isPrefixDefinition || isPostfixDefinition) {
1179
1368
  const operator = isPrefixDefinition ? token.text : peek(1).text;
1180
- cursor.index += isPrefixDefinition ? 1 : 2;
1181
- const param = isPrefixDefinition ? expectIdentifier() : token.text;
1369
+ if (isPrefixDefinition) advance();
1370
+ const param = expectName();
1371
+ if (isPostfixDefinition) advance();
1182
1372
  expect("==");
1183
- return parseOperator(operator, [{ name: param, arity: 0 }]);
1373
+ return parseOperator(operator, [toParam(param)]);
1184
1374
  }
1185
1375
  const name = expectIdentifier();
1186
1376
  if (accept("[")) {
1187
- const bounds = withoutOffside(() => parseBounds());
1377
+ const bounds = withBracketLayout(() => parseBounds());
1188
1378
  expect("]");
1189
1379
  expect("==");
1190
1380
  return {
@@ -1215,12 +1405,14 @@ const parse = (source: string, isTlapm: boolean): Module => {
1215
1405
  ): Instance => {
1216
1406
  const start = cursor.index;
1217
1407
  expect("INSTANCE");
1218
- const module = expectIdentifier();
1408
+ const module = expectModuleName();
1219
1409
  const substitutions = accept("WITH")
1220
1410
  ? parseSeparated(() => {
1221
- const target = advance().text;
1411
+ const targetStart = cursor.index;
1412
+ const target = expectSubstitutionTarget();
1413
+ const nameRange = getRange(targetStart);
1222
1414
  expect("<-");
1223
- return { name: target, expression: parseArgument() };
1415
+ return { name: target, nameRange, expression: parseArgument() };
1224
1416
  })
1225
1417
  : [];
1226
1418
  return {
@@ -1236,6 +1428,11 @@ const parse = (source: string, isTlapm: boolean): Module => {
1236
1428
  };
1237
1429
 
1238
1430
  const parseDeclaration = (): Declaration => {
1431
+ const start = cursor.index;
1432
+ return withRange(parseDeclarationUnit(), start);
1433
+ };
1434
+
1435
+ const parseDeclarationUnit = (): Declaration => {
1239
1436
  const location = getLocation(peek());
1240
1437
  if (isAt("_") && peek(1).kind === "Operator") {
1241
1438
  advance();
@@ -1281,7 +1478,12 @@ const parse = (source: string, isTlapm: boolean): Module => {
1281
1478
  const token = peek();
1282
1479
  const next = peek(1);
1283
1480
  if (token.kind !== "Identifier") {
1284
- return isAt("-.") && next.kind === "Identifier" && isAt("==", 2);
1481
+ return (
1482
+ token.kind !== "String" &&
1483
+ DEFINABLE_PREFIX_OPERATORS.has(token.text) &&
1484
+ next.kind === "Identifier" &&
1485
+ isAt("==", 2)
1486
+ );
1285
1487
  }
1286
1488
  if (isAt("(", 1) || isAt("[", 1)) return isAt("==", getClosingOffset(1));
1287
1489
  if (next.kind === "Operator" && POSTFIX_OPERATORS.has(next.text)) return isAt("==", 2);
@@ -1373,7 +1575,6 @@ const parse = (source: string, isTlapm: boolean): Module => {
1373
1575
  // start of an expression.
1374
1576
  const parseFact = (): Fact => {
1375
1577
  const start = cursor.index;
1376
- factStart.index = start;
1377
1578
  const token = peek();
1378
1579
  if (
1379
1580
  token.kind === "Operator" &&
@@ -1435,7 +1636,10 @@ const parse = (source: string, isTlapm: boolean): Module => {
1435
1636
  const parseDefs = () => {
1436
1637
  if (isTlapm) return parseSeparated(parseDefinable);
1437
1638
  const defs = parseSeparated(parseFact);
1438
- const invalid = defs.find((def) => def.kind === "Identifier" && isDeclaredSymbol(def.name));
1639
+ const invalid =
1640
+ mode === "tlc"
1641
+ ? defs.find((def) => def.kind === "Identifier" && isDeclaredSymbol(def.name))
1642
+ : undefined;
1439
1643
  if (invalid) {
1440
1644
  throw createError("DEF clause entry should describe a defined operator", invalid.location);
1441
1645
  }
@@ -1460,7 +1664,7 @@ const parse = (source: string, isTlapm: boolean): Module => {
1460
1664
  location: getLocation(keyword),
1461
1665
  };
1462
1666
  const invalid =
1463
- use.kind === "Hide" && !isTlapm ? use.facts.filter((fact) => !isHideFact(fact)) : [];
1667
+ use.kind === "Hide" && mode === "tlc" ? use.facts.filter((fact) => !isHideFact(fact)) : [];
1464
1668
  if (invalid.length > 0) {
1465
1669
  throw createSanyError(
1466
1670
  invalid.map((fact) => ({
@@ -1483,10 +1687,18 @@ const parse = (source: string, isTlapm: boolean): Module => {
1483
1687
  }
1484
1688
  if (level !== undefined) advance();
1485
1689
  if (level === "Variable") {
1486
- const name = expectIdentifier();
1487
- declareProofSymbol(name);
1690
+ const named = expectName();
1691
+ declareProofSymbol(named.name);
1488
1692
  return withRange(
1489
- { kind: "NewSymbol", name, arity: 0, level, set: undefined, location },
1693
+ {
1694
+ kind: "NewSymbol",
1695
+ name: named.name,
1696
+ arity: 0,
1697
+ level,
1698
+ set: undefined,
1699
+ nameRange: named.range,
1700
+ location,
1701
+ },
1490
1702
  start,
1491
1703
  );
1492
1704
  }
@@ -1504,6 +1716,7 @@ const parse = (source: string, isTlapm: boolean): Module => {
1504
1716
  arity: declaration.arity,
1505
1717
  level: level ?? "Constant",
1506
1718
  set: isBounded ? parseExpression() : undefined,
1719
+ nameRange: declaration.location.range,
1507
1720
  location,
1508
1721
  },
1509
1722
  start,
@@ -1546,7 +1759,8 @@ const parse = (source: string, isTlapm: boolean): Module => {
1546
1759
  const token = peek();
1547
1760
  if (isAt("USE") || isAt("HIDE")) return parseUseOrHide();
1548
1761
  if (isAt("INSTANCE")) {
1549
- return withRange(parseInstance(undefined, [], false, getLocation(token)), cursor.index);
1762
+ const start = cursor.index;
1763
+ return withRange(parseInstance(undefined, [], false, getLocation(token)), start);
1550
1764
  }
1551
1765
  if (isAt("DEFINE") || isDefinitionStart()) {
1552
1766
  const start = cursor.index;
@@ -1559,21 +1773,27 @@ const parse = (source: string, isTlapm: boolean): Module => {
1559
1773
  if (accept("HAVE")) return { kind: "Have", expression: parseExpression() };
1560
1774
  if (accept("TAKE")) {
1561
1775
  const isBounded = isBoundAhead();
1562
- const names = isBounded ? [] : parseSeparated(expectIdentifier);
1776
+ const names = getNames(isBounded ? [] : parseSeparated(expectName));
1563
1777
  const bounds = isBounded ? parseBounds() : [];
1564
- declareProofSymbols(names, bounds);
1565
- return { kind: "Take", names, bounds };
1778
+ declareProofSymbols(names.names, bounds);
1779
+ return { kind: "Take", names: names.names, nameRanges: names.ranges, bounds };
1566
1780
  }
1567
1781
  if (accept("WITNESS")) {
1568
1782
  return { kind: "Witness", expressions: parseSeparated(() => parseExpression()) };
1569
1783
  }
1570
1784
  if (accept("PICK")) {
1571
1785
  const isNames = isNameListAhead(":");
1572
- const names = isNames ? parseSeparated(expectIdentifier) : [];
1786
+ const names = getNames(isNames ? parseSeparated(expectName) : []);
1573
1787
  const bounds = isNames ? [] : parseBounds();
1574
- declareProofSymbols(names, bounds);
1788
+ declareProofSymbols(names.names, bounds);
1575
1789
  expect(":");
1576
- return { kind: "Pick", names, bounds, body: parseExpression() };
1790
+ return {
1791
+ kind: "Pick",
1792
+ names: names.names,
1793
+ nameRanges: names.ranges,
1794
+ bounds,
1795
+ body: parseExpression(),
1796
+ };
1577
1797
  }
1578
1798
  if (accept("CASE")) return { kind: "Case", expression: parseExpression() };
1579
1799
  return {
@@ -1603,10 +1823,12 @@ const parse = (source: string, isTlapm: boolean): Module => {
1603
1823
  const parseStep = (): ProofStep => {
1604
1824
  const start = cursor.index;
1605
1825
  const step = parseStepStart(isAt("QED", 1));
1826
+ const statementStart = cursor.index;
1606
1827
  const scope = new Set<string>();
1607
1828
  proofScopes.push(scope);
1608
1829
  const body: StepBody = accept("QED") ? { kind: "Qed" } : parseStepBody();
1609
1830
  const head = getRange(start);
1831
+ const statement = getRange(statementStart);
1610
1832
  const hasProof = isProofStart(peek());
1611
1833
  if (hasProof && !PROVABLE_STEPS.has(body.kind)) {
1612
1834
  throw createError("Proof of a step that does not take a proof");
@@ -1614,7 +1836,7 @@ const parse = (source: string, isTlapm: boolean): Module => {
1614
1836
  const proof = hasProof ? parseProof() : undefined;
1615
1837
  proofScopes.pop();
1616
1838
  if (body.kind !== "Assert" || body.isSuffices) scope.forEach(declareProofSymbol);
1617
- return withRange({ ...step, body, head, proof }, start);
1839
+ return withRange({ ...step, body, head, statement, proof }, start);
1618
1840
  };
1619
1841
 
1620
1842
  const parseProofBody = (): Proof => {
@@ -1649,6 +1871,13 @@ const parse = (source: string, isTlapm: boolean): Module => {
1649
1871
  return withRange(proof, start);
1650
1872
  };
1651
1873
 
1874
+ // SANY binds the name of a theorem or assumption that a module already defines to the first
1875
+ // definition, warning of the second.
1876
+ const addFactDefinition = (module: Module, definition: Definition) => {
1877
+ if (module.definitions.some((other) => other.name === definition.name)) return;
1878
+ module.definitions.push(definition);
1879
+ };
1880
+
1652
1881
  const parseTheorem = (module: Module) => {
1653
1882
  const start = cursor.index;
1654
1883
  const keyword = advance();
@@ -1670,7 +1899,8 @@ const parse = (source: string, isTlapm: boolean): Module => {
1670
1899
  module.theorems.push(theorem);
1671
1900
  module.units.push({ kind: "Theorem", theorem });
1672
1901
  if (name === undefined || statement.kind === "AssumeProve") return;
1673
- module.definitions.push(
1902
+ addFactDefinition(
1903
+ module,
1674
1904
  withRange(
1675
1905
  {
1676
1906
  kind: "Operator",
@@ -1707,7 +1937,7 @@ const parse = (source: string, isTlapm: boolean): Module => {
1707
1937
  const parseModuleBody = (): Module => {
1708
1938
  const location = getLocation(expect("----"));
1709
1939
  expect("MODULE");
1710
- const name = expectIdentifier();
1940
+ const name = expectModuleName();
1711
1941
  expect("----");
1712
1942
  const module: Module = {
1713
1943
  name,
@@ -1729,7 +1959,7 @@ const parse = (source: string, isTlapm: boolean): Module => {
1729
1959
  if (accept("EXTENDS")) {
1730
1960
  parseSeparated(() => {
1731
1961
  const start = cursor.index;
1732
- module.extends.push(expectIdentifier());
1962
+ module.extends.push(expectModuleName());
1733
1963
  module.extendsRanges.push(getRange(start));
1734
1964
  });
1735
1965
  }
@@ -1737,15 +1967,12 @@ const parse = (source: string, isTlapm: boolean): Module => {
1737
1967
  const tokenIndex = cursor.index;
1738
1968
  unitStart.index = tokenIndex;
1739
1969
  const token = peek();
1740
- if (token.kind === "ModuleEnd" || token.kind === "End") {
1741
- if (token.kind === "ModuleEnd") {
1742
- location.range = {
1743
- module: name,
1744
- start: { line: location.line, column: location.column },
1745
- end: { line: token.line, column: token.endColumn },
1746
- };
1747
- }
1748
- if (missingArguments.size > 0) throw createSanyError([...missingArguments.values()]);
1970
+ if (token.kind === "ModuleEnd") {
1971
+ location.range = {
1972
+ module: openModules[0].name,
1973
+ start: { line: location.line, column: location.column },
1974
+ end: { line: token.line, column: token.endColumn },
1975
+ };
1749
1976
  openModules.pop();
1750
1977
  recursiveScopes.pop();
1751
1978
  return module;
@@ -1764,22 +1991,24 @@ const parse = (source: string, isTlapm: boolean): Module => {
1764
1991
  switch (token.text) {
1765
1992
  case "CONSTANT":
1766
1993
  case "CONSTANTS": {
1767
- advance();
1994
+ const unitLocation = getLocation(advance());
1768
1995
  const declarations = parseDeclarations();
1769
1996
  module.constants.push(...declarations);
1770
- module.units.push({ kind: "Constants", declarations });
1997
+ unitLocation.range = getRange(tokenIndex);
1998
+ module.units.push({ kind: "Constants", declarations, location: unitLocation });
1771
1999
  continue;
1772
2000
  }
1773
2001
  case "VARIABLE":
1774
2002
  case "VARIABLES": {
1775
- advance();
2003
+ const unitLocation = getLocation(advance());
1776
2004
  const declarations = parseSeparated(() => {
1777
2005
  const start = cursor.index;
1778
2006
  const location = getLocation(peek());
1779
2007
  return withRange({ name: expectIdentifier(), arity: 0, location }, start);
1780
2008
  });
1781
2009
  module.variables.push(...declarations);
1782
- module.units.push({ kind: "Variables", declarations });
2010
+ unitLocation.range = getRange(tokenIndex);
2011
+ module.units.push({ kind: "Variables", declarations, location: unitLocation });
1783
2012
  continue;
1784
2013
  }
1785
2014
  case "ASSUME":
@@ -1789,7 +2018,7 @@ const parse = (source: string, isTlapm: boolean): Module => {
1789
2018
  module.assumptions.push(assumption);
1790
2019
  module.units.push({ kind: "Assumption", assumption });
1791
2020
  if (assumption.name !== undefined) {
1792
- module.definitions.push({
2021
+ addFactDefinition(module, {
1793
2022
  kind: "Operator",
1794
2023
  name: assumption.name,
1795
2024
  params: [],
@@ -1803,6 +2032,10 @@ const parse = (source: string, isTlapm: boolean): Module => {
1803
2032
  }
1804
2033
  case "USE":
1805
2034
  case "HIDE": {
2035
+ // SANY's module body takes a USE only when ONLY doesn't follow it.
2036
+ if (isAt("USE") && isAt("ONLY", 1)) {
2037
+ throw createUnexpected(`Expected a module unit but found ${describe(token)}`);
2038
+ }
1806
2039
  const use = parseUseOrHide();
1807
2040
  module.uses.push(use);
1808
2041
  module.units.push({ kind: "Use", use });
@@ -1827,7 +2060,7 @@ const parse = (source: string, isTlapm: boolean): Module => {
1827
2060
  );
1828
2061
  continue;
1829
2062
  }
1830
- addDefinitionUnit(module, parseDefinition(true));
2063
+ addDefinitionUnit(module, withRange(parseDefinitionUnit(true), tokenIndex));
1831
2064
  continue;
1832
2065
  }
1833
2066
  }
@@ -1849,9 +2082,16 @@ const parse = (source: string, isTlapm: boolean): Module => {
1849
2082
  module.units.push({ kind: "Definition", definition: unit });
1850
2083
  };
1851
2084
 
1852
- return parseModuleBody();
2085
+ const module = parseModuleBody();
2086
+ // SANY's lexer marks where each definition begins before its parser runs, which can split a
2087
+ // module's name from a keyword that the parser would take for one.
2088
+ const sanyError = keywordModuleName.isUsed ? getSanyParseError(source) : undefined;
2089
+ if (sanyError !== undefined) throw new TlaSyntaxError(sanyError);
2090
+ return module;
1853
2091
  };
1854
2092
 
1855
- export const parseModule = (source: string) => parse(source, false);
2093
+ export const parseModule = (source: string) => parse(source, "tlc");
2094
+
2095
+ export const parseTlapmModule = (source: string) => parse(source, "tlapm");
1856
2096
 
1857
- export const parseTlapmModule = (source: string) => parse(source, true);
2097
+ export const parseSanyModule = (source: string) => parse(source, "sany");