tla-ts 0.0.3-dev.52c5b61 → 0.0.3-dev.596cd91

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 (83) hide show
  1. package/README.md +12 -12
  2. package/dist/cli.cjs +1 -1
  3. package/dist/cli.js +1 -1
  4. package/dist/index.cjs +1 -1
  5. package/dist/index.d.cts +150 -8
  6. package/dist/index.d.ts +150 -8
  7. package/dist/index.js +1 -1
  8. package/dist/parallel-worker.cjs +1 -1
  9. package/dist/parallel-worker.js +2 -2
  10. package/dist/parallel.cjs +1 -1
  11. package/dist/parallel.js +2 -2
  12. package/dist/run-cli.cjs +45 -19
  13. package/dist/run-cli.js +45 -19
  14. package/dist/transfer.cjs +1391 -28
  15. package/dist/transfer.js +1391 -28
  16. package/package.json +5 -1
  17. package/src/ast.ts +57 -6
  18. package/src/bags.ts +4 -7
  19. package/src/builtins.ts +29 -11
  20. package/src/bundled-modules.ts +3 -3
  21. package/src/canonical.ts +4 -3
  22. package/src/check.ts +1396 -227
  23. package/src/cli.ts +8 -1
  24. package/src/codegen.ts +68 -18
  25. package/src/config.ts +254 -181
  26. package/src/environment.ts +494 -129
  27. package/src/errors.ts +217 -3
  28. package/src/evaluate.ts +722 -112
  29. package/src/exit-codes.ts +5 -4
  30. package/src/index.ts +1 -0
  31. package/src/instances.ts +4 -2
  32. package/src/java-overrides.ts +104 -25
  33. package/src/levels.ts +183 -37
  34. package/src/lexer.ts +122 -29
  35. package/src/live-check.ts +220 -102
  36. package/src/liveness.ts +216 -52
  37. package/src/obligation-expression.ts +2 -2
  38. package/src/obligation-source.ts +2 -0
  39. package/src/parallel-worker.ts +8 -3
  40. package/src/parallel.ts +56 -5
  41. package/src/parser.ts +445 -147
  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 +1465 -411
  49. package/src/run-cli.ts +1179 -155
  50. package/src/runtime.ts +18 -0
  51. package/src/sany-builtins.ts +147 -0
  52. package/src/sany-generator.ts +3128 -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 +356 -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 +26 -7
  64. package/src/standard-modules.ts +200 -148
  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 +38 -17
  69. package/src/successors.ts +207 -103
  70. package/src/symmetry.ts +180 -52
  71. package/src/tableau.ts +54 -25
  72. package/src/tlc-ext.ts +13 -17
  73. package/src/tlc-messages.ts +329 -0
  74. package/src/tlc-module.ts +49 -15
  75. package/src/tlc-modules.ts +4 -0
  76. package/src/tlc-order.ts +61 -7
  77. package/src/tlc-random.ts +37 -9
  78. package/src/tlc-replay.ts +655 -0
  79. package/src/tlc-summary.ts +20 -5
  80. package/src/tlc-version.ts +18 -0
  81. package/src/transfer.ts +15 -3
  82. package/src/value-sources.ts +29 -0
  83. package/src/values.ts +713 -180
package/src/parser.ts CHANGED
@@ -22,15 +22,30 @@ import type {
22
22
  StepBody,
23
23
  UseOrHide,
24
24
  } from "./ast";
25
- import { TlaSyntaxError } from "./errors";
26
- import { getNumeralValue, tokenize, type Token } from "./lexer";
25
+ import { createSanyError, formatRange, TlaSyntaxError } from "./errors";
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,32 +699,52 @@ 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, spelling: token.spelling, 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
736
  return parseExpression();
632
737
  };
633
738
 
739
+ const lastArguments: { range: SourceRange | undefined } = { range: undefined };
740
+
634
741
  const parseArguments = () =>
635
- withoutOffside(() => {
742
+ withBracketLayout(() => {
743
+ const start = cursor.index;
636
744
  expect("(");
637
745
  const args = parseSeparated(parseArgument);
638
746
  expect(")");
747
+ lastArguments.range = getRange(start);
639
748
  return args;
640
749
  });
641
750
 
@@ -657,15 +766,25 @@ const parse = (source: string, isTlapm: boolean): Module => {
657
766
  };
658
767
 
659
768
  const parseBracket = (start: Token): Expression =>
660
- withoutOffside(() => {
769
+ withBracketLayout(() => {
661
770
  const location = getLocation(start);
662
- if (peek().kind === "Identifier" && (isAt("|->", 1) || isAt(":", 1))) {
663
- const kind = isAt("|->", 1) ? "Record" : "RecordSet";
664
- const fields = parseSeparated(() => {
665
- const name = expectIdentifier();
666
- expect(kind === "Record" ? "|->" : ":");
667
- return { name, value: parseExpression() };
668
- });
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) => {
777
+ const fieldStart = cursor.index;
778
+ const fieldLocation = getLocation(peek());
779
+ const name = readName();
780
+ fieldLocation.range = getRange(fieldStart);
781
+ expect(isRecord ? "|->" : ":");
782
+ return { name, value: parseExpression(), location: fieldLocation };
783
+ };
784
+ const fields = [
785
+ parseField(() => (isIdentifier ? expectIdentifier() : advance().text)),
786
+ ...(accept(",") ? parseSeparated(() => parseField(expectIdentifier)) : []),
787
+ ];
669
788
  expect("]");
670
789
  return { kind, fields, location };
671
790
  }
@@ -703,17 +822,29 @@ const parse = (source: string, isTlapm: boolean): Module => {
703
822
  expect("]");
704
823
  return { kind: "Except", function: expression, updates, location };
705
824
  }
825
+ if (!isTlapm && !isAt("]_")) {
826
+ const args = [expression];
827
+ while (accept(",")) args.push(parseExpression());
828
+ expect("]");
829
+ return { kind: "Bracket", args, location };
830
+ }
706
831
  expect("]_");
707
- return {
708
- kind: "BoxAction",
709
- action: expression,
710
- subscript: parseSubscript(),
711
- location,
712
- };
832
+ return { kind: "BoxAction", action: expression, subscript: parseSubscript(), location };
713
833
  });
714
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
+
715
846
  const parseBrace = (start: Token): Expression =>
716
- withoutOffside(() => {
847
+ withBracketLayout(() => {
717
848
  const location = getLocation(start);
718
849
  if (accept("}")) return { kind: "SetEnumeration", elements: [], location };
719
850
  if (isBoundAhead() && (peek(1).text === "\\in" || isAt("<<"))) {
@@ -728,7 +859,8 @@ const parse = (source: string, isTlapm: boolean): Module => {
728
859
  }
729
860
  cursor.index = checkpoint;
730
861
  }
731
- const first = parseExpression();
862
+ const first =
863
+ peek().kind === "Identifier" && isAt("\\in", 1) ? parseSetMembership() : parseExpression();
732
864
  if (accept(":")) {
733
865
  const bounds = parseBounds();
734
866
  expect("}");
@@ -742,7 +874,7 @@ const parse = (source: string, isTlapm: boolean): Module => {
742
874
 
743
875
  const parseTuple = (start: Token): Expression => {
744
876
  const location = getLocation(start);
745
- const elements = withoutOffside(() =>
877
+ const elements = withBracketLayout(() =>
746
878
  isAt(">>") || isAt(">>_") ? [] : parseSeparated(() => parseExpression()),
747
879
  );
748
880
  if (accept(">>_")) {
@@ -763,12 +895,13 @@ const parse = (source: string, isTlapm: boolean): Module => {
763
895
  expect(":");
764
896
  return { kind, bounds, body: parseExpression(), location };
765
897
  }
766
- const names = parseSeparated(expectIdentifier);
898
+ const names = getNames(parseSeparated(expectName));
767
899
  expect(":");
768
900
  return {
769
901
  kind: "UnboundedQuantifier",
770
902
  quantifier: start.text === "\\A" || start.text === "\\AA" ? "Forall" : "Exists",
771
- names,
903
+ names: names.names,
904
+ nameRanges: names.ranges,
772
905
  body: parseExpression(),
773
906
  isTemporal,
774
907
  location,
@@ -822,8 +955,8 @@ const parse = (source: string, isTlapm: boolean): Module => {
822
955
  return { kind: "Name", name: token.text, args: isAt("(") ? parseArguments() : [] };
823
956
  };
824
957
 
825
- const parsePrimary = (): Expression => {
826
- const isFactStart = cursor.index === factStart.index;
958
+ const parsePrimary = (preceding?: Precedence): Expression => {
959
+ const start = cursor.index;
827
960
  const token = advance();
828
961
  const location = getLocation(token);
829
962
  if (isTlapm && token.kind === "Keyword" && token.text === "LAMBDA") {
@@ -847,53 +980,100 @@ const parse = (source: string, isTlapm: boolean): Module => {
847
980
  if (token.kind === "Identifier" || isStep) {
848
981
  const name = isStep ? (getStepName(token) ?? token.text) : token.text;
849
982
  if (isLabelAhead()) {
850
- const params = accept("(") ? parseSeparated(expectIdentifier) : [];
851
- if (params.length > 0) expect(")");
983
+ const params = getNames(accept("(") ? parseSeparated(expectName) : []);
984
+ if (params.names.length > 0) expect(")");
852
985
  expect("::");
853
- 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
+ };
854
1005
  }
855
1006
  const hasArguments = isAt("(");
1007
+ if (name === "@" && !hasArguments && !isSelectorAhead())
1008
+ return { kind: "ExceptAt", location };
856
1009
  const args = hasArguments ? parseArguments() : [];
1010
+ const argumentRanges = [hasArguments ? lastArguments.range : undefined];
857
1011
  if (!isSelectorAhead()) {
858
1012
  return hasArguments
859
- ? { kind: "Apply", operator: name, args, location }
1013
+ ? { kind: "Apply", operator: name, args, argumentsRange: lastArguments.range, location }
860
1014
  : { kind: "Identifier", name, location };
861
1015
  }
862
- const instance = openModules
863
- .flatMap((module) => module.instances)
864
- .find((candidate) => candidate.name === name);
865
- if (instance && !isFactStart && !isTlapm && instance.params.length !== args.length) {
866
- throw createError(
867
- `The operator ${name} requires ${instance.params.length} arguments`,
868
- token,
869
- );
870
- }
871
1016
  const selectors: Selector[] = [{ kind: "Name", name, args }];
1017
+ const selectorRanges = [getRange(start, start)];
872
1018
  while (isSelectorAhead()) {
873
1019
  advance();
1020
+ selectorRanges.push(getRange(cursor.index, cursor.index));
1021
+ lastArguments.range = undefined;
874
1022
  selectors.push(parseSelector());
1023
+ argumentRanges.push(lastArguments.range);
875
1024
  }
876
1025
  const names = selectors.flatMap((selector) =>
877
1026
  selector.kind === "Name" ? [selector.name] : [],
878
1027
  );
879
- if (names.length < selectors.length) return { kind: "Subexpression", selectors, location };
880
1028
  const operator = names.join("!");
881
1029
  const qualifiedArgs = selectors.flatMap((selector) =>
882
1030
  "args" in selector ? selector.args : [],
883
1031
  );
884
- if (qualifiedArgs.length === 0) return { kind: "Identifier", name: operator, location };
885
1032
  const argumentCounts = selectors.map((selector) =>
886
1033
  "args" in selector ? selector.args.length : 0,
887
1034
  );
888
- return argumentCounts.slice(0, -1).some((count) => count > 0)
889
- ? { kind: "Apply", operator, args: qualifiedArgs, argumentCounts, location }
890
- : { kind: "Apply", operator, args: qualifiedArgs, location };
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
+ };
1060
+ }
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("(")) {
1063
+ return {
1064
+ kind: "Apply",
1065
+ operator: token.text,
1066
+ spelling: token.spelling,
1067
+ args: parseArguments(),
1068
+ location,
1069
+ };
1070
+ }
1071
+ if (token.kind === "Operator" && isOperatorName(token.text) && !isTlapm) {
1072
+ return { kind: "Identifier", name: token.text, spelling: token.spelling, location };
891
1073
  }
892
- if (token.kind === "Operator" && isOperatorName(token.text) && isAt("("))
893
- return { kind: "Apply", operator: token.text, args: parseArguments(), location };
894
1074
  switch (token.text) {
895
1075
  case "(": {
896
- const expression = withoutOffside(() => parseExpression());
1076
+ const expression = withBracketLayout(() => parseExpression());
897
1077
  expect(")");
898
1078
  return expression;
899
1079
  }
@@ -949,7 +1129,7 @@ const parse = (source: string, isTlapm: boolean): Module => {
949
1129
  case "WF_":
950
1130
  case "SF_": {
951
1131
  const subscript = parseSubscript();
952
- const action = withoutOffside(() => {
1132
+ const action = withBracketLayout(() => {
953
1133
  expect("(");
954
1134
  const expression = parseExpression();
955
1135
  expect(")");
@@ -966,7 +1146,25 @@ const parse = (source: string, isTlapm: boolean): Module => {
966
1146
  throw createUnexpected(`Unexpected ${describe(token)}`, token);
967
1147
  };
968
1148
 
1149
+ // SANY rejects the operator after a prefix operator's operand unless it binds looser than the
1150
+ // prefix operator.
1151
+ const parsePrefixOperand = (operator: Token, low: number, high: number) => {
1152
+ operators.last = operators.preceding = { low, high };
1153
+ const operand = parseExpression(high + 1);
1154
+ const next = peek();
1155
+ const nextHigh =
1156
+ next.text === "'" || POSTFIX_OPERATORS.has(next.text)
1157
+ ? POSTFIX_PRECEDENCE.high
1158
+ : INFIX_OPERATORS.get(next.text)?.high;
1159
+ if (!isTlapm && next.kind === "Operator" && nextHigh !== undefined && nextHigh >= low) {
1160
+ throw createError(`Precedence conflict between ${operator.text} and ${next.text}`, next);
1161
+ }
1162
+ return operand;
1163
+ };
1164
+
969
1165
  const parsePrefix = (): Expression => {
1166
+ const preceding = operators.preceding;
1167
+ operators.preceding = undefined;
970
1168
  const token = peek();
971
1169
  const location = getLocation(token);
972
1170
  if (token.kind === "Operator" && (token.text === "/\\" || token.text === "\\/")) {
@@ -976,35 +1174,46 @@ const parse = (source: string, isTlapm: boolean): Module => {
976
1174
  switch (token.text) {
977
1175
  case "~":
978
1176
  advance();
979
- return { kind: "Apply", operator: "~", args: [parseExpression(5)], location };
1177
+ return {
1178
+ kind: "Apply",
1179
+ operator: "~",
1180
+ args: [parsePrefixOperand(token, 4, 4)],
1181
+ location,
1182
+ };
980
1183
  case "-":
981
1184
  advance();
982
1185
  return {
983
1186
  kind: "Apply",
984
1187
  operator: "-.",
985
- args: [parseExpression(NEGATION_PRECEDENCE + 1)],
1188
+ args: [parsePrefixOperand(token, NEGATION_PRECEDENCE, NEGATION_PRECEDENCE)],
986
1189
  location,
987
1190
  };
988
1191
  case "[]":
989
1192
  advance();
990
- return { kind: "Always", expression: parseExpression(16), location };
1193
+ return { kind: "Always", expression: parsePrefixOperand(token, 4, 15), location };
991
1194
  case "<>":
992
1195
  advance();
993
- return { kind: "Eventually", expression: parseExpression(16), location };
1196
+ return { kind: "Eventually", expression: parsePrefixOperand(token, 4, 15), location };
994
1197
  case "ENABLED":
995
1198
  advance();
996
- return { kind: "Enabled", expression: parseExpression(16), location };
1199
+ return { kind: "Enabled", expression: parsePrefixOperand(token, 4, 15), location };
997
1200
  case "UNCHANGED":
998
1201
  advance();
999
- return { kind: "Unchanged", expression: parseExpression(16), location };
1202
+ return { kind: "Unchanged", expression: parsePrefixOperand(token, 4, 15), location };
1000
1203
  case "SUBSET":
1001
1204
  case "UNION":
1002
1205
  case "DOMAIN":
1003
1206
  advance();
1004
- return { kind: "Apply", operator: token.text, args: [parseExpression(9)], location };
1207
+ return {
1208
+ kind: "Apply",
1209
+ operator: token.text,
1210
+ // tlapm gives these operators the precedence 8 of the TLA+ book, and SANY 10-13.
1211
+ args: [isTlapm ? parseExpression(9) : parsePrefixOperand(token, 10, 13)],
1212
+ location,
1213
+ };
1005
1214
  }
1006
1215
  }
1007
- return parsePrimary();
1216
+ return parsePrimary(preceding);
1008
1217
  };
1009
1218
 
1010
1219
  const parseExpression = (minimumPrecedence = 0): Expression => {
@@ -1020,21 +1229,30 @@ const parse = (source: string, isTlapm: boolean): Module => {
1020
1229
  const location = getLocation(token);
1021
1230
  if (token.text === "'" && minimumPrecedence <= 15) {
1022
1231
  advance();
1232
+ operators.last = POSTFIX_PRECEDENCE;
1023
1233
  state.left = withRange({ kind: "Prime", expression: state.left, location }, start);
1024
1234
  continue;
1025
1235
  }
1026
1236
  if (POSTFIX_OPERATORS.has(token.text) && minimumPrecedence <= 15) {
1027
1237
  advance();
1238
+ operators.last = POSTFIX_PRECEDENCE;
1028
1239
  state.left = withRange(
1029
- { kind: "Apply", operator: token.text, args: [state.left], location },
1240
+ {
1241
+ kind: "Apply",
1242
+ operator: token.text,
1243
+ spelling: token.spelling,
1244
+ args: [state.left],
1245
+ location,
1246
+ },
1030
1247
  start,
1031
1248
  );
1032
1249
  continue;
1033
1250
  }
1034
1251
  if (token.text === "[") {
1035
1252
  advance();
1036
- const args = withoutOffside(() => parseSeparated(() => parseExpression()));
1037
- withoutOffside(() => expect("]"));
1253
+ const args = withBracketLayout(() => parseSeparated(() => parseExpression()));
1254
+ withBracketLayout(() => expect("]"));
1255
+ operators.last = FUNCTION_PRECEDENCE;
1038
1256
  state.left = withRange(
1039
1257
  { kind: "FunctionApplication", function: state.left, args, location },
1040
1258
  start,
@@ -1065,21 +1283,33 @@ const parse = (source: string, isTlapm: boolean): Module => {
1065
1283
  if (infix.low > NEGATION_PRECEDENCE && isAt("-")) {
1066
1284
  throw createError(`Precedence conflict between ${token.text} and -`, peek());
1067
1285
  }
1286
+ operators.last = operators.preceding = infix;
1068
1287
  const right = parseExpression(infix.high + 1);
1069
1288
  const left = state.left;
1070
1289
  if (token.text === "/\\" || token.text === "\\/") {
1071
1290
  const kind = token.text === "/\\" ? "And" : "Or";
1291
+ const prefixEnds = [getRange(start).end];
1072
1292
  state.left =
1073
1293
  left.kind === kind && previous?.text === token.text
1074
- ? { ...left, operands: [...left.operands, right] }
1075
- : { kind, operands: [left, right], location };
1294
+ ? {
1295
+ ...left,
1296
+ operands: [...left.operands, right],
1297
+ prefixEnds: [...(left.prefixEnds ?? []), ...prefixEnds],
1298
+ }
1299
+ : { kind, operands: [left, right], prefixEnds, location };
1076
1300
  } else if (token.text === "\\X") {
1077
1301
  state.left =
1078
1302
  left.kind === "Product" && previous?.text === "\\X"
1079
1303
  ? { ...left, factors: [...left.factors, right] }
1080
1304
  : { kind: "Product", factors: [left, right], location };
1081
1305
  } else {
1082
- state.left = { kind: "Apply", operator: token.text, args: [left, right], location };
1306
+ state.left = {
1307
+ kind: "Apply",
1308
+ operator: token.text,
1309
+ spelling: token.spelling,
1310
+ args: [left, right],
1311
+ location,
1312
+ };
1083
1313
  }
1084
1314
  state.left = withRange(state.left, start);
1085
1315
  state.previous = { ...infix, text: token.text };
@@ -1099,7 +1329,7 @@ const parse = (source: string, isTlapm: boolean): Module => {
1099
1329
  const body = parseExpression();
1100
1330
  const last = tokens[cursor.index - 1];
1101
1331
  const end = { line: last.line, column: last.endColumn };
1102
- return { body, bodyRange: { module: openModules[openModules.length - 1].name, start, end } };
1332
+ return { body, bodyRange: { module: openModules[0].name, start, end } };
1103
1333
  };
1104
1334
 
1105
1335
  const parseDefinition = (isLocal: boolean): Definition | Instance => {
@@ -1107,6 +1337,16 @@ const parse = (source: string, isTlapm: boolean): Module => {
1107
1337
  return withRange(parseDefinitionUnit(isLocal), start);
1108
1338
  };
1109
1339
 
1340
+ const toParam = (named: { name: string; range: SourceRange }): OperatorParam => ({
1341
+ name: named.name,
1342
+ arity: 0,
1343
+ location: {
1344
+ line: named.range.start.line,
1345
+ column: named.range.start.column,
1346
+ range: named.range,
1347
+ },
1348
+ });
1349
+
1110
1350
  const parseDefinitionUnit = (isLocal: boolean): Definition | Instance => {
1111
1351
  const token = peek();
1112
1352
  const location = getLocation(token);
@@ -1126,28 +1366,27 @@ const parse = (source: string, isTlapm: boolean): Module => {
1126
1366
  peek(2).kind === "Identifier" &&
1127
1367
  isAt("==", 3)
1128
1368
  ) {
1129
- const left = expectIdentifier();
1369
+ const left = expectName();
1130
1370
  const operator = advance().text;
1131
- const right = expectIdentifier();
1371
+ const right = expectName();
1132
1372
  expect("==");
1133
- return parseOperator(operator, [
1134
- { name: left, arity: 0 },
1135
- { name: right, arity: 0 },
1136
- ]);
1373
+ return parseOperator(operator, [toParam(left), toParam(right)]);
1137
1374
  }
1138
- const isPrefixDefinition = token.kind === "Operator" && token.text === "-.";
1375
+ const isPrefixDefinition =
1376
+ token.kind !== "String" && DEFINABLE_PREFIX_OPERATORS.has(token.text);
1139
1377
  const isPostfixDefinition =
1140
1378
  token.kind === "Identifier" && POSTFIX_OPERATORS.has(peek(1).text) && isAt("==", 2);
1141
1379
  if (isPrefixDefinition || isPostfixDefinition) {
1142
1380
  const operator = isPrefixDefinition ? token.text : peek(1).text;
1143
- cursor.index += isPrefixDefinition ? 1 : 2;
1144
- const param = isPrefixDefinition ? expectIdentifier() : token.text;
1381
+ if (isPrefixDefinition) advance();
1382
+ const param = expectName();
1383
+ if (isPostfixDefinition) advance();
1145
1384
  expect("==");
1146
- return parseOperator(operator, [{ name: param, arity: 0 }]);
1385
+ return parseOperator(operator, [toParam(param)]);
1147
1386
  }
1148
1387
  const name = expectIdentifier();
1149
1388
  if (accept("[")) {
1150
- const bounds = withoutOffside(() => parseBounds());
1389
+ const bounds = withBracketLayout(() => parseBounds());
1151
1390
  expect("]");
1152
1391
  expect("==");
1153
1392
  return {
@@ -1178,12 +1417,14 @@ const parse = (source: string, isTlapm: boolean): Module => {
1178
1417
  ): Instance => {
1179
1418
  const start = cursor.index;
1180
1419
  expect("INSTANCE");
1181
- const module = expectIdentifier();
1420
+ const module = expectModuleName();
1182
1421
  const substitutions = accept("WITH")
1183
1422
  ? parseSeparated(() => {
1184
- const target = advance().text;
1423
+ const targetStart = cursor.index;
1424
+ const target = expectSubstitutionTarget();
1425
+ const nameRange = getRange(targetStart);
1185
1426
  expect("<-");
1186
- return { name: target, expression: parseArgument() };
1427
+ return { name: target, nameRange, expression: parseArgument() };
1187
1428
  })
1188
1429
  : [];
1189
1430
  return {
@@ -1199,6 +1440,11 @@ const parse = (source: string, isTlapm: boolean): Module => {
1199
1440
  };
1200
1441
 
1201
1442
  const parseDeclaration = (): Declaration => {
1443
+ const start = cursor.index;
1444
+ return withRange(parseDeclarationUnit(), start);
1445
+ };
1446
+
1447
+ const parseDeclarationUnit = (): Declaration => {
1202
1448
  const location = getLocation(peek());
1203
1449
  if (isAt("_") && peek(1).kind === "Operator") {
1204
1450
  advance();
@@ -1244,7 +1490,12 @@ const parse = (source: string, isTlapm: boolean): Module => {
1244
1490
  const token = peek();
1245
1491
  const next = peek(1);
1246
1492
  if (token.kind !== "Identifier") {
1247
- return isAt("-.") && next.kind === "Identifier" && isAt("==", 2);
1493
+ return (
1494
+ token.kind !== "String" &&
1495
+ DEFINABLE_PREFIX_OPERATORS.has(token.text) &&
1496
+ next.kind === "Identifier" &&
1497
+ isAt("==", 2)
1498
+ );
1248
1499
  }
1249
1500
  if (isAt("(", 1) || isAt("[", 1)) return isAt("==", getClosingOffset(1));
1250
1501
  if (next.kind === "Operator" && POSTFIX_OPERATORS.has(next.text)) return isAt("==", 2);
@@ -1336,7 +1587,6 @@ const parse = (source: string, isTlapm: boolean): Module => {
1336
1587
  // start of an expression.
1337
1588
  const parseFact = (): Fact => {
1338
1589
  const start = cursor.index;
1339
- factStart.index = start;
1340
1590
  const token = peek();
1341
1591
  if (
1342
1592
  token.kind === "Operator" &&
@@ -1345,7 +1595,12 @@ const parse = (source: string, isTlapm: boolean): Module => {
1345
1595
  ) {
1346
1596
  cursor.index++;
1347
1597
  return withRange(
1348
- { kind: "OperatorReference", operator: token.text, location: getLocation(token) },
1598
+ {
1599
+ kind: "OperatorReference",
1600
+ operator: token.text,
1601
+ spelling: token.spelling,
1602
+ location: getLocation(token),
1603
+ },
1349
1604
  start,
1350
1605
  );
1351
1606
  }
@@ -1398,7 +1653,10 @@ const parse = (source: string, isTlapm: boolean): Module => {
1398
1653
  const parseDefs = () => {
1399
1654
  if (isTlapm) return parseSeparated(parseDefinable);
1400
1655
  const defs = parseSeparated(parseFact);
1401
- const invalid = defs.find((def) => def.kind === "Identifier" && isDeclaredSymbol(def.name));
1656
+ const invalid =
1657
+ mode === "tlc"
1658
+ ? defs.find((def) => def.kind === "Identifier" && isDeclaredSymbol(def.name))
1659
+ : undefined;
1402
1660
  if (invalid) {
1403
1661
  throw createError("DEF clause entry should describe a defined operator", invalid.location);
1404
1662
  }
@@ -1423,11 +1681,14 @@ const parse = (source: string, isTlapm: boolean): Module => {
1423
1681
  location: getLocation(keyword),
1424
1682
  };
1425
1683
  const invalid =
1426
- use.kind === "Hide" && !isTlapm ? use.facts.find((fact) => !isHideFact(fact)) : undefined;
1427
- if (invalid) {
1428
- throw createError(
1429
- "The only expression allowed as a fact in a HIDE is the name of a theorem, assumption, or step",
1430
- invalid.location,
1684
+ use.kind === "Hide" && mode === "tlc" ? use.facts.filter((fact) => !isHideFact(fact)) : [];
1685
+ if (invalid.length > 0) {
1686
+ throw createSanyError(
1687
+ invalid.map((fact) => ({
1688
+ location: formatRange(fact.location.range ?? getRange(start)),
1689
+ message:
1690
+ "The only expression allowed as a fact in a HIDE is \nthe name of a theorem, assumption, or step.",
1691
+ })),
1431
1692
  );
1432
1693
  }
1433
1694
  return withRange(use, start);
@@ -1443,10 +1704,18 @@ const parse = (source: string, isTlapm: boolean): Module => {
1443
1704
  }
1444
1705
  if (level !== undefined) advance();
1445
1706
  if (level === "Variable") {
1446
- const name = expectIdentifier();
1447
- declareProofSymbol(name);
1707
+ const named = expectName();
1708
+ declareProofSymbol(named.name);
1448
1709
  return withRange(
1449
- { kind: "NewSymbol", name, arity: 0, level, set: undefined, location },
1710
+ {
1711
+ kind: "NewSymbol",
1712
+ name: named.name,
1713
+ arity: 0,
1714
+ level,
1715
+ set: undefined,
1716
+ nameRange: named.range,
1717
+ location,
1718
+ },
1450
1719
  start,
1451
1720
  );
1452
1721
  }
@@ -1464,6 +1733,7 @@ const parse = (source: string, isTlapm: boolean): Module => {
1464
1733
  arity: declaration.arity,
1465
1734
  level: level ?? "Constant",
1466
1735
  set: isBounded ? parseExpression() : undefined,
1736
+ nameRange: declaration.location.range,
1467
1737
  location,
1468
1738
  },
1469
1739
  start,
@@ -1506,7 +1776,8 @@ const parse = (source: string, isTlapm: boolean): Module => {
1506
1776
  const token = peek();
1507
1777
  if (isAt("USE") || isAt("HIDE")) return parseUseOrHide();
1508
1778
  if (isAt("INSTANCE")) {
1509
- return withRange(parseInstance(undefined, [], false, getLocation(token)), cursor.index);
1779
+ const start = cursor.index;
1780
+ return withRange(parseInstance(undefined, [], false, getLocation(token)), start);
1510
1781
  }
1511
1782
  if (isAt("DEFINE") || isDefinitionStart()) {
1512
1783
  const start = cursor.index;
@@ -1519,21 +1790,27 @@ const parse = (source: string, isTlapm: boolean): Module => {
1519
1790
  if (accept("HAVE")) return { kind: "Have", expression: parseExpression() };
1520
1791
  if (accept("TAKE")) {
1521
1792
  const isBounded = isBoundAhead();
1522
- const names = isBounded ? [] : parseSeparated(expectIdentifier);
1793
+ const names = getNames(isBounded ? [] : parseSeparated(expectName));
1523
1794
  const bounds = isBounded ? parseBounds() : [];
1524
- declareProofSymbols(names, bounds);
1525
- return { kind: "Take", names, bounds };
1795
+ declareProofSymbols(names.names, bounds);
1796
+ return { kind: "Take", names: names.names, nameRanges: names.ranges, bounds };
1526
1797
  }
1527
1798
  if (accept("WITNESS")) {
1528
1799
  return { kind: "Witness", expressions: parseSeparated(() => parseExpression()) };
1529
1800
  }
1530
1801
  if (accept("PICK")) {
1531
1802
  const isNames = isNameListAhead(":");
1532
- const names = isNames ? parseSeparated(expectIdentifier) : [];
1803
+ const names = getNames(isNames ? parseSeparated(expectName) : []);
1533
1804
  const bounds = isNames ? [] : parseBounds();
1534
- declareProofSymbols(names, bounds);
1805
+ declareProofSymbols(names.names, bounds);
1535
1806
  expect(":");
1536
- return { kind: "Pick", names, bounds, body: parseExpression() };
1807
+ return {
1808
+ kind: "Pick",
1809
+ names: names.names,
1810
+ nameRanges: names.ranges,
1811
+ bounds,
1812
+ body: parseExpression(),
1813
+ };
1537
1814
  }
1538
1815
  if (accept("CASE")) return { kind: "Case", expression: parseExpression() };
1539
1816
  return {
@@ -1563,10 +1840,12 @@ const parse = (source: string, isTlapm: boolean): Module => {
1563
1840
  const parseStep = (): ProofStep => {
1564
1841
  const start = cursor.index;
1565
1842
  const step = parseStepStart(isAt("QED", 1));
1843
+ const statementStart = cursor.index;
1566
1844
  const scope = new Set<string>();
1567
1845
  proofScopes.push(scope);
1568
1846
  const body: StepBody = accept("QED") ? { kind: "Qed" } : parseStepBody();
1569
1847
  const head = getRange(start);
1848
+ const statement = getRange(statementStart);
1570
1849
  const hasProof = isProofStart(peek());
1571
1850
  if (hasProof && !PROVABLE_STEPS.has(body.kind)) {
1572
1851
  throw createError("Proof of a step that does not take a proof");
@@ -1574,7 +1853,7 @@ const parse = (source: string, isTlapm: boolean): Module => {
1574
1853
  const proof = hasProof ? parseProof() : undefined;
1575
1854
  proofScopes.pop();
1576
1855
  if (body.kind !== "Assert" || body.isSuffices) scope.forEach(declareProofSymbol);
1577
- return withRange({ ...step, body, head, proof }, start);
1856
+ return withRange({ ...step, body, head, statement, proof }, start);
1578
1857
  };
1579
1858
 
1580
1859
  const parseProofBody = (): Proof => {
@@ -1609,6 +1888,13 @@ const parse = (source: string, isTlapm: boolean): Module => {
1609
1888
  return withRange(proof, start);
1610
1889
  };
1611
1890
 
1891
+ // SANY binds the name of a theorem or assumption that a module already defines to the first
1892
+ // definition, warning of the second.
1893
+ const addFactDefinition = (module: Module, definition: Definition) => {
1894
+ if (module.definitions.some((other) => other.name === definition.name)) return;
1895
+ module.definitions.push(definition);
1896
+ };
1897
+
1612
1898
  const parseTheorem = (module: Module) => {
1613
1899
  const start = cursor.index;
1614
1900
  const keyword = advance();
@@ -1630,7 +1916,8 @@ const parse = (source: string, isTlapm: boolean): Module => {
1630
1916
  module.theorems.push(theorem);
1631
1917
  module.units.push({ kind: "Theorem", theorem });
1632
1918
  if (name === undefined || statement.kind === "AssumeProve") return;
1633
- module.definitions.push(
1919
+ addFactDefinition(
1920
+ module,
1634
1921
  withRange(
1635
1922
  {
1636
1923
  kind: "Operator",
@@ -1667,7 +1954,7 @@ const parse = (source: string, isTlapm: boolean): Module => {
1667
1954
  const parseModuleBody = (): Module => {
1668
1955
  const location = getLocation(expect("----"));
1669
1956
  expect("MODULE");
1670
- const name = expectIdentifier();
1957
+ const name = expectModuleName();
1671
1958
  expect("----");
1672
1959
  const module: Module = {
1673
1960
  name,
@@ -1689,7 +1976,7 @@ const parse = (source: string, isTlapm: boolean): Module => {
1689
1976
  if (accept("EXTENDS")) {
1690
1977
  parseSeparated(() => {
1691
1978
  const start = cursor.index;
1692
- module.extends.push(expectIdentifier());
1979
+ module.extends.push(expectModuleName());
1693
1980
  module.extendsRanges.push(getRange(start));
1694
1981
  });
1695
1982
  }
@@ -1697,14 +1984,12 @@ const parse = (source: string, isTlapm: boolean): Module => {
1697
1984
  const tokenIndex = cursor.index;
1698
1985
  unitStart.index = tokenIndex;
1699
1986
  const token = peek();
1700
- if (token.kind === "ModuleEnd" || token.kind === "End") {
1701
- if (token.kind === "ModuleEnd") {
1702
- location.range = {
1703
- module: name,
1704
- start: { line: location.line, column: location.column },
1705
- end: { line: token.line, column: token.endColumn },
1706
- };
1707
- }
1987
+ if (token.kind === "ModuleEnd") {
1988
+ location.range = {
1989
+ module: openModules[0].name,
1990
+ start: { line: location.line, column: location.column },
1991
+ end: { line: token.line, column: token.endColumn },
1992
+ };
1708
1993
  openModules.pop();
1709
1994
  recursiveScopes.pop();
1710
1995
  return module;
@@ -1723,22 +2008,24 @@ const parse = (source: string, isTlapm: boolean): Module => {
1723
2008
  switch (token.text) {
1724
2009
  case "CONSTANT":
1725
2010
  case "CONSTANTS": {
1726
- advance();
2011
+ const unitLocation = getLocation(advance());
1727
2012
  const declarations = parseDeclarations();
1728
2013
  module.constants.push(...declarations);
1729
- module.units.push({ kind: "Constants", declarations });
2014
+ unitLocation.range = getRange(tokenIndex);
2015
+ module.units.push({ kind: "Constants", declarations, location: unitLocation });
1730
2016
  continue;
1731
2017
  }
1732
2018
  case "VARIABLE":
1733
2019
  case "VARIABLES": {
1734
- advance();
2020
+ const unitLocation = getLocation(advance());
1735
2021
  const declarations = parseSeparated(() => {
1736
2022
  const start = cursor.index;
1737
2023
  const location = getLocation(peek());
1738
2024
  return withRange({ name: expectIdentifier(), arity: 0, location }, start);
1739
2025
  });
1740
2026
  module.variables.push(...declarations);
1741
- module.units.push({ kind: "Variables", declarations });
2027
+ unitLocation.range = getRange(tokenIndex);
2028
+ module.units.push({ kind: "Variables", declarations, location: unitLocation });
1742
2029
  continue;
1743
2030
  }
1744
2031
  case "ASSUME":
@@ -1748,7 +2035,7 @@ const parse = (source: string, isTlapm: boolean): Module => {
1748
2035
  module.assumptions.push(assumption);
1749
2036
  module.units.push({ kind: "Assumption", assumption });
1750
2037
  if (assumption.name !== undefined) {
1751
- module.definitions.push({
2038
+ addFactDefinition(module, {
1752
2039
  kind: "Operator",
1753
2040
  name: assumption.name,
1754
2041
  params: [],
@@ -1762,6 +2049,10 @@ const parse = (source: string, isTlapm: boolean): Module => {
1762
2049
  }
1763
2050
  case "USE":
1764
2051
  case "HIDE": {
2052
+ // SANY's module body takes a USE only when ONLY doesn't follow it.
2053
+ if (isAt("USE") && isAt("ONLY", 1)) {
2054
+ throw createUnexpected(`Expected a module unit but found ${describe(token)}`);
2055
+ }
1765
2056
  const use = parseUseOrHide();
1766
2057
  module.uses.push(use);
1767
2058
  module.units.push({ kind: "Use", use });
@@ -1786,7 +2077,7 @@ const parse = (source: string, isTlapm: boolean): Module => {
1786
2077
  );
1787
2078
  continue;
1788
2079
  }
1789
- addDefinitionUnit(module, parseDefinition(true));
2080
+ addDefinitionUnit(module, withRange(parseDefinitionUnit(true), tokenIndex));
1790
2081
  continue;
1791
2082
  }
1792
2083
  }
@@ -1808,9 +2099,16 @@ const parse = (source: string, isTlapm: boolean): Module => {
1808
2099
  module.units.push({ kind: "Definition", definition: unit });
1809
2100
  };
1810
2101
 
1811
- return parseModuleBody();
2102
+ const module = parseModuleBody();
2103
+ // SANY's lexer marks where each definition begins before its parser runs, which can split a
2104
+ // module's name from a keyword that the parser would take for one.
2105
+ const sanyError = keywordModuleName.isUsed ? getSanyParseError(source) : undefined;
2106
+ if (sanyError !== undefined) throw new TlaSyntaxError(sanyError);
2107
+ return module;
1812
2108
  };
1813
2109
 
1814
- export const parseModule = (source: string) => parse(source, false);
2110
+ export const parseModule = (source: string) => parse(source, "tlc");
2111
+
2112
+ export const parseTlapmModule = (source: string) => parse(source, "tlapm");
1815
2113
 
1816
- export const parseTlapmModule = (source: string) => parse(source, true);
2114
+ export const parseSanyModule = (source: string) => parse(source, "sany");