tla-ts 0.0.3-dev.a85c0bd → 0.0.3-dev.ab42bab
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/index.d.cts +18 -1
- package/dist/index.d.ts +18 -1
- package/dist/run-cli.cjs +5 -3
- package/dist/run-cli.js +20 -18
- package/dist/transfer.cjs +23 -17
- package/dist/transfer.js +23 -17
- package/package.json +1 -1
- package/src/ast.ts +3 -0
- package/src/check.ts +142 -22
- package/src/config.ts +224 -170
- package/src/environment.ts +23 -5
- package/src/errors.ts +41 -1
- package/src/evaluate.ts +38 -9
- package/src/instances.ts +1 -1
- package/src/levels.ts +55 -27
- package/src/liveness.ts +5 -1
- package/src/parser.ts +21 -10
- package/src/resolve.ts +106 -29
- package/src/run-cli.ts +36 -8
- package/src/spec-description.ts +1 -2
- package/src/successors.ts +49 -12
- package/src/values.ts +3 -1
package/src/evaluate.ts
CHANGED
|
@@ -10,10 +10,9 @@ import {
|
|
|
10
10
|
type NumberExpression,
|
|
11
11
|
type OperatorParam,
|
|
12
12
|
type RecordField,
|
|
13
|
-
type SourceRange,
|
|
14
13
|
} from "./ast";
|
|
15
14
|
import { getKindString } from "./builtins";
|
|
16
|
-
import { TlaEvaluationError } from "./errors";
|
|
15
|
+
import { formatRange, TlaEvaluationError } from "./errors";
|
|
17
16
|
import { EXIT_STATUS, setExitCode, setOwnExitCode } from "./exit-codes";
|
|
18
17
|
import { generateEvaluator } from "./codegen";
|
|
19
18
|
import type { CheckerRuntime } from "./runtime";
|
|
@@ -49,6 +48,7 @@ import {
|
|
|
49
48
|
toFiniteSet,
|
|
50
49
|
updateFunction,
|
|
51
50
|
valuesEqual,
|
|
51
|
+
type FilteredSetValue,
|
|
52
52
|
type FunctionValue,
|
|
53
53
|
type LazyFunctionSource,
|
|
54
54
|
type LazyFunctionValue,
|
|
@@ -117,6 +117,7 @@ export interface Environment {
|
|
|
117
117
|
definitionValues: Map<Definition, Value>;
|
|
118
118
|
constantLevels: Map<Definition, boolean>;
|
|
119
119
|
evaluators: WeakMap<Expression, Evaluator>;
|
|
120
|
+
trace?: Expression[];
|
|
120
121
|
}
|
|
121
122
|
|
|
122
123
|
export interface Context {
|
|
@@ -146,9 +147,6 @@ const EXCEPT_AT = "@";
|
|
|
146
147
|
export const describeLocation = (expression: Expression) =>
|
|
147
148
|
`line ${expression.location.line}, column ${expression.location.column}`;
|
|
148
149
|
|
|
149
|
-
export const formatRange = (range: SourceRange) =>
|
|
150
|
-
`line ${range.start.line}, col ${range.start.column} to line ${range.end.line}, col ${range.end.column} of module ${range.module}`;
|
|
151
|
-
|
|
152
150
|
export const describeRange = (expression: Expression) => {
|
|
153
151
|
const range = expression.location.range;
|
|
154
152
|
return range ? formatRange(range) : describeLocation(expression);
|
|
@@ -1023,16 +1021,38 @@ const isStateCached = (expression: Expression, environment: Environment) =>
|
|
|
1023
1021
|
getReadVariables(expression, environment) !== undefined &&
|
|
1024
1022
|
!hasFreeLocals(expression, NO_BOUND_NAMES);
|
|
1025
1023
|
|
|
1024
|
+
// CallStackTool also evaluates the predicate of a lazy set filter it returns, even one that TLC
|
|
1025
|
+
// made before the replay.
|
|
1026
|
+
const filteredSetRetracers = new WeakMap<
|
|
1027
|
+
FilteredSetValue,
|
|
1028
|
+
(environment: Environment) => FilteredSetValue
|
|
1029
|
+
>();
|
|
1030
|
+
|
|
1026
1031
|
export const getEvaluator = (expression: Expression, environment: Environment): Evaluator => {
|
|
1027
1032
|
const cached = environment.evaluators.get(expression);
|
|
1028
1033
|
if (cached) return cached;
|
|
1029
1034
|
const compiled = compile(expression, environment);
|
|
1030
|
-
const
|
|
1035
|
+
const cachedEvaluator =
|
|
1031
1036
|
isWorthCaching(expression) && isClosedConstant(expression, environment)
|
|
1032
1037
|
? cacheFirstValue(compiled)
|
|
1033
1038
|
: isStateCached(expression, environment)
|
|
1034
1039
|
? cacheStateValue(compiled)
|
|
1035
1040
|
: compiled;
|
|
1041
|
+
const trace = environment.trace;
|
|
1042
|
+
// TLC's CallStackTool pushes each expression it evaluates and keeps the stack when one fails.
|
|
1043
|
+
const evaluator: Evaluator = trace
|
|
1044
|
+
? (context) => {
|
|
1045
|
+
const depth = trace.length;
|
|
1046
|
+
trace.push(expression);
|
|
1047
|
+
const value = cachedEvaluator(context);
|
|
1048
|
+
trace.length = depth;
|
|
1049
|
+
const retrace =
|
|
1050
|
+
typeof value === "object" && value.kind === "FilteredSet"
|
|
1051
|
+
? filteredSetRetracers.get(value)
|
|
1052
|
+
: undefined;
|
|
1053
|
+
return retrace ? retrace(environment) : value;
|
|
1054
|
+
}
|
|
1055
|
+
: cachedEvaluator;
|
|
1036
1056
|
environment.evaluators.set(expression, evaluator);
|
|
1037
1057
|
return evaluator;
|
|
1038
1058
|
};
|
|
@@ -1040,6 +1060,7 @@ export const getEvaluator = (expression: Expression, environment: Environment):
|
|
|
1040
1060
|
const entryEvaluators = new WeakMap<Expression, Evaluator>();
|
|
1041
1061
|
|
|
1042
1062
|
export const getEntryEvaluator = (expression: Expression, environment: Environment) => {
|
|
1063
|
+
if (environment.trace) return getEvaluator(expression, environment);
|
|
1043
1064
|
const cached = entryEvaluators.get(expression);
|
|
1044
1065
|
if (cached) return cached;
|
|
1045
1066
|
const evaluator =
|
|
@@ -1532,13 +1553,21 @@ const compileSetComprehension = (
|
|
|
1532
1553
|
const pattern = expression.bound.pattern;
|
|
1533
1554
|
return (context) => {
|
|
1534
1555
|
const base = set(context);
|
|
1535
|
-
const
|
|
1556
|
+
const getTest = (evaluatePredicate: Evaluator) => (element: Value) =>
|
|
1536
1557
|
expectBoolean(
|
|
1537
|
-
|
|
1558
|
+
evaluatePredicate(withScope(context, bindPattern(context.scope, pattern, element))),
|
|
1538
1559
|
"a set filter predicate",
|
|
1539
1560
|
);
|
|
1561
|
+
const test = getTest(predicate);
|
|
1540
1562
|
if (!isReducible(base)) {
|
|
1541
|
-
if (isSetValue(base))
|
|
1563
|
+
if (isSetValue(base)) {
|
|
1564
|
+
const filtered: FilteredSetValue = { kind: "FilteredSet", base, test };
|
|
1565
|
+
filteredSetRetracers.set(filtered, (traced) => ({
|
|
1566
|
+
...filtered,
|
|
1567
|
+
test: getTest(getEvaluator(expression.predicate, traced)),
|
|
1568
|
+
}));
|
|
1569
|
+
return filtered;
|
|
1570
|
+
}
|
|
1542
1571
|
throw new TlaEvaluationError(
|
|
1543
1572
|
`TLC encountered a non-enumerable quantifier bound ${formatValue(base)} at ${describeLocation(expression.bound.set)}`,
|
|
1544
1573
|
);
|
package/src/instances.ts
CHANGED
|
@@ -164,7 +164,7 @@ export const mapChildren = (
|
|
|
164
164
|
case "RecordSet":
|
|
165
165
|
return {
|
|
166
166
|
...expression,
|
|
167
|
-
fields: expression.fields.map((field) => ({
|
|
167
|
+
fields: expression.fields.map((field) => ({ ...field, value: plain(field.value) })),
|
|
168
168
|
};
|
|
169
169
|
case "Except":
|
|
170
170
|
return {
|
package/src/levels.ts
CHANGED
|
@@ -5,11 +5,10 @@ import {
|
|
|
5
5
|
type Expression,
|
|
6
6
|
type Module,
|
|
7
7
|
type OperatorParam,
|
|
8
|
-
type SourceLocation,
|
|
9
8
|
} from "./ast";
|
|
10
|
-
import { TlaSyntaxError } from "./errors";
|
|
9
|
+
import { createSemanticError, TlaSyntaxError } from "./errors";
|
|
11
10
|
import { mapChildren } from "./instances";
|
|
12
|
-
import { getBoundNames, getPatternNames } from "./resolve";
|
|
11
|
+
import { collectSemanticErrors, getBoundNames, getPatternNames } from "./resolve";
|
|
13
12
|
import { STANDARD_LEVELS } from "./standard-levels";
|
|
14
13
|
|
|
15
14
|
interface LevelData {
|
|
@@ -176,8 +175,13 @@ export const ACTION_LEVEL = 2;
|
|
|
176
175
|
|
|
177
176
|
export const TEMPORAL_LEVEL = 3;
|
|
178
177
|
|
|
179
|
-
|
|
180
|
-
|
|
178
|
+
// SANY reports a level error at the range of the expression it rejects.
|
|
179
|
+
const createLevelError = (message: string, expression: Expression) =>
|
|
180
|
+
expression.location.range
|
|
181
|
+
? createSemanticError(`${message}.`, expression.location.range)
|
|
182
|
+
: new TlaSyntaxError(
|
|
183
|
+
`${message} at line ${expression.location.line}, column ${expression.location.column}`,
|
|
184
|
+
);
|
|
181
185
|
|
|
182
186
|
const LOGICAL_OPERATORS = new Set(["/\\", "\\/", "=>", "<=>"]);
|
|
183
187
|
|
|
@@ -237,13 +241,13 @@ export const createLevelAnalyzer = (context: LevelContext) => {
|
|
|
237
241
|
if (operand.operator || operand.declared) return;
|
|
238
242
|
if (operand.data.level > getMaxLevel(operator, index)) {
|
|
239
243
|
throw new TlaSyntaxError(
|
|
240
|
-
`Level error in applying operator ${operator.name}
|
|
244
|
+
`Level error in applying operator ${operator.name}:\nThe level of argument ${index + 1} exceeds the maximum level allowed by the operator`,
|
|
241
245
|
);
|
|
242
246
|
}
|
|
243
247
|
});
|
|
244
248
|
if (ranges.some((range) => range.level > ACTION_LEVEL)) {
|
|
245
249
|
throw new TlaSyntaxError(
|
|
246
|
-
`Level error in applying operator ${operator.name}
|
|
250
|
+
`Level error in applying operator ${operator.name}:\nThe level of the range for a bounded variable exceeds the maximum level allowed by the operator`,
|
|
247
251
|
);
|
|
248
252
|
}
|
|
249
253
|
const getOperand = (formal: string) => {
|
|
@@ -444,10 +448,13 @@ export const createLevelAnalyzer = (context: LevelContext) => {
|
|
|
444
448
|
? applyDeclared(resolved.name, resolved.level, operands)
|
|
445
449
|
: applyDefined(resolved.levels, operands);
|
|
446
450
|
|
|
447
|
-
const checkJunction = (operands: Operand[],
|
|
451
|
+
const checkJunction = (operands: Operand[], expression: Expression) => {
|
|
448
452
|
const levels = operands.map((operand) => operand.data.level);
|
|
449
453
|
if (levels.includes(ACTION_LEVEL) && levels.includes(TEMPORAL_LEVEL)) {
|
|
450
|
-
throw createLevelError(
|
|
454
|
+
throw createLevelError(
|
|
455
|
+
"Formula has both temporal formula and action as arguments",
|
|
456
|
+
expression,
|
|
457
|
+
);
|
|
451
458
|
}
|
|
452
459
|
};
|
|
453
460
|
|
|
@@ -456,10 +463,10 @@ export const createLevelAnalyzer = (context: LevelContext) => {
|
|
|
456
463
|
if (isLeadsTo && operands.some((operand) => operand.data.level === ACTION_LEVEL)) {
|
|
457
464
|
throw createLevelError(
|
|
458
465
|
"Action used where only temporal formula or state predicate allowed",
|
|
459
|
-
expression
|
|
466
|
+
expression,
|
|
460
467
|
);
|
|
461
468
|
}
|
|
462
|
-
if (LOGICAL_OPERATORS.has(expression.operator)) checkJunction(operands, expression
|
|
469
|
+
if (LOGICAL_OPERATORS.has(expression.operator)) checkJunction(operands, expression);
|
|
463
470
|
};
|
|
464
471
|
|
|
465
472
|
const checkTemporal = (
|
|
@@ -473,7 +480,7 @@ export const createLevelAnalyzer = (context: LevelContext) => {
|
|
|
473
480
|
expression.kind === "Always"
|
|
474
481
|
? "[] followed by action not of form [A]_v"
|
|
475
482
|
: "<> followed by action not of form <<A>>_v",
|
|
476
|
-
expression
|
|
483
|
+
expression,
|
|
477
484
|
);
|
|
478
485
|
};
|
|
479
486
|
|
|
@@ -501,7 +508,17 @@ export const createLevelAnalyzer = (context: LevelContext) => {
|
|
|
501
508
|
return data;
|
|
502
509
|
};
|
|
503
510
|
|
|
511
|
+
// SANY reports a level error of an operator's arguments at the application.
|
|
504
512
|
const analyze = (expression: Expression, scope: Scope): LevelData => {
|
|
513
|
+
try {
|
|
514
|
+
return analyzeNode(expression, scope);
|
|
515
|
+
} catch (error) {
|
|
516
|
+
if (!(error instanceof TlaSyntaxError) || error.sany) throw error;
|
|
517
|
+
throw createLevelError(error.message, expression);
|
|
518
|
+
}
|
|
519
|
+
};
|
|
520
|
+
|
|
521
|
+
const analyzeNode = (expression: Expression, scope: Scope): LevelData => {
|
|
505
522
|
switch (expression.kind) {
|
|
506
523
|
case "Number":
|
|
507
524
|
case "Decimal":
|
|
@@ -521,7 +538,7 @@ export const createLevelAnalyzer = (context: LevelContext) => {
|
|
|
521
538
|
case "And":
|
|
522
539
|
case "Or": {
|
|
523
540
|
const operands = toOperands(expression.operands, scope);
|
|
524
|
-
checkJunction(operands, expression
|
|
541
|
+
checkJunction(operands, expression);
|
|
525
542
|
return applyDefined(JUNCTION_LEVELS, operands);
|
|
526
543
|
}
|
|
527
544
|
case "Prime":
|
|
@@ -561,13 +578,14 @@ export const createLevelAnalyzer = (context: LevelContext) => {
|
|
|
561
578
|
expression.bounds.map((bound) => bound.set),
|
|
562
579
|
getBoundNames(expression.bounds),
|
|
563
580
|
);
|
|
564
|
-
|
|
565
|
-
data.level === TEMPORAL_LEVEL
|
|
566
|
-
|
|
567
|
-
|
|
581
|
+
const actionBound =
|
|
582
|
+
data.level === TEMPORAL_LEVEL
|
|
583
|
+
? expression.bounds.find((bound) => analyze(bound.set, scope).level === ACTION_LEVEL)
|
|
584
|
+
: undefined;
|
|
585
|
+
if (actionBound) {
|
|
568
586
|
throw createLevelError(
|
|
569
587
|
"Action-level bound of quantified temporal formula",
|
|
570
|
-
|
|
588
|
+
actionBound.set,
|
|
571
589
|
);
|
|
572
590
|
}
|
|
573
591
|
return data;
|
|
@@ -838,13 +856,23 @@ const analyzeAssumeProve = (
|
|
|
838
856
|
// SANY checks the level of every definition, assumption, and theorem of a module.
|
|
839
857
|
export const checkModuleLevels = (module: Module, context: LevelContext) => {
|
|
840
858
|
const analyzer = createLevelAnalyzer(context);
|
|
841
|
-
|
|
842
|
-
.
|
|
843
|
-
|
|
844
|
-
|
|
845
|
-
|
|
846
|
-
|
|
847
|
-
|
|
848
|
-
|
|
849
|
-
|
|
859
|
+
collectSemanticErrors([
|
|
860
|
+
...module.definitions
|
|
861
|
+
.filter((definition) => !definition.name.includes("!"))
|
|
862
|
+
.map((definition) => ({
|
|
863
|
+
location: definition.location,
|
|
864
|
+
check: () => analyzer.analyzeDefinition(definition, new Map()),
|
|
865
|
+
})),
|
|
866
|
+
...module.assumptions.map((assumption) => ({
|
|
867
|
+
location: assumption.location,
|
|
868
|
+
check: () => analyzer.analyze(assumption.expression, new Map()),
|
|
869
|
+
})),
|
|
870
|
+
...module.theorems.map((theorem) => ({
|
|
871
|
+
location: theorem.location,
|
|
872
|
+
check: () =>
|
|
873
|
+
theorem.statement.kind === "AssumeProve"
|
|
874
|
+
? analyzeAssumeProve(theorem.statement, new Map(), analyzer)
|
|
875
|
+
: analyzer.analyze(theorem.statement, new Map()),
|
|
876
|
+
})),
|
|
877
|
+
]);
|
|
850
878
|
};
|
package/src/liveness.ts
CHANGED
|
@@ -210,12 +210,16 @@ export const expandTemporal = (
|
|
|
210
210
|
if (expanding.has(definition)) {
|
|
211
211
|
throw setExitCode(new TlaEvaluationError(STACK_OVERFLOW), EXIT_STATUS.error);
|
|
212
212
|
}
|
|
213
|
-
|
|
213
|
+
const expanded = expand(
|
|
214
214
|
definition.body,
|
|
215
215
|
undefined,
|
|
216
216
|
expression.name,
|
|
217
217
|
new Set([...expanding, definition]),
|
|
218
218
|
);
|
|
219
|
+
// TLC takes the body of a state-level definition in a specification as one initial predicate.
|
|
220
|
+
return !isProperty && getDefinitionLevel(definition, environment) < ACTION_LEVEL
|
|
221
|
+
? [{ expression: definition.body, scope: undefined, name: expression.name }]
|
|
222
|
+
: expanded;
|
|
219
223
|
}
|
|
220
224
|
}
|
|
221
225
|
const context = getConstantContext(environment, scope);
|
package/src/parser.ts
CHANGED
|
@@ -22,7 +22,7 @@ import type {
|
|
|
22
22
|
StepBody,
|
|
23
23
|
UseOrHide,
|
|
24
24
|
} from "./ast";
|
|
25
|
-
import { TlaSyntaxError } from "./errors";
|
|
25
|
+
import { createSanyError, formatRange, TlaSyntaxError } from "./errors";
|
|
26
26
|
import { getNumeralValue, tokenize, type Token } from "./lexer";
|
|
27
27
|
|
|
28
28
|
interface InfixOperator {
|
|
@@ -631,11 +631,15 @@ const parse = (source: string, isTlapm: boolean): Module => {
|
|
|
631
631
|
return parseExpression();
|
|
632
632
|
};
|
|
633
633
|
|
|
634
|
+
const lastArguments: { range: SourceRange | undefined } = { range: undefined };
|
|
635
|
+
|
|
634
636
|
const parseArguments = () =>
|
|
635
637
|
withoutOffside(() => {
|
|
638
|
+
const start = cursor.index;
|
|
636
639
|
expect("(");
|
|
637
640
|
const args = parseSeparated(parseArgument);
|
|
638
641
|
expect(")");
|
|
642
|
+
lastArguments.range = getRange(start);
|
|
639
643
|
return args;
|
|
640
644
|
});
|
|
641
645
|
|
|
@@ -662,9 +666,12 @@ const parse = (source: string, isTlapm: boolean): Module => {
|
|
|
662
666
|
if (peek().kind === "Identifier" && (isAt("|->", 1) || isAt(":", 1))) {
|
|
663
667
|
const kind = isAt("|->", 1) ? "Record" : "RecordSet";
|
|
664
668
|
const fields = parseSeparated(() => {
|
|
669
|
+
const fieldStart = cursor.index;
|
|
670
|
+
const fieldLocation = getLocation(peek());
|
|
665
671
|
const name = expectIdentifier();
|
|
672
|
+
fieldLocation.range = getRange(fieldStart);
|
|
666
673
|
expect(kind === "Record" ? "|->" : ":");
|
|
667
|
-
return { name, value: parseExpression() };
|
|
674
|
+
return { name, value: parseExpression(), location: fieldLocation };
|
|
668
675
|
});
|
|
669
676
|
expect("]");
|
|
670
677
|
return { kind, fields, location };
|
|
@@ -856,7 +863,7 @@ const parse = (source: string, isTlapm: boolean): Module => {
|
|
|
856
863
|
const args = hasArguments ? parseArguments() : [];
|
|
857
864
|
if (!isSelectorAhead()) {
|
|
858
865
|
return hasArguments
|
|
859
|
-
? { kind: "Apply", operator: name, args, location }
|
|
866
|
+
? { kind: "Apply", operator: name, args, argumentsRange: lastArguments.range, location }
|
|
860
867
|
: { kind: "Identifier", name, location };
|
|
861
868
|
}
|
|
862
869
|
const instance = openModules
|
|
@@ -885,9 +892,10 @@ const parse = (source: string, isTlapm: boolean): Module => {
|
|
|
885
892
|
const argumentCounts = selectors.map((selector) =>
|
|
886
893
|
"args" in selector ? selector.args.length : 0,
|
|
887
894
|
);
|
|
895
|
+
const argumentsRange = lastArguments.range;
|
|
888
896
|
return argumentCounts.slice(0, -1).some((count) => count > 0)
|
|
889
|
-
? { kind: "Apply", operator, args: qualifiedArgs, argumentCounts, location }
|
|
890
|
-
: { kind: "Apply", operator, args: qualifiedArgs, location };
|
|
897
|
+
? { kind: "Apply", operator, args: qualifiedArgs, argumentCounts, argumentsRange, location }
|
|
898
|
+
: { kind: "Apply", operator, args: qualifiedArgs, argumentsRange, location };
|
|
891
899
|
}
|
|
892
900
|
if (token.kind === "Operator" && isOperatorName(token.text) && isAt("("))
|
|
893
901
|
return { kind: "Apply", operator: token.text, args: parseArguments(), location };
|
|
@@ -1423,11 +1431,14 @@ const parse = (source: string, isTlapm: boolean): Module => {
|
|
|
1423
1431
|
location: getLocation(keyword),
|
|
1424
1432
|
};
|
|
1425
1433
|
const invalid =
|
|
1426
|
-
use.kind === "Hide" && !isTlapm ? use.facts.
|
|
1427
|
-
if (invalid) {
|
|
1428
|
-
throw
|
|
1429
|
-
|
|
1430
|
-
|
|
1434
|
+
use.kind === "Hide" && !isTlapm ? use.facts.filter((fact) => !isHideFact(fact)) : [];
|
|
1435
|
+
if (invalid.length > 0) {
|
|
1436
|
+
throw createSanyError(
|
|
1437
|
+
invalid.map((fact) => ({
|
|
1438
|
+
location: formatRange(fact.location.range ?? getRange(start)),
|
|
1439
|
+
message:
|
|
1440
|
+
"The only expression allowed as a fact in a HIDE is \nthe name of a theorem, assumption, or step.",
|
|
1441
|
+
})),
|
|
1431
1442
|
);
|
|
1432
1443
|
}
|
|
1433
1444
|
return withRange(use, start);
|
package/src/resolve.ts
CHANGED
|
@@ -13,9 +13,16 @@ import {
|
|
|
13
13
|
type Proof,
|
|
14
14
|
type ProofStep,
|
|
15
15
|
type SourceLocation,
|
|
16
|
+
type SourceRange,
|
|
16
17
|
type Theorem,
|
|
17
18
|
} from "./ast";
|
|
18
|
-
import {
|
|
19
|
+
import {
|
|
20
|
+
createSanyError,
|
|
21
|
+
createSemanticError,
|
|
22
|
+
formatRange,
|
|
23
|
+
TlaSyntaxError,
|
|
24
|
+
type SanyError,
|
|
25
|
+
} from "./errors";
|
|
19
26
|
|
|
20
27
|
export interface ModuleSymbol {
|
|
21
28
|
key: string;
|
|
@@ -103,6 +110,21 @@ const findSymbol = (name: string, unit: Unit): ModuleSymbol | undefined => {
|
|
|
103
110
|
: unit.imported.get(name);
|
|
104
111
|
};
|
|
105
112
|
|
|
113
|
+
// SANY reports a name at the range of its text.
|
|
114
|
+
const getNameRange = (location: SourceLocation, name: string): SourceRange => ({
|
|
115
|
+
module: location.range?.module ?? "",
|
|
116
|
+
start: location,
|
|
117
|
+
end: { line: location.line, column: location.column + name.length - 1 },
|
|
118
|
+
});
|
|
119
|
+
|
|
120
|
+
// SANY reports an operator symbol applied to operands as one it cannot resolve.
|
|
121
|
+
const getFixity = (expression: Expression) => {
|
|
122
|
+
if (expression.kind !== "Apply") return undefined;
|
|
123
|
+
if (expression.args.length === 2) return "infix";
|
|
124
|
+
if (expression.args.length !== 1) return undefined;
|
|
125
|
+
return isBefore(expression.location, expression.args[0].location) ? "prefix" : "postfix";
|
|
126
|
+
};
|
|
127
|
+
|
|
106
128
|
// SANY names an undefined operator symbol such as + differently from an undefined identifier.
|
|
107
129
|
const isOperatorSymbol = (name: string) =>
|
|
108
130
|
name[0].toLowerCase() === name[0].toUpperCase() &&
|
|
@@ -135,7 +157,7 @@ const getSymbolArity = (
|
|
|
135
157
|
}
|
|
136
158
|
// A name such as Inv!P1 selects the label P1 of a definition or theorem, which takes its own
|
|
137
159
|
// arguments.
|
|
138
|
-
const prefix = name.slice(0, name.indexOf("!"));
|
|
160
|
+
const prefix = name.includes("!") ? name.slice(0, name.indexOf("!")) : "";
|
|
139
161
|
const isSelected =
|
|
140
162
|
prefix !== "" &&
|
|
141
163
|
(lookupLocal(scope, prefix) !== undefined ||
|
|
@@ -144,11 +166,23 @@ const getSymbolArity = (
|
|
|
144
166
|
if (isSelected) {
|
|
145
167
|
return expression.kind === "Apply" ? expression.args.length : 0;
|
|
146
168
|
}
|
|
147
|
-
const
|
|
148
|
-
throw
|
|
149
|
-
|
|
150
|
-
|
|
151
|
-
|
|
169
|
+
const range = getNameRange(location, name === "-." ? "-" : name);
|
|
170
|
+
if (!isOperatorSymbol(name)) throw createSemanticError(`Unknown operator: \`${name}'.`, range);
|
|
171
|
+
const missing = {
|
|
172
|
+
location: formatRange(range),
|
|
173
|
+
message: `Could not find declaration or definition of symbol '${name}'.`,
|
|
174
|
+
};
|
|
175
|
+
const fixity = getFixity(expression);
|
|
176
|
+
throw createSanyError(
|
|
177
|
+
fixity && location.range
|
|
178
|
+
? [
|
|
179
|
+
missing,
|
|
180
|
+
{
|
|
181
|
+
location: formatRange(location.range),
|
|
182
|
+
message: `Couldn't resolve ${fixity} operator symbol \`${name}'.`,
|
|
183
|
+
},
|
|
184
|
+
]
|
|
185
|
+
: [missing],
|
|
152
186
|
);
|
|
153
187
|
};
|
|
154
188
|
|
|
@@ -235,13 +269,13 @@ const resolveApply = (
|
|
|
235
269
|
scope: LocalName | undefined,
|
|
236
270
|
unit: Unit,
|
|
237
271
|
) => {
|
|
238
|
-
const
|
|
239
|
-
|
|
240
|
-
|
|
241
|
-
const arity = getSymbolArity(expression, expression.operator, scope, unit);
|
|
272
|
+
const operator = expression.operator;
|
|
273
|
+
const callee = lookupLocal(scope, operator) ? undefined : getVisibleDefinition(operator, unit);
|
|
274
|
+
const arity = getSymbolArity(expression, operator, scope, unit);
|
|
242
275
|
if (arity !== expression.args.length) {
|
|
243
|
-
throw
|
|
244
|
-
`The operator ${
|
|
276
|
+
throw createSemanticError(
|
|
277
|
+
`The operator ${operator} requires ${arity} arguments.`,
|
|
278
|
+
expression.argumentsRange ?? getNameRange(expression.location, operator),
|
|
245
279
|
);
|
|
246
280
|
}
|
|
247
281
|
expression.args.forEach((arg, index) => {
|
|
@@ -275,10 +309,12 @@ const resolveExpression = (
|
|
|
275
309
|
case "ExceptAt":
|
|
276
310
|
return;
|
|
277
311
|
case "Identifier": {
|
|
278
|
-
const
|
|
312
|
+
const name = expression.name;
|
|
313
|
+
const arity = getSymbolArity(expression, name, scope, unit);
|
|
279
314
|
if (arity > 0) {
|
|
280
|
-
throw
|
|
281
|
-
`The operator ${
|
|
315
|
+
throw createSemanticError(
|
|
316
|
+
`The operator ${name} requires ${arity} arguments.`,
|
|
317
|
+
getNameRange(expression.location, name),
|
|
282
318
|
);
|
|
283
319
|
}
|
|
284
320
|
return;
|
|
@@ -347,14 +383,21 @@ const resolveExpression = (
|
|
|
347
383
|
resolveAll([expression.domain, expression.range]);
|
|
348
384
|
return;
|
|
349
385
|
case "Record":
|
|
350
|
-
case "RecordSet":
|
|
351
|
-
|
|
352
|
-
|
|
353
|
-
|
|
386
|
+
case "RecordSet": {
|
|
387
|
+
const repeated = expression.fields.filter((field, index) =>
|
|
388
|
+
expression.fields.slice(0, index).some((earlier) => earlier.name === field.name),
|
|
389
|
+
);
|
|
390
|
+
if (repeated.length > 0) {
|
|
391
|
+
throw createSanyError(
|
|
392
|
+
repeated.map((field) => ({
|
|
393
|
+
location: formatRange(field.location.range ?? getNameRange(field.location, field.name)),
|
|
394
|
+
message: "Non-unique fields in constructor.",
|
|
395
|
+
})),
|
|
354
396
|
);
|
|
355
397
|
}
|
|
356
398
|
resolveAll(expression.fields.map((field) => field.value));
|
|
357
399
|
return;
|
|
400
|
+
}
|
|
358
401
|
case "Except":
|
|
359
402
|
resolveAll([
|
|
360
403
|
expression.function,
|
|
@@ -769,6 +812,29 @@ export const resolveSubstitutions = (
|
|
|
769
812
|
);
|
|
770
813
|
};
|
|
771
814
|
|
|
815
|
+
// SANY reports the errors of every unit it checks, in the order of the units in the module.
|
|
816
|
+
export const collectSemanticErrors = (units: { location: SourceLocation; check: () => void }[]) => {
|
|
817
|
+
const errors: SanyError[] = [];
|
|
818
|
+
units
|
|
819
|
+
.toSorted((left, right) => (isBefore(left.location, right.location) ? -1 : 1))
|
|
820
|
+
.forEach((unit) => {
|
|
821
|
+
try {
|
|
822
|
+
unit.check();
|
|
823
|
+
} catch (error) {
|
|
824
|
+
if (!(error instanceof TlaSyntaxError) || !error.sany) throw error;
|
|
825
|
+
error.sany.errors
|
|
826
|
+
.filter((item) =>
|
|
827
|
+
errors.every(
|
|
828
|
+
(existing) =>
|
|
829
|
+
existing.location !== item.location || existing.message !== item.message,
|
|
830
|
+
),
|
|
831
|
+
)
|
|
832
|
+
.forEach((item) => errors.push(item));
|
|
833
|
+
}
|
|
834
|
+
});
|
|
835
|
+
if (errors.length > 0) throw createSanyError(errors);
|
|
836
|
+
};
|
|
837
|
+
|
|
772
838
|
export const resolveModule = (module: Module, unit: ModuleUnit) => {
|
|
773
839
|
const symbols = createSymbols(module, unit.imported);
|
|
774
840
|
const facts = new Set(
|
|
@@ -782,13 +848,24 @@ export const resolveModule = (module: Module, unit: ModuleUnit) => {
|
|
|
782
848
|
self,
|
|
783
849
|
facts,
|
|
784
850
|
});
|
|
785
|
-
|
|
786
|
-
|
|
787
|
-
|
|
788
|
-
|
|
789
|
-
|
|
790
|
-
|
|
791
|
-
|
|
792
|
-
|
|
793
|
-
|
|
851
|
+
collectSemanticErrors([
|
|
852
|
+
...module.definitions.map((definition) => ({
|
|
853
|
+
location: definition.location,
|
|
854
|
+
check: () =>
|
|
855
|
+
resolveDefinition(definition, undefined, createUnit(definition.location, definition)),
|
|
856
|
+
})),
|
|
857
|
+
...module.assumptions.map((assumption) => ({
|
|
858
|
+
location: assumption.location,
|
|
859
|
+
check: () =>
|
|
860
|
+
resolveExpression(
|
|
861
|
+
assumption.expression,
|
|
862
|
+
undefined,
|
|
863
|
+
createUnit(assumption.location, undefined),
|
|
864
|
+
),
|
|
865
|
+
})),
|
|
866
|
+
...module.theorems.map((theorem) => ({
|
|
867
|
+
location: theorem.location,
|
|
868
|
+
check: () => resolveTheorem(theorem, createUnit(theorem.location, undefined)),
|
|
869
|
+
})),
|
|
870
|
+
]);
|
|
794
871
|
};
|