tla-ts 0.0.3-dev.f6f300a → 0.0.3-dev.fac17cc
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/cli.cjs +1 -1
- package/dist/cli.js +1 -1
- package/dist/index.cjs +1 -1
- package/dist/index.d.cts +149 -8
- package/dist/index.d.ts +149 -8
- package/dist/index.js +1 -1
- package/dist/parallel-worker.cjs +1 -1
- package/dist/parallel-worker.js +2 -2
- package/dist/parallel.cjs +1 -1
- package/dist/parallel.js +2 -2
- package/dist/run-cli.cjs +1351 -20
- package/dist/run-cli.js +1351 -20
- package/dist/transfer.cjs +82 -27
- package/dist/transfer.js +82 -27
- package/package.json +5 -1
- package/src/ast.ts +56 -6
- package/src/bags.ts +4 -7
- package/src/builtins.ts +29 -11
- package/src/bundled-modules.ts +3 -3
- package/src/canonical.ts +4 -3
- package/src/check.ts +1335 -236
- package/src/cli.ts +8 -1
- package/src/codegen.ts +68 -21
- package/src/config.ts +252 -179
- package/src/environment.ts +431 -120
- package/src/errors.ts +207 -9
- package/src/evaluate.ts +716 -141
- package/src/exit-codes.ts +5 -4
- package/src/index.ts +1 -0
- package/src/instances.ts +4 -2
- package/src/java-overrides.ts +104 -25
- package/src/levels.ts +183 -37
- package/src/lexer.ts +32 -4
- package/src/live-check.ts +204 -146
- package/src/liveness.ts +192 -63
- package/src/obligation-expression.ts +2 -2
- package/src/obligation-source.ts +2 -0
- package/src/parallel-worker.ts +6 -1
- package/src/parallel.ts +57 -6
- package/src/parser.ts +425 -144
- package/src/pcal-ast.ts +770 -0
- package/src/pcal-parse.ts +1523 -0
- package/src/pcal-tokenize.ts +516 -0
- package/src/pcal-translate.ts +1230 -0
- package/src/pcal-validate.ts +454 -0
- package/src/randomization.ts +24 -7
- package/src/resolve.ts +1408 -400
- package/src/run-cli.ts +1167 -155
- package/src/runtime.ts +16 -0
- package/src/sany-builtins.ts +147 -0
- package/src/sany-generator.ts +3112 -0
- package/src/sany-levels.ts +1208 -0
- package/src/sany-lexer.ts +545 -0
- package/src/sany-linter.ts +122 -0
- package/src/sany-modules.ts +1398 -0
- package/src/sany-nodes.ts +463 -0
- package/src/sany-parse-error.ts +2161 -0
- package/src/sany-report.ts +354 -0
- package/src/sany-selectors.ts +738 -0
- package/src/sany-source.ts +248 -0
- package/src/sany-xml.ts +1017 -0
- package/src/spec-description.ts +26 -7
- package/src/standard-modules.ts +203 -146
- package/src/standard-ranges.ts +116 -0
- package/src/state-graph.ts +29 -6
- package/src/subexpressions.ts +221 -161
- package/src/substitution-levels.ts +38 -17
- package/src/successors.ts +162 -114
- package/src/symmetry.ts +168 -50
- package/src/tableau.ts +3 -1
- package/src/tlc-ext.ts +13 -17
- package/src/tlc-messages.ts +329 -0
- package/src/tlc-module.ts +49 -21
- package/src/tlc-modules.ts +0 -4
- package/src/tlc-order.ts +55 -9
- package/src/tlc-random.ts +28 -3
- package/src/tlc-replay.ts +655 -0
- package/src/tlc-version.ts +18 -0
- package/src/transfer.ts +15 -3
- package/src/value-sources.ts +29 -0
- package/src/values.ts +683 -256
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
|
|
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
|
-
|
|
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) =>
|
|
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
|
-
//
|
|
307
|
-
// SANY does not.
|
|
308
|
-
|
|
309
|
-
|
|
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
|
-
//
|
|
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[
|
|
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" ||
|
|
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
|
|
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("<<"))
|
|
518
|
-
|
|
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
|
-
{
|
|
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
|
|
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
|
-
|
|
618
|
-
|
|
619
|
-
|
|
620
|
-
|
|
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(
|
|
722
|
+
const params = getNames(parseSeparated(expectName));
|
|
627
723
|
expect(":");
|
|
628
724
|
const body = parseExpression();
|
|
629
|
-
return withRange(
|
|
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
|
-
|
|
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
|
-
|
|
769
|
+
withBracketLayout(() => {
|
|
661
770
|
const location = getLocation(start);
|
|
662
|
-
|
|
663
|
-
|
|
664
|
-
|
|
665
|
-
|
|
666
|
-
|
|
667
|
-
|
|
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
|
-
|
|
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 =
|
|
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 =
|
|
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(
|
|
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
|
|
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,94 @@ 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(
|
|
851
|
-
if (params.length > 0) expect(")");
|
|
983
|
+
const params = getNames(accept("(") ? parseSeparated(expectName) : []);
|
|
984
|
+
if (params.names.length > 0) expect(")");
|
|
852
985
|
expect("::");
|
|
853
|
-
|
|
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
|
-
|
|
889
|
-
|
|
890
|
-
|
|
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
|
+
};
|
|
891
1060
|
}
|
|
892
|
-
|
|
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("(")) {
|
|
893
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
|
+
}
|
|
894
1068
|
switch (token.text) {
|
|
895
1069
|
case "(": {
|
|
896
|
-
const expression =
|
|
1070
|
+
const expression = withBracketLayout(() => parseExpression());
|
|
897
1071
|
expect(")");
|
|
898
1072
|
return expression;
|
|
899
1073
|
}
|
|
@@ -949,7 +1123,7 @@ const parse = (source: string, isTlapm: boolean): Module => {
|
|
|
949
1123
|
case "WF_":
|
|
950
1124
|
case "SF_": {
|
|
951
1125
|
const subscript = parseSubscript();
|
|
952
|
-
const action =
|
|
1126
|
+
const action = withBracketLayout(() => {
|
|
953
1127
|
expect("(");
|
|
954
1128
|
const expression = parseExpression();
|
|
955
1129
|
expect(")");
|
|
@@ -966,7 +1140,25 @@ const parse = (source: string, isTlapm: boolean): Module => {
|
|
|
966
1140
|
throw createUnexpected(`Unexpected ${describe(token)}`, token);
|
|
967
1141
|
};
|
|
968
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
|
+
|
|
969
1159
|
const parsePrefix = (): Expression => {
|
|
1160
|
+
const preceding = operators.preceding;
|
|
1161
|
+
operators.preceding = undefined;
|
|
970
1162
|
const token = peek();
|
|
971
1163
|
const location = getLocation(token);
|
|
972
1164
|
if (token.kind === "Operator" && (token.text === "/\\" || token.text === "\\/")) {
|
|
@@ -976,35 +1168,46 @@ const parse = (source: string, isTlapm: boolean): Module => {
|
|
|
976
1168
|
switch (token.text) {
|
|
977
1169
|
case "~":
|
|
978
1170
|
advance();
|
|
979
|
-
return {
|
|
1171
|
+
return {
|
|
1172
|
+
kind: "Apply",
|
|
1173
|
+
operator: "~",
|
|
1174
|
+
args: [parsePrefixOperand(token, 4, 4)],
|
|
1175
|
+
location,
|
|
1176
|
+
};
|
|
980
1177
|
case "-":
|
|
981
1178
|
advance();
|
|
982
1179
|
return {
|
|
983
1180
|
kind: "Apply",
|
|
984
1181
|
operator: "-.",
|
|
985
|
-
args: [
|
|
1182
|
+
args: [parsePrefixOperand(token, NEGATION_PRECEDENCE, NEGATION_PRECEDENCE)],
|
|
986
1183
|
location,
|
|
987
1184
|
};
|
|
988
1185
|
case "[]":
|
|
989
1186
|
advance();
|
|
990
|
-
return { kind: "Always", expression:
|
|
1187
|
+
return { kind: "Always", expression: parsePrefixOperand(token, 4, 15), location };
|
|
991
1188
|
case "<>":
|
|
992
1189
|
advance();
|
|
993
|
-
return { kind: "Eventually", expression:
|
|
1190
|
+
return { kind: "Eventually", expression: parsePrefixOperand(token, 4, 15), location };
|
|
994
1191
|
case "ENABLED":
|
|
995
1192
|
advance();
|
|
996
|
-
return { kind: "Enabled", expression:
|
|
1193
|
+
return { kind: "Enabled", expression: parsePrefixOperand(token, 4, 15), location };
|
|
997
1194
|
case "UNCHANGED":
|
|
998
1195
|
advance();
|
|
999
|
-
return { kind: "Unchanged", expression:
|
|
1196
|
+
return { kind: "Unchanged", expression: parsePrefixOperand(token, 4, 15), location };
|
|
1000
1197
|
case "SUBSET":
|
|
1001
1198
|
case "UNION":
|
|
1002
1199
|
case "DOMAIN":
|
|
1003
1200
|
advance();
|
|
1004
|
-
return {
|
|
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
|
+
};
|
|
1005
1208
|
}
|
|
1006
1209
|
}
|
|
1007
|
-
return parsePrimary();
|
|
1210
|
+
return parsePrimary(preceding);
|
|
1008
1211
|
};
|
|
1009
1212
|
|
|
1010
1213
|
const parseExpression = (minimumPrecedence = 0): Expression => {
|
|
@@ -1020,11 +1223,13 @@ const parse = (source: string, isTlapm: boolean): Module => {
|
|
|
1020
1223
|
const location = getLocation(token);
|
|
1021
1224
|
if (token.text === "'" && minimumPrecedence <= 15) {
|
|
1022
1225
|
advance();
|
|
1226
|
+
operators.last = POSTFIX_PRECEDENCE;
|
|
1023
1227
|
state.left = withRange({ kind: "Prime", expression: state.left, location }, start);
|
|
1024
1228
|
continue;
|
|
1025
1229
|
}
|
|
1026
1230
|
if (POSTFIX_OPERATORS.has(token.text) && minimumPrecedence <= 15) {
|
|
1027
1231
|
advance();
|
|
1232
|
+
operators.last = POSTFIX_PRECEDENCE;
|
|
1028
1233
|
state.left = withRange(
|
|
1029
1234
|
{ kind: "Apply", operator: token.text, args: [state.left], location },
|
|
1030
1235
|
start,
|
|
@@ -1033,8 +1238,9 @@ const parse = (source: string, isTlapm: boolean): Module => {
|
|
|
1033
1238
|
}
|
|
1034
1239
|
if (token.text === "[") {
|
|
1035
1240
|
advance();
|
|
1036
|
-
const args =
|
|
1037
|
-
|
|
1241
|
+
const args = withBracketLayout(() => parseSeparated(() => parseExpression()));
|
|
1242
|
+
withBracketLayout(() => expect("]"));
|
|
1243
|
+
operators.last = FUNCTION_PRECEDENCE;
|
|
1038
1244
|
state.left = withRange(
|
|
1039
1245
|
{ kind: "FunctionApplication", function: state.left, args, location },
|
|
1040
1246
|
start,
|
|
@@ -1065,21 +1271,33 @@ const parse = (source: string, isTlapm: boolean): Module => {
|
|
|
1065
1271
|
if (infix.low > NEGATION_PRECEDENCE && isAt("-")) {
|
|
1066
1272
|
throw createError(`Precedence conflict between ${token.text} and -`, peek());
|
|
1067
1273
|
}
|
|
1274
|
+
operators.last = operators.preceding = infix;
|
|
1068
1275
|
const right = parseExpression(infix.high + 1);
|
|
1069
1276
|
const left = state.left;
|
|
1070
1277
|
if (token.text === "/\\" || token.text === "\\/") {
|
|
1071
1278
|
const kind = token.text === "/\\" ? "And" : "Or";
|
|
1279
|
+
const prefixEnds = [getRange(start).end];
|
|
1072
1280
|
state.left =
|
|
1073
1281
|
left.kind === kind && previous?.text === token.text
|
|
1074
|
-
? {
|
|
1075
|
-
|
|
1282
|
+
? {
|
|
1283
|
+
...left,
|
|
1284
|
+
operands: [...left.operands, right],
|
|
1285
|
+
prefixEnds: [...(left.prefixEnds ?? []), ...prefixEnds],
|
|
1286
|
+
}
|
|
1287
|
+
: { kind, operands: [left, right], prefixEnds, location };
|
|
1076
1288
|
} else if (token.text === "\\X") {
|
|
1077
1289
|
state.left =
|
|
1078
1290
|
left.kind === "Product" && previous?.text === "\\X"
|
|
1079
1291
|
? { ...left, factors: [...left.factors, right] }
|
|
1080
1292
|
: { kind: "Product", factors: [left, right], location };
|
|
1081
1293
|
} else {
|
|
1082
|
-
state.left = {
|
|
1294
|
+
state.left = {
|
|
1295
|
+
kind: "Apply",
|
|
1296
|
+
operator: token.text,
|
|
1297
|
+
spelling: token.spelling,
|
|
1298
|
+
args: [left, right],
|
|
1299
|
+
location,
|
|
1300
|
+
};
|
|
1083
1301
|
}
|
|
1084
1302
|
state.left = withRange(state.left, start);
|
|
1085
1303
|
state.previous = { ...infix, text: token.text };
|
|
@@ -1099,7 +1317,7 @@ const parse = (source: string, isTlapm: boolean): Module => {
|
|
|
1099
1317
|
const body = parseExpression();
|
|
1100
1318
|
const last = tokens[cursor.index - 1];
|
|
1101
1319
|
const end = { line: last.line, column: last.endColumn };
|
|
1102
|
-
return { body, bodyRange: { module: openModules[
|
|
1320
|
+
return { body, bodyRange: { module: openModules[0].name, start, end } };
|
|
1103
1321
|
};
|
|
1104
1322
|
|
|
1105
1323
|
const parseDefinition = (isLocal: boolean): Definition | Instance => {
|
|
@@ -1107,6 +1325,16 @@ const parse = (source: string, isTlapm: boolean): Module => {
|
|
|
1107
1325
|
return withRange(parseDefinitionUnit(isLocal), start);
|
|
1108
1326
|
};
|
|
1109
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
|
+
|
|
1110
1338
|
const parseDefinitionUnit = (isLocal: boolean): Definition | Instance => {
|
|
1111
1339
|
const token = peek();
|
|
1112
1340
|
const location = getLocation(token);
|
|
@@ -1126,28 +1354,27 @@ const parse = (source: string, isTlapm: boolean): Module => {
|
|
|
1126
1354
|
peek(2).kind === "Identifier" &&
|
|
1127
1355
|
isAt("==", 3)
|
|
1128
1356
|
) {
|
|
1129
|
-
const left =
|
|
1357
|
+
const left = expectName();
|
|
1130
1358
|
const operator = advance().text;
|
|
1131
|
-
const right =
|
|
1359
|
+
const right = expectName();
|
|
1132
1360
|
expect("==");
|
|
1133
|
-
return parseOperator(operator, [
|
|
1134
|
-
{ name: left, arity: 0 },
|
|
1135
|
-
{ name: right, arity: 0 },
|
|
1136
|
-
]);
|
|
1361
|
+
return parseOperator(operator, [toParam(left), toParam(right)]);
|
|
1137
1362
|
}
|
|
1138
|
-
const isPrefixDefinition =
|
|
1363
|
+
const isPrefixDefinition =
|
|
1364
|
+
token.kind !== "String" && DEFINABLE_PREFIX_OPERATORS.has(token.text);
|
|
1139
1365
|
const isPostfixDefinition =
|
|
1140
1366
|
token.kind === "Identifier" && POSTFIX_OPERATORS.has(peek(1).text) && isAt("==", 2);
|
|
1141
1367
|
if (isPrefixDefinition || isPostfixDefinition) {
|
|
1142
1368
|
const operator = isPrefixDefinition ? token.text : peek(1).text;
|
|
1143
|
-
|
|
1144
|
-
const param =
|
|
1369
|
+
if (isPrefixDefinition) advance();
|
|
1370
|
+
const param = expectName();
|
|
1371
|
+
if (isPostfixDefinition) advance();
|
|
1145
1372
|
expect("==");
|
|
1146
|
-
return parseOperator(operator, [
|
|
1373
|
+
return parseOperator(operator, [toParam(param)]);
|
|
1147
1374
|
}
|
|
1148
1375
|
const name = expectIdentifier();
|
|
1149
1376
|
if (accept("[")) {
|
|
1150
|
-
const bounds =
|
|
1377
|
+
const bounds = withBracketLayout(() => parseBounds());
|
|
1151
1378
|
expect("]");
|
|
1152
1379
|
expect("==");
|
|
1153
1380
|
return {
|
|
@@ -1178,12 +1405,14 @@ const parse = (source: string, isTlapm: boolean): Module => {
|
|
|
1178
1405
|
): Instance => {
|
|
1179
1406
|
const start = cursor.index;
|
|
1180
1407
|
expect("INSTANCE");
|
|
1181
|
-
const module =
|
|
1408
|
+
const module = expectModuleName();
|
|
1182
1409
|
const substitutions = accept("WITH")
|
|
1183
1410
|
? parseSeparated(() => {
|
|
1184
|
-
const
|
|
1411
|
+
const targetStart = cursor.index;
|
|
1412
|
+
const target = expectSubstitutionTarget();
|
|
1413
|
+
const nameRange = getRange(targetStart);
|
|
1185
1414
|
expect("<-");
|
|
1186
|
-
return { name: target, expression: parseArgument() };
|
|
1415
|
+
return { name: target, nameRange, expression: parseArgument() };
|
|
1187
1416
|
})
|
|
1188
1417
|
: [];
|
|
1189
1418
|
return {
|
|
@@ -1199,6 +1428,11 @@ const parse = (source: string, isTlapm: boolean): Module => {
|
|
|
1199
1428
|
};
|
|
1200
1429
|
|
|
1201
1430
|
const parseDeclaration = (): Declaration => {
|
|
1431
|
+
const start = cursor.index;
|
|
1432
|
+
return withRange(parseDeclarationUnit(), start);
|
|
1433
|
+
};
|
|
1434
|
+
|
|
1435
|
+
const parseDeclarationUnit = (): Declaration => {
|
|
1202
1436
|
const location = getLocation(peek());
|
|
1203
1437
|
if (isAt("_") && peek(1).kind === "Operator") {
|
|
1204
1438
|
advance();
|
|
@@ -1244,7 +1478,12 @@ const parse = (source: string, isTlapm: boolean): Module => {
|
|
|
1244
1478
|
const token = peek();
|
|
1245
1479
|
const next = peek(1);
|
|
1246
1480
|
if (token.kind !== "Identifier") {
|
|
1247
|
-
return
|
|
1481
|
+
return (
|
|
1482
|
+
token.kind !== "String" &&
|
|
1483
|
+
DEFINABLE_PREFIX_OPERATORS.has(token.text) &&
|
|
1484
|
+
next.kind === "Identifier" &&
|
|
1485
|
+
isAt("==", 2)
|
|
1486
|
+
);
|
|
1248
1487
|
}
|
|
1249
1488
|
if (isAt("(", 1) || isAt("[", 1)) return isAt("==", getClosingOffset(1));
|
|
1250
1489
|
if (next.kind === "Operator" && POSTFIX_OPERATORS.has(next.text)) return isAt("==", 2);
|
|
@@ -1336,7 +1575,6 @@ const parse = (source: string, isTlapm: boolean): Module => {
|
|
|
1336
1575
|
// start of an expression.
|
|
1337
1576
|
const parseFact = (): Fact => {
|
|
1338
1577
|
const start = cursor.index;
|
|
1339
|
-
factStart.index = start;
|
|
1340
1578
|
const token = peek();
|
|
1341
1579
|
if (
|
|
1342
1580
|
token.kind === "Operator" &&
|
|
@@ -1398,7 +1636,10 @@ const parse = (source: string, isTlapm: boolean): Module => {
|
|
|
1398
1636
|
const parseDefs = () => {
|
|
1399
1637
|
if (isTlapm) return parseSeparated(parseDefinable);
|
|
1400
1638
|
const defs = parseSeparated(parseFact);
|
|
1401
|
-
const invalid =
|
|
1639
|
+
const invalid =
|
|
1640
|
+
mode === "tlc"
|
|
1641
|
+
? defs.find((def) => def.kind === "Identifier" && isDeclaredSymbol(def.name))
|
|
1642
|
+
: undefined;
|
|
1402
1643
|
if (invalid) {
|
|
1403
1644
|
throw createError("DEF clause entry should describe a defined operator", invalid.location);
|
|
1404
1645
|
}
|
|
@@ -1423,11 +1664,14 @@ const parse = (source: string, isTlapm: boolean): Module => {
|
|
|
1423
1664
|
location: getLocation(keyword),
|
|
1424
1665
|
};
|
|
1425
1666
|
const invalid =
|
|
1426
|
-
use.kind === "Hide" &&
|
|
1427
|
-
if (invalid) {
|
|
1428
|
-
throw
|
|
1429
|
-
|
|
1430
|
-
|
|
1667
|
+
use.kind === "Hide" && mode === "tlc" ? use.facts.filter((fact) => !isHideFact(fact)) : [];
|
|
1668
|
+
if (invalid.length > 0) {
|
|
1669
|
+
throw createSanyError(
|
|
1670
|
+
invalid.map((fact) => ({
|
|
1671
|
+
location: formatRange(fact.location.range ?? getRange(start)),
|
|
1672
|
+
message:
|
|
1673
|
+
"The only expression allowed as a fact in a HIDE is \nthe name of a theorem, assumption, or step.",
|
|
1674
|
+
})),
|
|
1431
1675
|
);
|
|
1432
1676
|
}
|
|
1433
1677
|
return withRange(use, start);
|
|
@@ -1443,10 +1687,18 @@ const parse = (source: string, isTlapm: boolean): Module => {
|
|
|
1443
1687
|
}
|
|
1444
1688
|
if (level !== undefined) advance();
|
|
1445
1689
|
if (level === "Variable") {
|
|
1446
|
-
const
|
|
1447
|
-
declareProofSymbol(name);
|
|
1690
|
+
const named = expectName();
|
|
1691
|
+
declareProofSymbol(named.name);
|
|
1448
1692
|
return withRange(
|
|
1449
|
-
{
|
|
1693
|
+
{
|
|
1694
|
+
kind: "NewSymbol",
|
|
1695
|
+
name: named.name,
|
|
1696
|
+
arity: 0,
|
|
1697
|
+
level,
|
|
1698
|
+
set: undefined,
|
|
1699
|
+
nameRange: named.range,
|
|
1700
|
+
location,
|
|
1701
|
+
},
|
|
1450
1702
|
start,
|
|
1451
1703
|
);
|
|
1452
1704
|
}
|
|
@@ -1464,6 +1716,7 @@ const parse = (source: string, isTlapm: boolean): Module => {
|
|
|
1464
1716
|
arity: declaration.arity,
|
|
1465
1717
|
level: level ?? "Constant",
|
|
1466
1718
|
set: isBounded ? parseExpression() : undefined,
|
|
1719
|
+
nameRange: declaration.location.range,
|
|
1467
1720
|
location,
|
|
1468
1721
|
},
|
|
1469
1722
|
start,
|
|
@@ -1506,7 +1759,8 @@ const parse = (source: string, isTlapm: boolean): Module => {
|
|
|
1506
1759
|
const token = peek();
|
|
1507
1760
|
if (isAt("USE") || isAt("HIDE")) return parseUseOrHide();
|
|
1508
1761
|
if (isAt("INSTANCE")) {
|
|
1509
|
-
|
|
1762
|
+
const start = cursor.index;
|
|
1763
|
+
return withRange(parseInstance(undefined, [], false, getLocation(token)), start);
|
|
1510
1764
|
}
|
|
1511
1765
|
if (isAt("DEFINE") || isDefinitionStart()) {
|
|
1512
1766
|
const start = cursor.index;
|
|
@@ -1519,21 +1773,27 @@ const parse = (source: string, isTlapm: boolean): Module => {
|
|
|
1519
1773
|
if (accept("HAVE")) return { kind: "Have", expression: parseExpression() };
|
|
1520
1774
|
if (accept("TAKE")) {
|
|
1521
1775
|
const isBounded = isBoundAhead();
|
|
1522
|
-
const names = isBounded ? [] : parseSeparated(
|
|
1776
|
+
const names = getNames(isBounded ? [] : parseSeparated(expectName));
|
|
1523
1777
|
const bounds = isBounded ? parseBounds() : [];
|
|
1524
|
-
declareProofSymbols(names, bounds);
|
|
1525
|
-
return { kind: "Take", names, bounds };
|
|
1778
|
+
declareProofSymbols(names.names, bounds);
|
|
1779
|
+
return { kind: "Take", names: names.names, nameRanges: names.ranges, bounds };
|
|
1526
1780
|
}
|
|
1527
1781
|
if (accept("WITNESS")) {
|
|
1528
1782
|
return { kind: "Witness", expressions: parseSeparated(() => parseExpression()) };
|
|
1529
1783
|
}
|
|
1530
1784
|
if (accept("PICK")) {
|
|
1531
1785
|
const isNames = isNameListAhead(":");
|
|
1532
|
-
const names = isNames ? parseSeparated(
|
|
1786
|
+
const names = getNames(isNames ? parseSeparated(expectName) : []);
|
|
1533
1787
|
const bounds = isNames ? [] : parseBounds();
|
|
1534
|
-
declareProofSymbols(names, bounds);
|
|
1788
|
+
declareProofSymbols(names.names, bounds);
|
|
1535
1789
|
expect(":");
|
|
1536
|
-
return {
|
|
1790
|
+
return {
|
|
1791
|
+
kind: "Pick",
|
|
1792
|
+
names: names.names,
|
|
1793
|
+
nameRanges: names.ranges,
|
|
1794
|
+
bounds,
|
|
1795
|
+
body: parseExpression(),
|
|
1796
|
+
};
|
|
1537
1797
|
}
|
|
1538
1798
|
if (accept("CASE")) return { kind: "Case", expression: parseExpression() };
|
|
1539
1799
|
return {
|
|
@@ -1563,10 +1823,12 @@ const parse = (source: string, isTlapm: boolean): Module => {
|
|
|
1563
1823
|
const parseStep = (): ProofStep => {
|
|
1564
1824
|
const start = cursor.index;
|
|
1565
1825
|
const step = parseStepStart(isAt("QED", 1));
|
|
1826
|
+
const statementStart = cursor.index;
|
|
1566
1827
|
const scope = new Set<string>();
|
|
1567
1828
|
proofScopes.push(scope);
|
|
1568
1829
|
const body: StepBody = accept("QED") ? { kind: "Qed" } : parseStepBody();
|
|
1569
1830
|
const head = getRange(start);
|
|
1831
|
+
const statement = getRange(statementStart);
|
|
1570
1832
|
const hasProof = isProofStart(peek());
|
|
1571
1833
|
if (hasProof && !PROVABLE_STEPS.has(body.kind)) {
|
|
1572
1834
|
throw createError("Proof of a step that does not take a proof");
|
|
@@ -1574,7 +1836,7 @@ const parse = (source: string, isTlapm: boolean): Module => {
|
|
|
1574
1836
|
const proof = hasProof ? parseProof() : undefined;
|
|
1575
1837
|
proofScopes.pop();
|
|
1576
1838
|
if (body.kind !== "Assert" || body.isSuffices) scope.forEach(declareProofSymbol);
|
|
1577
|
-
return withRange({ ...step, body, head, proof }, start);
|
|
1839
|
+
return withRange({ ...step, body, head, statement, proof }, start);
|
|
1578
1840
|
};
|
|
1579
1841
|
|
|
1580
1842
|
const parseProofBody = (): Proof => {
|
|
@@ -1609,6 +1871,13 @@ const parse = (source: string, isTlapm: boolean): Module => {
|
|
|
1609
1871
|
return withRange(proof, start);
|
|
1610
1872
|
};
|
|
1611
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
|
+
|
|
1612
1881
|
const parseTheorem = (module: Module) => {
|
|
1613
1882
|
const start = cursor.index;
|
|
1614
1883
|
const keyword = advance();
|
|
@@ -1630,7 +1899,8 @@ const parse = (source: string, isTlapm: boolean): Module => {
|
|
|
1630
1899
|
module.theorems.push(theorem);
|
|
1631
1900
|
module.units.push({ kind: "Theorem", theorem });
|
|
1632
1901
|
if (name === undefined || statement.kind === "AssumeProve") return;
|
|
1633
|
-
|
|
1902
|
+
addFactDefinition(
|
|
1903
|
+
module,
|
|
1634
1904
|
withRange(
|
|
1635
1905
|
{
|
|
1636
1906
|
kind: "Operator",
|
|
@@ -1667,7 +1937,7 @@ const parse = (source: string, isTlapm: boolean): Module => {
|
|
|
1667
1937
|
const parseModuleBody = (): Module => {
|
|
1668
1938
|
const location = getLocation(expect("----"));
|
|
1669
1939
|
expect("MODULE");
|
|
1670
|
-
const name =
|
|
1940
|
+
const name = expectModuleName();
|
|
1671
1941
|
expect("----");
|
|
1672
1942
|
const module: Module = {
|
|
1673
1943
|
name,
|
|
@@ -1689,7 +1959,7 @@ const parse = (source: string, isTlapm: boolean): Module => {
|
|
|
1689
1959
|
if (accept("EXTENDS")) {
|
|
1690
1960
|
parseSeparated(() => {
|
|
1691
1961
|
const start = cursor.index;
|
|
1692
|
-
module.extends.push(
|
|
1962
|
+
module.extends.push(expectModuleName());
|
|
1693
1963
|
module.extendsRanges.push(getRange(start));
|
|
1694
1964
|
});
|
|
1695
1965
|
}
|
|
@@ -1697,14 +1967,12 @@ const parse = (source: string, isTlapm: boolean): Module => {
|
|
|
1697
1967
|
const tokenIndex = cursor.index;
|
|
1698
1968
|
unitStart.index = tokenIndex;
|
|
1699
1969
|
const token = peek();
|
|
1700
|
-
if (token.kind === "ModuleEnd"
|
|
1701
|
-
|
|
1702
|
-
|
|
1703
|
-
|
|
1704
|
-
|
|
1705
|
-
|
|
1706
|
-
};
|
|
1707
|
-
}
|
|
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
|
+
};
|
|
1708
1976
|
openModules.pop();
|
|
1709
1977
|
recursiveScopes.pop();
|
|
1710
1978
|
return module;
|
|
@@ -1723,22 +1991,24 @@ const parse = (source: string, isTlapm: boolean): Module => {
|
|
|
1723
1991
|
switch (token.text) {
|
|
1724
1992
|
case "CONSTANT":
|
|
1725
1993
|
case "CONSTANTS": {
|
|
1726
|
-
advance();
|
|
1994
|
+
const unitLocation = getLocation(advance());
|
|
1727
1995
|
const declarations = parseDeclarations();
|
|
1728
1996
|
module.constants.push(...declarations);
|
|
1729
|
-
|
|
1997
|
+
unitLocation.range = getRange(tokenIndex);
|
|
1998
|
+
module.units.push({ kind: "Constants", declarations, location: unitLocation });
|
|
1730
1999
|
continue;
|
|
1731
2000
|
}
|
|
1732
2001
|
case "VARIABLE":
|
|
1733
2002
|
case "VARIABLES": {
|
|
1734
|
-
advance();
|
|
2003
|
+
const unitLocation = getLocation(advance());
|
|
1735
2004
|
const declarations = parseSeparated(() => {
|
|
1736
2005
|
const start = cursor.index;
|
|
1737
2006
|
const location = getLocation(peek());
|
|
1738
2007
|
return withRange({ name: expectIdentifier(), arity: 0, location }, start);
|
|
1739
2008
|
});
|
|
1740
2009
|
module.variables.push(...declarations);
|
|
1741
|
-
|
|
2010
|
+
unitLocation.range = getRange(tokenIndex);
|
|
2011
|
+
module.units.push({ kind: "Variables", declarations, location: unitLocation });
|
|
1742
2012
|
continue;
|
|
1743
2013
|
}
|
|
1744
2014
|
case "ASSUME":
|
|
@@ -1748,7 +2018,7 @@ const parse = (source: string, isTlapm: boolean): Module => {
|
|
|
1748
2018
|
module.assumptions.push(assumption);
|
|
1749
2019
|
module.units.push({ kind: "Assumption", assumption });
|
|
1750
2020
|
if (assumption.name !== undefined) {
|
|
1751
|
-
module
|
|
2021
|
+
addFactDefinition(module, {
|
|
1752
2022
|
kind: "Operator",
|
|
1753
2023
|
name: assumption.name,
|
|
1754
2024
|
params: [],
|
|
@@ -1762,6 +2032,10 @@ const parse = (source: string, isTlapm: boolean): Module => {
|
|
|
1762
2032
|
}
|
|
1763
2033
|
case "USE":
|
|
1764
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
|
+
}
|
|
1765
2039
|
const use = parseUseOrHide();
|
|
1766
2040
|
module.uses.push(use);
|
|
1767
2041
|
module.units.push({ kind: "Use", use });
|
|
@@ -1786,7 +2060,7 @@ const parse = (source: string, isTlapm: boolean): Module => {
|
|
|
1786
2060
|
);
|
|
1787
2061
|
continue;
|
|
1788
2062
|
}
|
|
1789
|
-
addDefinitionUnit(module,
|
|
2063
|
+
addDefinitionUnit(module, withRange(parseDefinitionUnit(true), tokenIndex));
|
|
1790
2064
|
continue;
|
|
1791
2065
|
}
|
|
1792
2066
|
}
|
|
@@ -1808,9 +2082,16 @@ const parse = (source: string, isTlapm: boolean): Module => {
|
|
|
1808
2082
|
module.units.push({ kind: "Definition", definition: unit });
|
|
1809
2083
|
};
|
|
1810
2084
|
|
|
1811
|
-
|
|
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;
|
|
1812
2091
|
};
|
|
1813
2092
|
|
|
1814
|
-
export const parseModule = (source: string) => parse(source,
|
|
2093
|
+
export const parseModule = (source: string) => parse(source, "tlc");
|
|
2094
|
+
|
|
2095
|
+
export const parseTlapmModule = (source: string) => parse(source, "tlapm");
|
|
1815
2096
|
|
|
1816
|
-
export const
|
|
2097
|
+
export const parseSanyModule = (source: string) => parse(source, "sany");
|