tla-ts 0.0.3-dev.3cf2ad0 → 0.0.3-dev.3ef4193
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +16 -2
- package/dist/cli.cjs +1 -1
- package/dist/cli.js +1 -1
- package/dist/index.cjs +1 -1
- package/dist/index.d.cts +158 -8
- package/dist/index.d.ts +158 -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 -19
- package/dist/run-cli.js +1351 -19
- package/dist/transfer.cjs +88 -18
- package/dist/transfer.js +88 -18
- package/package.json +5 -1
- package/src/ast.ts +146 -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 +1539 -235
- package/src/cli-options.ts +11 -5
- package/src/cli.ts +8 -1
- package/src/codegen.ts +77 -37
- package/src/config.ts +252 -179
- package/src/dependencies.ts +2 -2
- package/src/environment.ts +524 -140
- package/src/errors.ts +224 -3
- package/src/evaluate.ts +796 -246
- package/src/exit-codes.ts +22 -43
- package/src/index.ts +1 -0
- package/src/instances.ts +19 -16
- package/src/java-overrides.ts +104 -25
- package/src/levels.ts +191 -45
- package/src/lexer.ts +37 -5
- package/src/live-check.ts +828 -0
- package/src/liveness.ts +218 -572
- package/src/obligation-expression.ts +2 -2
- package/src/obligation-source.ts +2 -0
- package/src/parallel-worker.ts +13 -4
- package/src/parallel.ts +73 -6
- package/src/parser.ts +436 -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 +1424 -415
- package/src/run-cli.ts +1200 -143
- package/src/runtime.ts +19 -1
- 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 +42 -11
- package/src/standard-modules.ts +200 -148
- package/src/standard-ranges.ts +116 -0
- package/src/state-graph.ts +180 -0
- package/src/subexpressions.ts +231 -171
- package/src/substitution-levels.ts +38 -17
- package/src/successors.ts +219 -107
- package/src/symmetry.ts +189 -53
- package/src/tableau.ts +54 -25
- package/src/tlc-ext.ts +42 -29
- package/src/tlc-messages.ts +329 -0
- package/src/tlc-module.ts +52 -43
- package/src/tlc-order.ts +73 -9
- package/src/tlc-random.ts +37 -9
- package/src/tlc-replay.ts +655 -0
- package/src/tlc-summary.ts +20 -5
- package/src/tlc-version.ts +18 -0
- package/src/transfer.ts +15 -3
- package/src/value-sources.ts +29 -0
- package/src/values.ts +708 -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
|
|
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,
|
|
@@ -135,10 +150,25 @@ const INFIX_OPERATORS = new Map<string, InfixOperator>([
|
|
|
135
150
|
["^^", createInfix(14, 14, false)],
|
|
136
151
|
]);
|
|
137
152
|
|
|
153
|
+
const NEGATION_PRECEDENCE = 12;
|
|
154
|
+
|
|
138
155
|
const POSTFIX_OPERATORS = new Set(["^+", "^*", "^#"]);
|
|
139
156
|
|
|
140
157
|
const PREFIX_OPERATOR_REFERENCES = new Set(["-", "~", "-."]);
|
|
141
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
|
+
|
|
142
172
|
const EXPRESSION_PREFIXES = new Set([
|
|
143
173
|
"-",
|
|
144
174
|
"~",
|
|
@@ -167,6 +197,16 @@ const OPERATOR_ARGUMENTS = new Set([
|
|
|
167
197
|
...POSTFIX_OPERATORS,
|
|
168
198
|
]);
|
|
169
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
|
+
|
|
170
210
|
const isOperatorName = (text: string) =>
|
|
171
211
|
INFIX_OPERATORS.has(text) || POSTFIX_OPERATORS.has(text) || text === "-.";
|
|
172
212
|
|
|
@@ -260,6 +300,7 @@ const FACT_KEYWORDS = new Set([
|
|
|
260
300
|
"IF",
|
|
261
301
|
"LAMBDA",
|
|
262
302
|
"LET",
|
|
303
|
+
"MODULE",
|
|
263
304
|
"SF_",
|
|
264
305
|
"SUBSET",
|
|
265
306
|
"UNCHANGED",
|
|
@@ -289,30 +330,33 @@ const BUILTIN_CONSTANTS = new Set(["TRUE", "FALSE", "BOOLEAN", "STRING"]);
|
|
|
289
330
|
|
|
290
331
|
const NO_OFFSIDE = -1;
|
|
291
332
|
|
|
292
|
-
|
|
293
|
-
|
|
294
|
-
// The text of a module that starts on its own line in a file, as TLC's monolith extractor reads
|
|
295
|
-
// 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.
|
|
296
335
|
export const extractModule = (source: string, name: string) => {
|
|
336
|
+
const header = new RegExp(`^-{4,}\\s*MODULE\\s+${name}\\s*-{3,}$`);
|
|
297
337
|
const lines = source.split(/\r?\n/);
|
|
298
|
-
const start = lines.findIndex((line) =>
|
|
338
|
+
const start = lines.findIndex((line) => header.test(line));
|
|
299
339
|
if (start === -1) return undefined;
|
|
300
340
|
const end = lines.findIndex((line, index) => index > start && line.startsWith("===="));
|
|
301
|
-
return lines.slice(start, end === -1 ? undefined : end + 1).join("\n")
|
|
341
|
+
return `${lines.slice(start, end === -1 ? undefined : end + 1).join("\n")}\n`;
|
|
302
342
|
};
|
|
303
343
|
|
|
304
|
-
//
|
|
305
|
-
// SANY does not.
|
|
306
|
-
|
|
307
|
-
|
|
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);
|
|
308
352
|
const cursor = { index: 0, offsideColumns: [] as number[] };
|
|
353
|
+
const operators: OperatorContext = {};
|
|
309
354
|
// A RECURSIVE declaration covers the definitions of its own LET or module.
|
|
310
355
|
const recursiveScopes: Set<string>[] = [];
|
|
311
356
|
const factNames = new Set<string>();
|
|
312
357
|
// The NEW, TAKE, and PICK names in scope, which a DEF clause cannot cite.
|
|
313
358
|
const proofScopes: Set<string>[] = [];
|
|
314
|
-
//
|
|
315
|
-
const factStart = { index: -1 };
|
|
359
|
+
// SANY reports a location in a nested module as one in the module of its file.
|
|
316
360
|
const openModules: Module[] = [];
|
|
317
361
|
|
|
318
362
|
const isRecursiveName = (name: string) => recursiveScopes[recursiveScopes.length - 1].has(name);
|
|
@@ -327,15 +371,14 @@ const parse = (source: string, isTlapm: boolean): Module => {
|
|
|
327
371
|
const tokenEnds: SourceLocation[] = [];
|
|
328
372
|
const tokenRanges: SourceRange[] = [];
|
|
329
373
|
|
|
330
|
-
const getRange = (startIndex: number) => {
|
|
331
|
-
const endIndex = cursor.index - 1;
|
|
374
|
+
const getRange = (startIndex: number, endIndex = cursor.index - 1) => {
|
|
332
375
|
const cached = startIndex === endIndex ? tokenRanges[startIndex] : undefined;
|
|
333
376
|
if (cached) return cached;
|
|
334
377
|
const last = tokens[endIndex];
|
|
335
378
|
tokenStarts[startIndex] ??= getLocation(tokens[startIndex]);
|
|
336
379
|
tokenEnds[endIndex] ??= { line: last.line, column: last.endColumn };
|
|
337
380
|
const range = {
|
|
338
|
-
module: openModules[
|
|
381
|
+
module: openModules[0].name,
|
|
339
382
|
start: tokenStarts[startIndex],
|
|
340
383
|
end: tokenEnds[endIndex],
|
|
341
384
|
};
|
|
@@ -433,8 +476,12 @@ const parse = (source: string, isTlapm: boolean): Module => {
|
|
|
433
476
|
const createUnexpected = (message: string, token: Token = peekRaw()) =>
|
|
434
477
|
createError(message, token, token);
|
|
435
478
|
|
|
479
|
+
// TLAplusParser.isFieldNameToken: a keyword or an underscore names a field or a module too.
|
|
436
480
|
const isFieldName = (token: Token) =>
|
|
437
|
-
(token.kind === "Identifier" ||
|
|
481
|
+
(token.kind === "Identifier" ||
|
|
482
|
+
token.kind === "Keyword" ||
|
|
483
|
+
(token.kind === "Operator" && token.text === "_")) &&
|
|
484
|
+
!isTlapmKeyword(token);
|
|
438
485
|
|
|
439
486
|
const isAt = (text: string, offset = 0) => {
|
|
440
487
|
const token = peek(offset);
|
|
@@ -470,7 +517,42 @@ const parse = (source: string, isTlapm: boolean): Module => {
|
|
|
470
517
|
return token.text;
|
|
471
518
|
};
|
|
472
519
|
|
|
473
|
-
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();
|
|
474
556
|
cursor.offsideColumns.push(NO_OFFSIDE);
|
|
475
557
|
const result = parse();
|
|
476
558
|
cursor.offsideColumns.pop();
|
|
@@ -512,10 +594,13 @@ const parse = (source: string, isTlapm: boolean): Module => {
|
|
|
512
594
|
};
|
|
513
595
|
|
|
514
596
|
const parsePattern = (): BoundPattern => {
|
|
515
|
-
if (!accept("<<"))
|
|
516
|
-
|
|
597
|
+
if (!accept("<<")) {
|
|
598
|
+
const named = expectName();
|
|
599
|
+
return { kind: "Name", name: named.name, ranges: [named.range] };
|
|
600
|
+
}
|
|
601
|
+
const names = getNames(parseSeparated(expectName));
|
|
517
602
|
expect(">>");
|
|
518
|
-
return { kind: "Tuple", names };
|
|
603
|
+
return { kind: "Tuple", names: names.names, ranges: names.ranges };
|
|
519
604
|
};
|
|
520
605
|
|
|
521
606
|
const parseBounds = () =>
|
|
@@ -558,8 +643,9 @@ const parse = (source: string, isTlapm: boolean): Module => {
|
|
|
558
643
|
);
|
|
559
644
|
};
|
|
560
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.
|
|
561
648
|
const isStandalone = (operator: Token) => {
|
|
562
|
-
if (!EXPRESSION_PREFIXES.has(operator.text)) return true;
|
|
563
649
|
const token = peek(1);
|
|
564
650
|
return (
|
|
565
651
|
token.kind === "End" ||
|
|
@@ -598,7 +684,12 @@ const parse = (source: string, isTlapm: boolean): Module => {
|
|
|
598
684
|
if (isOperatorAlone) {
|
|
599
685
|
cursor.index++;
|
|
600
686
|
return withRange(
|
|
601
|
-
{
|
|
687
|
+
{
|
|
688
|
+
kind: "OperatorReference",
|
|
689
|
+
operator: token.text,
|
|
690
|
+
spelling: token.spelling,
|
|
691
|
+
location: getLocation(token),
|
|
692
|
+
},
|
|
602
693
|
cursor.index - 1,
|
|
603
694
|
);
|
|
604
695
|
}
|
|
@@ -608,32 +699,52 @@ const parse = (source: string, isTlapm: boolean): Module => {
|
|
|
608
699
|
cursor.index++;
|
|
609
700
|
const location = getLocation(token);
|
|
610
701
|
if (POSTFIX_OPERATORS.has(token.text)) {
|
|
611
|
-
return
|
|
702
|
+
return withRange(
|
|
703
|
+
{ kind: "OperatorReference", operator: token.text, location },
|
|
704
|
+
cursor.index - 1,
|
|
705
|
+
);
|
|
612
706
|
}
|
|
613
707
|
const argument: Expression = { kind: "Identifier", name: "argument", location };
|
|
614
|
-
return
|
|
615
|
-
|
|
616
|
-
|
|
617
|
-
|
|
618
|
-
|
|
619
|
-
|
|
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
|
+
);
|
|
620
718
|
}
|
|
621
719
|
if (isAt("LAMBDA")) {
|
|
622
720
|
const start = cursor.index;
|
|
623
721
|
advance();
|
|
624
|
-
const params = parseSeparated(
|
|
722
|
+
const params = getNames(parseSeparated(expectName));
|
|
625
723
|
expect(":");
|
|
626
724
|
const body = parseExpression();
|
|
627
|
-
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
|
+
);
|
|
628
735
|
}
|
|
629
736
|
return parseExpression();
|
|
630
737
|
};
|
|
631
738
|
|
|
739
|
+
const lastArguments: { range: SourceRange | undefined } = { range: undefined };
|
|
740
|
+
|
|
632
741
|
const parseArguments = () =>
|
|
633
|
-
|
|
742
|
+
withBracketLayout(() => {
|
|
743
|
+
const start = cursor.index;
|
|
634
744
|
expect("(");
|
|
635
745
|
const args = parseSeparated(parseArgument);
|
|
636
746
|
expect(")");
|
|
747
|
+
lastArguments.range = getRange(start);
|
|
637
748
|
return args;
|
|
638
749
|
});
|
|
639
750
|
|
|
@@ -655,15 +766,25 @@ const parse = (source: string, isTlapm: boolean): Module => {
|
|
|
655
766
|
};
|
|
656
767
|
|
|
657
768
|
const parseBracket = (start: Token): Expression =>
|
|
658
|
-
|
|
769
|
+
withBracketLayout(() => {
|
|
659
770
|
const location = getLocation(start);
|
|
660
|
-
|
|
661
|
-
|
|
662
|
-
|
|
663
|
-
|
|
664
|
-
|
|
665
|
-
|
|
666
|
-
|
|
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
|
+
];
|
|
667
788
|
expect("]");
|
|
668
789
|
return { kind, fields, location };
|
|
669
790
|
}
|
|
@@ -701,17 +822,29 @@ const parse = (source: string, isTlapm: boolean): Module => {
|
|
|
701
822
|
expect("]");
|
|
702
823
|
return { kind: "Except", function: expression, updates, location };
|
|
703
824
|
}
|
|
825
|
+
if (!isTlapm && !isAt("]_")) {
|
|
826
|
+
const args = [expression];
|
|
827
|
+
while (accept(",")) args.push(parseExpression());
|
|
828
|
+
expect("]");
|
|
829
|
+
return { kind: "Bracket", args, location };
|
|
830
|
+
}
|
|
704
831
|
expect("]_");
|
|
705
|
-
return {
|
|
706
|
-
kind: "BoxAction",
|
|
707
|
-
action: expression,
|
|
708
|
-
subscript: parseSubscript(),
|
|
709
|
-
location,
|
|
710
|
-
};
|
|
832
|
+
return { kind: "BoxAction", action: expression, subscript: parseSubscript(), location };
|
|
711
833
|
});
|
|
712
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
|
+
|
|
713
846
|
const parseBrace = (start: Token): Expression =>
|
|
714
|
-
|
|
847
|
+
withBracketLayout(() => {
|
|
715
848
|
const location = getLocation(start);
|
|
716
849
|
if (accept("}")) return { kind: "SetEnumeration", elements: [], location };
|
|
717
850
|
if (isBoundAhead() && (peek(1).text === "\\in" || isAt("<<"))) {
|
|
@@ -726,7 +859,8 @@ const parse = (source: string, isTlapm: boolean): Module => {
|
|
|
726
859
|
}
|
|
727
860
|
cursor.index = checkpoint;
|
|
728
861
|
}
|
|
729
|
-
const first =
|
|
862
|
+
const first =
|
|
863
|
+
peek().kind === "Identifier" && isAt("\\in", 1) ? parseSetMembership() : parseExpression();
|
|
730
864
|
if (accept(":")) {
|
|
731
865
|
const bounds = parseBounds();
|
|
732
866
|
expect("}");
|
|
@@ -740,7 +874,7 @@ const parse = (source: string, isTlapm: boolean): Module => {
|
|
|
740
874
|
|
|
741
875
|
const parseTuple = (start: Token): Expression => {
|
|
742
876
|
const location = getLocation(start);
|
|
743
|
-
const elements =
|
|
877
|
+
const elements = withBracketLayout(() =>
|
|
744
878
|
isAt(">>") || isAt(">>_") ? [] : parseSeparated(() => parseExpression()),
|
|
745
879
|
);
|
|
746
880
|
if (accept(">>_")) {
|
|
@@ -761,12 +895,13 @@ const parse = (source: string, isTlapm: boolean): Module => {
|
|
|
761
895
|
expect(":");
|
|
762
896
|
return { kind, bounds, body: parseExpression(), location };
|
|
763
897
|
}
|
|
764
|
-
const names = parseSeparated(
|
|
898
|
+
const names = getNames(parseSeparated(expectName));
|
|
765
899
|
expect(":");
|
|
766
900
|
return {
|
|
767
901
|
kind: "UnboundedQuantifier",
|
|
768
902
|
quantifier: start.text === "\\A" || start.text === "\\AA" ? "Forall" : "Exists",
|
|
769
|
-
names,
|
|
903
|
+
names: names.names,
|
|
904
|
+
nameRanges: names.ranges,
|
|
770
905
|
body: parseExpression(),
|
|
771
906
|
isTemporal,
|
|
772
907
|
location,
|
|
@@ -820,8 +955,8 @@ const parse = (source: string, isTlapm: boolean): Module => {
|
|
|
820
955
|
return { kind: "Name", name: token.text, args: isAt("(") ? parseArguments() : [] };
|
|
821
956
|
};
|
|
822
957
|
|
|
823
|
-
const parsePrimary = (): Expression => {
|
|
824
|
-
const
|
|
958
|
+
const parsePrimary = (preceding?: Precedence): Expression => {
|
|
959
|
+
const start = cursor.index;
|
|
825
960
|
const token = advance();
|
|
826
961
|
const location = getLocation(token);
|
|
827
962
|
if (isTlapm && token.kind === "Keyword" && token.text === "LAMBDA") {
|
|
@@ -845,53 +980,94 @@ const parse = (source: string, isTlapm: boolean): Module => {
|
|
|
845
980
|
if (token.kind === "Identifier" || isStep) {
|
|
846
981
|
const name = isStep ? (getStepName(token) ?? token.text) : token.text;
|
|
847
982
|
if (isLabelAhead()) {
|
|
848
|
-
const params = accept("(") ? parseSeparated(
|
|
849
|
-
if (params.length > 0) expect(")");
|
|
983
|
+
const params = getNames(accept("(") ? parseSeparated(expectName) : []);
|
|
984
|
+
if (params.names.length > 0) expect(")");
|
|
850
985
|
expect("::");
|
|
851
|
-
|
|
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
|
+
};
|
|
852
1005
|
}
|
|
853
1006
|
const hasArguments = isAt("(");
|
|
1007
|
+
if (name === "@" && !hasArguments && !isSelectorAhead())
|
|
1008
|
+
return { kind: "ExceptAt", location };
|
|
854
1009
|
const args = hasArguments ? parseArguments() : [];
|
|
1010
|
+
const argumentRanges = [hasArguments ? lastArguments.range : undefined];
|
|
855
1011
|
if (!isSelectorAhead()) {
|
|
856
1012
|
return hasArguments
|
|
857
|
-
? { kind: "Apply", operator: name, args, location }
|
|
1013
|
+
? { kind: "Apply", operator: name, args, argumentsRange: lastArguments.range, location }
|
|
858
1014
|
: { kind: "Identifier", name, location };
|
|
859
1015
|
}
|
|
860
|
-
const instance = openModules
|
|
861
|
-
.flatMap((module) => module.instances)
|
|
862
|
-
.find((candidate) => candidate.name === name);
|
|
863
|
-
if (instance && !isFactStart && !isTlapm && instance.params.length !== args.length) {
|
|
864
|
-
throw createError(
|
|
865
|
-
`The operator ${name} requires ${instance.params.length} arguments`,
|
|
866
|
-
token,
|
|
867
|
-
);
|
|
868
|
-
}
|
|
869
1016
|
const selectors: Selector[] = [{ kind: "Name", name, args }];
|
|
1017
|
+
const selectorRanges = [getRange(start, start)];
|
|
870
1018
|
while (isSelectorAhead()) {
|
|
871
1019
|
advance();
|
|
1020
|
+
selectorRanges.push(getRange(cursor.index, cursor.index));
|
|
1021
|
+
lastArguments.range = undefined;
|
|
872
1022
|
selectors.push(parseSelector());
|
|
1023
|
+
argumentRanges.push(lastArguments.range);
|
|
873
1024
|
}
|
|
874
1025
|
const names = selectors.flatMap((selector) =>
|
|
875
1026
|
selector.kind === "Name" ? [selector.name] : [],
|
|
876
1027
|
);
|
|
877
|
-
if (names.length < selectors.length) return { kind: "Subexpression", selectors, location };
|
|
878
1028
|
const operator = names.join("!");
|
|
879
1029
|
const qualifiedArgs = selectors.flatMap((selector) =>
|
|
880
1030
|
"args" in selector ? selector.args : [],
|
|
881
1031
|
);
|
|
882
|
-
if (qualifiedArgs.length === 0) return { kind: "Identifier", name: operator, location };
|
|
883
1032
|
const argumentCounts = selectors.map((selector) =>
|
|
884
1033
|
"args" in selector ? selector.args.length : 0,
|
|
885
1034
|
);
|
|
886
|
-
|
|
887
|
-
|
|
888
|
-
|
|
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
|
+
};
|
|
889
1060
|
}
|
|
890
|
-
|
|
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("(")) {
|
|
891
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
|
+
}
|
|
892
1068
|
switch (token.text) {
|
|
893
1069
|
case "(": {
|
|
894
|
-
const expression =
|
|
1070
|
+
const expression = withBracketLayout(() => parseExpression());
|
|
895
1071
|
expect(")");
|
|
896
1072
|
return expression;
|
|
897
1073
|
}
|
|
@@ -947,7 +1123,7 @@ const parse = (source: string, isTlapm: boolean): Module => {
|
|
|
947
1123
|
case "WF_":
|
|
948
1124
|
case "SF_": {
|
|
949
1125
|
const subscript = parseSubscript();
|
|
950
|
-
const action =
|
|
1126
|
+
const action = withBracketLayout(() => {
|
|
951
1127
|
expect("(");
|
|
952
1128
|
const expression = parseExpression();
|
|
953
1129
|
expect(")");
|
|
@@ -964,7 +1140,25 @@ const parse = (source: string, isTlapm: boolean): Module => {
|
|
|
964
1140
|
throw createUnexpected(`Unexpected ${describe(token)}`, token);
|
|
965
1141
|
};
|
|
966
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
|
+
|
|
967
1159
|
const parsePrefix = (): Expression => {
|
|
1160
|
+
const preceding = operators.preceding;
|
|
1161
|
+
operators.preceding = undefined;
|
|
968
1162
|
const token = peek();
|
|
969
1163
|
const location = getLocation(token);
|
|
970
1164
|
if (token.kind === "Operator" && (token.text === "/\\" || token.text === "\\/")) {
|
|
@@ -974,30 +1168,46 @@ const parse = (source: string, isTlapm: boolean): Module => {
|
|
|
974
1168
|
switch (token.text) {
|
|
975
1169
|
case "~":
|
|
976
1170
|
advance();
|
|
977
|
-
return {
|
|
1171
|
+
return {
|
|
1172
|
+
kind: "Apply",
|
|
1173
|
+
operator: "~",
|
|
1174
|
+
args: [parsePrefixOperand(token, 4, 4)],
|
|
1175
|
+
location,
|
|
1176
|
+
};
|
|
978
1177
|
case "-":
|
|
979
1178
|
advance();
|
|
980
|
-
return {
|
|
1179
|
+
return {
|
|
1180
|
+
kind: "Apply",
|
|
1181
|
+
operator: "-.",
|
|
1182
|
+
args: [parsePrefixOperand(token, NEGATION_PRECEDENCE, NEGATION_PRECEDENCE)],
|
|
1183
|
+
location,
|
|
1184
|
+
};
|
|
981
1185
|
case "[]":
|
|
982
1186
|
advance();
|
|
983
|
-
return { kind: "Always", expression:
|
|
1187
|
+
return { kind: "Always", expression: parsePrefixOperand(token, 4, 15), location };
|
|
984
1188
|
case "<>":
|
|
985
1189
|
advance();
|
|
986
|
-
return { kind: "Eventually", expression:
|
|
1190
|
+
return { kind: "Eventually", expression: parsePrefixOperand(token, 4, 15), location };
|
|
987
1191
|
case "ENABLED":
|
|
988
1192
|
advance();
|
|
989
|
-
return { kind: "Enabled", expression:
|
|
1193
|
+
return { kind: "Enabled", expression: parsePrefixOperand(token, 4, 15), location };
|
|
990
1194
|
case "UNCHANGED":
|
|
991
1195
|
advance();
|
|
992
|
-
return { kind: "Unchanged", expression:
|
|
1196
|
+
return { kind: "Unchanged", expression: parsePrefixOperand(token, 4, 15), location };
|
|
993
1197
|
case "SUBSET":
|
|
994
1198
|
case "UNION":
|
|
995
1199
|
case "DOMAIN":
|
|
996
1200
|
advance();
|
|
997
|
-
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
|
+
};
|
|
998
1208
|
}
|
|
999
1209
|
}
|
|
1000
|
-
return parsePrimary();
|
|
1210
|
+
return parsePrimary(preceding);
|
|
1001
1211
|
};
|
|
1002
1212
|
|
|
1003
1213
|
const parseExpression = (minimumPrecedence = 0): Expression => {
|
|
@@ -1013,11 +1223,13 @@ const parse = (source: string, isTlapm: boolean): Module => {
|
|
|
1013
1223
|
const location = getLocation(token);
|
|
1014
1224
|
if (token.text === "'" && minimumPrecedence <= 15) {
|
|
1015
1225
|
advance();
|
|
1226
|
+
operators.last = POSTFIX_PRECEDENCE;
|
|
1016
1227
|
state.left = withRange({ kind: "Prime", expression: state.left, location }, start);
|
|
1017
1228
|
continue;
|
|
1018
1229
|
}
|
|
1019
1230
|
if (POSTFIX_OPERATORS.has(token.text) && minimumPrecedence <= 15) {
|
|
1020
1231
|
advance();
|
|
1232
|
+
operators.last = POSTFIX_PRECEDENCE;
|
|
1021
1233
|
state.left = withRange(
|
|
1022
1234
|
{ kind: "Apply", operator: token.text, args: [state.left], location },
|
|
1023
1235
|
start,
|
|
@@ -1026,8 +1238,9 @@ const parse = (source: string, isTlapm: boolean): Module => {
|
|
|
1026
1238
|
}
|
|
1027
1239
|
if (token.text === "[") {
|
|
1028
1240
|
advance();
|
|
1029
|
-
const args =
|
|
1030
|
-
|
|
1241
|
+
const args = withBracketLayout(() => parseSeparated(() => parseExpression()));
|
|
1242
|
+
withBracketLayout(() => expect("]"));
|
|
1243
|
+
operators.last = FUNCTION_PRECEDENCE;
|
|
1031
1244
|
state.left = withRange(
|
|
1032
1245
|
{ kind: "FunctionApplication", function: state.left, args, location },
|
|
1033
1246
|
start,
|
|
@@ -1054,21 +1267,37 @@ const parse = (source: string, isTlapm: boolean): Module => {
|
|
|
1054
1267
|
}
|
|
1055
1268
|
}
|
|
1056
1269
|
advance();
|
|
1270
|
+
// SANY reads - after an infix operator as prefix -, and rejects it after one that binds tighter.
|
|
1271
|
+
if (infix.low > NEGATION_PRECEDENCE && isAt("-")) {
|
|
1272
|
+
throw createError(`Precedence conflict between ${token.text} and -`, peek());
|
|
1273
|
+
}
|
|
1274
|
+
operators.last = operators.preceding = infix;
|
|
1057
1275
|
const right = parseExpression(infix.high + 1);
|
|
1058
1276
|
const left = state.left;
|
|
1059
1277
|
if (token.text === "/\\" || token.text === "\\/") {
|
|
1060
1278
|
const kind = token.text === "/\\" ? "And" : "Or";
|
|
1279
|
+
const prefixEnds = [getRange(start).end];
|
|
1061
1280
|
state.left =
|
|
1062
1281
|
left.kind === kind && previous?.text === token.text
|
|
1063
|
-
? {
|
|
1064
|
-
|
|
1282
|
+
? {
|
|
1283
|
+
...left,
|
|
1284
|
+
operands: [...left.operands, right],
|
|
1285
|
+
prefixEnds: [...(left.prefixEnds ?? []), ...prefixEnds],
|
|
1286
|
+
}
|
|
1287
|
+
: { kind, operands: [left, right], prefixEnds, location };
|
|
1065
1288
|
} else if (token.text === "\\X") {
|
|
1066
1289
|
state.left =
|
|
1067
1290
|
left.kind === "Product" && previous?.text === "\\X"
|
|
1068
1291
|
? { ...left, factors: [...left.factors, right] }
|
|
1069
1292
|
: { kind: "Product", factors: [left, right], location };
|
|
1070
1293
|
} else {
|
|
1071
|
-
state.left = {
|
|
1294
|
+
state.left = {
|
|
1295
|
+
kind: "Apply",
|
|
1296
|
+
operator: token.text,
|
|
1297
|
+
spelling: token.spelling,
|
|
1298
|
+
args: [left, right],
|
|
1299
|
+
location,
|
|
1300
|
+
};
|
|
1072
1301
|
}
|
|
1073
1302
|
state.left = withRange(state.left, start);
|
|
1074
1303
|
state.previous = { ...infix, text: token.text };
|
|
@@ -1088,7 +1317,7 @@ const parse = (source: string, isTlapm: boolean): Module => {
|
|
|
1088
1317
|
const body = parseExpression();
|
|
1089
1318
|
const last = tokens[cursor.index - 1];
|
|
1090
1319
|
const end = { line: last.line, column: last.endColumn };
|
|
1091
|
-
return { body, bodyRange: { module: openModules[
|
|
1320
|
+
return { body, bodyRange: { module: openModules[0].name, start, end } };
|
|
1092
1321
|
};
|
|
1093
1322
|
|
|
1094
1323
|
const parseDefinition = (isLocal: boolean): Definition | Instance => {
|
|
@@ -1096,6 +1325,16 @@ const parse = (source: string, isTlapm: boolean): Module => {
|
|
|
1096
1325
|
return withRange(parseDefinitionUnit(isLocal), start);
|
|
1097
1326
|
};
|
|
1098
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
|
+
|
|
1099
1338
|
const parseDefinitionUnit = (isLocal: boolean): Definition | Instance => {
|
|
1100
1339
|
const token = peek();
|
|
1101
1340
|
const location = getLocation(token);
|
|
@@ -1115,28 +1354,27 @@ const parse = (source: string, isTlapm: boolean): Module => {
|
|
|
1115
1354
|
peek(2).kind === "Identifier" &&
|
|
1116
1355
|
isAt("==", 3)
|
|
1117
1356
|
) {
|
|
1118
|
-
const left =
|
|
1357
|
+
const left = expectName();
|
|
1119
1358
|
const operator = advance().text;
|
|
1120
|
-
const right =
|
|
1359
|
+
const right = expectName();
|
|
1121
1360
|
expect("==");
|
|
1122
|
-
return parseOperator(operator, [
|
|
1123
|
-
{ name: left, arity: 0 },
|
|
1124
|
-
{ name: right, arity: 0 },
|
|
1125
|
-
]);
|
|
1361
|
+
return parseOperator(operator, [toParam(left), toParam(right)]);
|
|
1126
1362
|
}
|
|
1127
|
-
const isPrefixDefinition =
|
|
1363
|
+
const isPrefixDefinition =
|
|
1364
|
+
token.kind !== "String" && DEFINABLE_PREFIX_OPERATORS.has(token.text);
|
|
1128
1365
|
const isPostfixDefinition =
|
|
1129
1366
|
token.kind === "Identifier" && POSTFIX_OPERATORS.has(peek(1).text) && isAt("==", 2);
|
|
1130
1367
|
if (isPrefixDefinition || isPostfixDefinition) {
|
|
1131
1368
|
const operator = isPrefixDefinition ? token.text : peek(1).text;
|
|
1132
|
-
|
|
1133
|
-
const param =
|
|
1369
|
+
if (isPrefixDefinition) advance();
|
|
1370
|
+
const param = expectName();
|
|
1371
|
+
if (isPostfixDefinition) advance();
|
|
1134
1372
|
expect("==");
|
|
1135
|
-
return parseOperator(operator, [
|
|
1373
|
+
return parseOperator(operator, [toParam(param)]);
|
|
1136
1374
|
}
|
|
1137
1375
|
const name = expectIdentifier();
|
|
1138
1376
|
if (accept("[")) {
|
|
1139
|
-
const bounds =
|
|
1377
|
+
const bounds = withBracketLayout(() => parseBounds());
|
|
1140
1378
|
expect("]");
|
|
1141
1379
|
expect("==");
|
|
1142
1380
|
return {
|
|
@@ -1167,12 +1405,14 @@ const parse = (source: string, isTlapm: boolean): Module => {
|
|
|
1167
1405
|
): Instance => {
|
|
1168
1406
|
const start = cursor.index;
|
|
1169
1407
|
expect("INSTANCE");
|
|
1170
|
-
const module =
|
|
1408
|
+
const module = expectModuleName();
|
|
1171
1409
|
const substitutions = accept("WITH")
|
|
1172
1410
|
? parseSeparated(() => {
|
|
1173
|
-
const
|
|
1411
|
+
const targetStart = cursor.index;
|
|
1412
|
+
const target = expectSubstitutionTarget();
|
|
1413
|
+
const nameRange = getRange(targetStart);
|
|
1174
1414
|
expect("<-");
|
|
1175
|
-
return { name: target, expression: parseArgument() };
|
|
1415
|
+
return { name: target, nameRange, expression: parseArgument() };
|
|
1176
1416
|
})
|
|
1177
1417
|
: [];
|
|
1178
1418
|
return {
|
|
@@ -1188,6 +1428,11 @@ const parse = (source: string, isTlapm: boolean): Module => {
|
|
|
1188
1428
|
};
|
|
1189
1429
|
|
|
1190
1430
|
const parseDeclaration = (): Declaration => {
|
|
1431
|
+
const start = cursor.index;
|
|
1432
|
+
return withRange(parseDeclarationUnit(), start);
|
|
1433
|
+
};
|
|
1434
|
+
|
|
1435
|
+
const parseDeclarationUnit = (): Declaration => {
|
|
1191
1436
|
const location = getLocation(peek());
|
|
1192
1437
|
if (isAt("_") && peek(1).kind === "Operator") {
|
|
1193
1438
|
advance();
|
|
@@ -1233,7 +1478,12 @@ const parse = (source: string, isTlapm: boolean): Module => {
|
|
|
1233
1478
|
const token = peek();
|
|
1234
1479
|
const next = peek(1);
|
|
1235
1480
|
if (token.kind !== "Identifier") {
|
|
1236
|
-
return
|
|
1481
|
+
return (
|
|
1482
|
+
token.kind !== "String" &&
|
|
1483
|
+
DEFINABLE_PREFIX_OPERATORS.has(token.text) &&
|
|
1484
|
+
next.kind === "Identifier" &&
|
|
1485
|
+
isAt("==", 2)
|
|
1486
|
+
);
|
|
1237
1487
|
}
|
|
1238
1488
|
if (isAt("(", 1) || isAt("[", 1)) return isAt("==", getClosingOffset(1));
|
|
1239
1489
|
if (next.kind === "Operator" && POSTFIX_OPERATORS.has(next.text)) return isAt("==", 2);
|
|
@@ -1325,7 +1575,6 @@ const parse = (source: string, isTlapm: boolean): Module => {
|
|
|
1325
1575
|
// start of an expression.
|
|
1326
1576
|
const parseFact = (): Fact => {
|
|
1327
1577
|
const start = cursor.index;
|
|
1328
|
-
factStart.index = start;
|
|
1329
1578
|
const token = peek();
|
|
1330
1579
|
if (
|
|
1331
1580
|
token.kind === "Operator" &&
|
|
@@ -1387,7 +1636,10 @@ const parse = (source: string, isTlapm: boolean): Module => {
|
|
|
1387
1636
|
const parseDefs = () => {
|
|
1388
1637
|
if (isTlapm) return parseSeparated(parseDefinable);
|
|
1389
1638
|
const defs = parseSeparated(parseFact);
|
|
1390
|
-
const invalid =
|
|
1639
|
+
const invalid =
|
|
1640
|
+
mode === "tlc"
|
|
1641
|
+
? defs.find((def) => def.kind === "Identifier" && isDeclaredSymbol(def.name))
|
|
1642
|
+
: undefined;
|
|
1391
1643
|
if (invalid) {
|
|
1392
1644
|
throw createError("DEF clause entry should describe a defined operator", invalid.location);
|
|
1393
1645
|
}
|
|
@@ -1412,11 +1664,14 @@ const parse = (source: string, isTlapm: boolean): Module => {
|
|
|
1412
1664
|
location: getLocation(keyword),
|
|
1413
1665
|
};
|
|
1414
1666
|
const invalid =
|
|
1415
|
-
use.kind === "Hide" &&
|
|
1416
|
-
if (invalid) {
|
|
1417
|
-
throw
|
|
1418
|
-
|
|
1419
|
-
|
|
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
|
+
})),
|
|
1420
1675
|
);
|
|
1421
1676
|
}
|
|
1422
1677
|
return withRange(use, start);
|
|
@@ -1432,10 +1687,18 @@ const parse = (source: string, isTlapm: boolean): Module => {
|
|
|
1432
1687
|
}
|
|
1433
1688
|
if (level !== undefined) advance();
|
|
1434
1689
|
if (level === "Variable") {
|
|
1435
|
-
const
|
|
1436
|
-
declareProofSymbol(name);
|
|
1690
|
+
const named = expectName();
|
|
1691
|
+
declareProofSymbol(named.name);
|
|
1437
1692
|
return withRange(
|
|
1438
|
-
{
|
|
1693
|
+
{
|
|
1694
|
+
kind: "NewSymbol",
|
|
1695
|
+
name: named.name,
|
|
1696
|
+
arity: 0,
|
|
1697
|
+
level,
|
|
1698
|
+
set: undefined,
|
|
1699
|
+
nameRange: named.range,
|
|
1700
|
+
location,
|
|
1701
|
+
},
|
|
1439
1702
|
start,
|
|
1440
1703
|
);
|
|
1441
1704
|
}
|
|
@@ -1453,6 +1716,7 @@ const parse = (source: string, isTlapm: boolean): Module => {
|
|
|
1453
1716
|
arity: declaration.arity,
|
|
1454
1717
|
level: level ?? "Constant",
|
|
1455
1718
|
set: isBounded ? parseExpression() : undefined,
|
|
1719
|
+
nameRange: declaration.location.range,
|
|
1456
1720
|
location,
|
|
1457
1721
|
},
|
|
1458
1722
|
start,
|
|
@@ -1495,7 +1759,8 @@ const parse = (source: string, isTlapm: boolean): Module => {
|
|
|
1495
1759
|
const token = peek();
|
|
1496
1760
|
if (isAt("USE") || isAt("HIDE")) return parseUseOrHide();
|
|
1497
1761
|
if (isAt("INSTANCE")) {
|
|
1498
|
-
|
|
1762
|
+
const start = cursor.index;
|
|
1763
|
+
return withRange(parseInstance(undefined, [], false, getLocation(token)), start);
|
|
1499
1764
|
}
|
|
1500
1765
|
if (isAt("DEFINE") || isDefinitionStart()) {
|
|
1501
1766
|
const start = cursor.index;
|
|
@@ -1508,21 +1773,27 @@ const parse = (source: string, isTlapm: boolean): Module => {
|
|
|
1508
1773
|
if (accept("HAVE")) return { kind: "Have", expression: parseExpression() };
|
|
1509
1774
|
if (accept("TAKE")) {
|
|
1510
1775
|
const isBounded = isBoundAhead();
|
|
1511
|
-
const names = isBounded ? [] : parseSeparated(
|
|
1776
|
+
const names = getNames(isBounded ? [] : parseSeparated(expectName));
|
|
1512
1777
|
const bounds = isBounded ? parseBounds() : [];
|
|
1513
|
-
declareProofSymbols(names, bounds);
|
|
1514
|
-
return { kind: "Take", names, bounds };
|
|
1778
|
+
declareProofSymbols(names.names, bounds);
|
|
1779
|
+
return { kind: "Take", names: names.names, nameRanges: names.ranges, bounds };
|
|
1515
1780
|
}
|
|
1516
1781
|
if (accept("WITNESS")) {
|
|
1517
1782
|
return { kind: "Witness", expressions: parseSeparated(() => parseExpression()) };
|
|
1518
1783
|
}
|
|
1519
1784
|
if (accept("PICK")) {
|
|
1520
1785
|
const isNames = isNameListAhead(":");
|
|
1521
|
-
const names = isNames ? parseSeparated(
|
|
1786
|
+
const names = getNames(isNames ? parseSeparated(expectName) : []);
|
|
1522
1787
|
const bounds = isNames ? [] : parseBounds();
|
|
1523
|
-
declareProofSymbols(names, bounds);
|
|
1788
|
+
declareProofSymbols(names.names, bounds);
|
|
1524
1789
|
expect(":");
|
|
1525
|
-
return {
|
|
1790
|
+
return {
|
|
1791
|
+
kind: "Pick",
|
|
1792
|
+
names: names.names,
|
|
1793
|
+
nameRanges: names.ranges,
|
|
1794
|
+
bounds,
|
|
1795
|
+
body: parseExpression(),
|
|
1796
|
+
};
|
|
1526
1797
|
}
|
|
1527
1798
|
if (accept("CASE")) return { kind: "Case", expression: parseExpression() };
|
|
1528
1799
|
return {
|
|
@@ -1552,10 +1823,12 @@ const parse = (source: string, isTlapm: boolean): Module => {
|
|
|
1552
1823
|
const parseStep = (): ProofStep => {
|
|
1553
1824
|
const start = cursor.index;
|
|
1554
1825
|
const step = parseStepStart(isAt("QED", 1));
|
|
1826
|
+
const statementStart = cursor.index;
|
|
1555
1827
|
const scope = new Set<string>();
|
|
1556
1828
|
proofScopes.push(scope);
|
|
1557
1829
|
const body: StepBody = accept("QED") ? { kind: "Qed" } : parseStepBody();
|
|
1558
1830
|
const head = getRange(start);
|
|
1831
|
+
const statement = getRange(statementStart);
|
|
1559
1832
|
const hasProof = isProofStart(peek());
|
|
1560
1833
|
if (hasProof && !PROVABLE_STEPS.has(body.kind)) {
|
|
1561
1834
|
throw createError("Proof of a step that does not take a proof");
|
|
@@ -1563,7 +1836,7 @@ const parse = (source: string, isTlapm: boolean): Module => {
|
|
|
1563
1836
|
const proof = hasProof ? parseProof() : undefined;
|
|
1564
1837
|
proofScopes.pop();
|
|
1565
1838
|
if (body.kind !== "Assert" || body.isSuffices) scope.forEach(declareProofSymbol);
|
|
1566
|
-
return withRange({ ...step, body, head, proof }, start);
|
|
1839
|
+
return withRange({ ...step, body, head, statement, proof }, start);
|
|
1567
1840
|
};
|
|
1568
1841
|
|
|
1569
1842
|
const parseProofBody = (): Proof => {
|
|
@@ -1598,6 +1871,13 @@ const parse = (source: string, isTlapm: boolean): Module => {
|
|
|
1598
1871
|
return withRange(proof, start);
|
|
1599
1872
|
};
|
|
1600
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
|
+
|
|
1601
1881
|
const parseTheorem = (module: Module) => {
|
|
1602
1882
|
const start = cursor.index;
|
|
1603
1883
|
const keyword = advance();
|
|
@@ -1619,7 +1899,8 @@ const parse = (source: string, isTlapm: boolean): Module => {
|
|
|
1619
1899
|
module.theorems.push(theorem);
|
|
1620
1900
|
module.units.push({ kind: "Theorem", theorem });
|
|
1621
1901
|
if (name === undefined || statement.kind === "AssumeProve") return;
|
|
1622
|
-
|
|
1902
|
+
addFactDefinition(
|
|
1903
|
+
module,
|
|
1623
1904
|
withRange(
|
|
1624
1905
|
{
|
|
1625
1906
|
kind: "Operator",
|
|
@@ -1656,7 +1937,7 @@ const parse = (source: string, isTlapm: boolean): Module => {
|
|
|
1656
1937
|
const parseModuleBody = (): Module => {
|
|
1657
1938
|
const location = getLocation(expect("----"));
|
|
1658
1939
|
expect("MODULE");
|
|
1659
|
-
const name =
|
|
1940
|
+
const name = expectModuleName();
|
|
1660
1941
|
expect("----");
|
|
1661
1942
|
const module: Module = {
|
|
1662
1943
|
name,
|
|
@@ -1678,7 +1959,7 @@ const parse = (source: string, isTlapm: boolean): Module => {
|
|
|
1678
1959
|
if (accept("EXTENDS")) {
|
|
1679
1960
|
parseSeparated(() => {
|
|
1680
1961
|
const start = cursor.index;
|
|
1681
|
-
module.extends.push(
|
|
1962
|
+
module.extends.push(expectModuleName());
|
|
1682
1963
|
module.extendsRanges.push(getRange(start));
|
|
1683
1964
|
});
|
|
1684
1965
|
}
|
|
@@ -1686,14 +1967,12 @@ const parse = (source: string, isTlapm: boolean): Module => {
|
|
|
1686
1967
|
const tokenIndex = cursor.index;
|
|
1687
1968
|
unitStart.index = tokenIndex;
|
|
1688
1969
|
const token = peek();
|
|
1689
|
-
if (token.kind === "ModuleEnd"
|
|
1690
|
-
|
|
1691
|
-
|
|
1692
|
-
|
|
1693
|
-
|
|
1694
|
-
|
|
1695
|
-
};
|
|
1696
|
-
}
|
|
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
|
+
};
|
|
1697
1976
|
openModules.pop();
|
|
1698
1977
|
recursiveScopes.pop();
|
|
1699
1978
|
return module;
|
|
@@ -1712,22 +1991,24 @@ const parse = (source: string, isTlapm: boolean): Module => {
|
|
|
1712
1991
|
switch (token.text) {
|
|
1713
1992
|
case "CONSTANT":
|
|
1714
1993
|
case "CONSTANTS": {
|
|
1715
|
-
advance();
|
|
1994
|
+
const unitLocation = getLocation(advance());
|
|
1716
1995
|
const declarations = parseDeclarations();
|
|
1717
1996
|
module.constants.push(...declarations);
|
|
1718
|
-
|
|
1997
|
+
unitLocation.range = getRange(tokenIndex);
|
|
1998
|
+
module.units.push({ kind: "Constants", declarations, location: unitLocation });
|
|
1719
1999
|
continue;
|
|
1720
2000
|
}
|
|
1721
2001
|
case "VARIABLE":
|
|
1722
2002
|
case "VARIABLES": {
|
|
1723
|
-
advance();
|
|
2003
|
+
const unitLocation = getLocation(advance());
|
|
1724
2004
|
const declarations = parseSeparated(() => {
|
|
1725
2005
|
const start = cursor.index;
|
|
1726
2006
|
const location = getLocation(peek());
|
|
1727
2007
|
return withRange({ name: expectIdentifier(), arity: 0, location }, start);
|
|
1728
2008
|
});
|
|
1729
2009
|
module.variables.push(...declarations);
|
|
1730
|
-
|
|
2010
|
+
unitLocation.range = getRange(tokenIndex);
|
|
2011
|
+
module.units.push({ kind: "Variables", declarations, location: unitLocation });
|
|
1731
2012
|
continue;
|
|
1732
2013
|
}
|
|
1733
2014
|
case "ASSUME":
|
|
@@ -1737,7 +2018,7 @@ const parse = (source: string, isTlapm: boolean): Module => {
|
|
|
1737
2018
|
module.assumptions.push(assumption);
|
|
1738
2019
|
module.units.push({ kind: "Assumption", assumption });
|
|
1739
2020
|
if (assumption.name !== undefined) {
|
|
1740
|
-
module
|
|
2021
|
+
addFactDefinition(module, {
|
|
1741
2022
|
kind: "Operator",
|
|
1742
2023
|
name: assumption.name,
|
|
1743
2024
|
params: [],
|
|
@@ -1751,6 +2032,10 @@ const parse = (source: string, isTlapm: boolean): Module => {
|
|
|
1751
2032
|
}
|
|
1752
2033
|
case "USE":
|
|
1753
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
|
+
}
|
|
1754
2039
|
const use = parseUseOrHide();
|
|
1755
2040
|
module.uses.push(use);
|
|
1756
2041
|
module.units.push({ kind: "Use", use });
|
|
@@ -1775,7 +2060,7 @@ const parse = (source: string, isTlapm: boolean): Module => {
|
|
|
1775
2060
|
);
|
|
1776
2061
|
continue;
|
|
1777
2062
|
}
|
|
1778
|
-
addDefinitionUnit(module,
|
|
2063
|
+
addDefinitionUnit(module, withRange(parseDefinitionUnit(true), tokenIndex));
|
|
1779
2064
|
continue;
|
|
1780
2065
|
}
|
|
1781
2066
|
}
|
|
@@ -1797,9 +2082,16 @@ const parse = (source: string, isTlapm: boolean): Module => {
|
|
|
1797
2082
|
module.units.push({ kind: "Definition", definition: unit });
|
|
1798
2083
|
};
|
|
1799
2084
|
|
|
1800
|
-
|
|
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;
|
|
1801
2091
|
};
|
|
1802
2092
|
|
|
1803
|
-
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");
|
|
1804
2096
|
|
|
1805
|
-
export const
|
|
2097
|
+
export const parseSanyModule = (source: string) => parse(source, "sany");
|