tla-ts 0.0.10-dev.37a75eb5b → 0.0.10-dev.45c0eaef5
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/compile.cjs +3 -3
- package/dist/compile.js +1 -1
- package/dist/deciders.cjs +33 -33
- package/dist/deciders.js +53 -53
- package/dist/index.cjs +1 -1
- package/dist/index.d.cts +17 -3
- package/dist/index.d.ts +17 -3
- package/dist/index.js +1 -1
- package/dist/parallel-worker.cjs +1 -1
- package/dist/parallel-worker.js +1 -1
- package/dist/prove-worker.cjs +1 -1
- package/dist/prove-worker.js +1 -1
- package/dist/prove.cjs +55 -55
- package/dist/prove.js +78 -78
- package/dist/run.cjs +40 -42
- package/dist/run.js +42 -44
- package/dist/tlapm.cjs +1 -1
- package/dist/tlapm.js +2 -2
- package/dist/transfer.cjs +96 -91
- package/dist/transfer.js +95 -90
- package/dist/worker.cjs +7 -7
- package/dist/worker.js +7 -7
- package/package.json +1 -1
- package/src/ast.ts +31 -3
- package/src/bags.ts +12 -10
- package/src/builtins.ts +4 -3
- package/src/check-failure.ts +13 -11
- package/src/check-trace.ts +146 -93
- package/src/check.ts +418 -246
- package/src/cli/tlc-output.ts +17 -2
- package/src/cli/tlc.ts +5 -4
- package/src/cli/xml-exporter.ts +1 -1
- package/src/codegen.ts +23 -10
- package/src/coverage.ts +255 -18
- package/src/dependencies.ts +68 -15
- package/src/dfid.ts +93 -35
- package/src/environment.ts +106 -39
- package/src/errors.ts +7 -0
- package/src/evaluate.ts +415 -132
- package/src/exit-codes.ts +28 -15
- package/src/instances.ts +135 -11
- package/src/java-hash.ts +14 -0
- package/src/java-overrides.ts +2 -2
- package/src/levels.ts +674 -236
- package/src/lexer.ts +12 -2
- package/src/liveness-checker.ts +161 -60
- package/src/liveness.ts +55 -10
- package/src/obligations/index.ts +1 -1
- package/src/obligations/normalize.ts +1 -4
- package/src/obligations/printer.ts +5 -5
- package/src/obligations/source.ts +2 -0
- package/src/parser.ts +110 -111
- package/src/prover/isabelle/isar/attrib.ts +4 -4
- package/src/prover/isabelle/isar/rule-cases.ts +8 -6
- package/src/prover/isabelle/provers/clasimp.ts +1 -1
- package/src/prover/isabelle/provers/hypsubst.ts +2 -2
- package/src/prover/isabelle/pure/rewriter.ts +3 -3
- package/src/prover/isabelle/pure/term.ts +3 -3
- package/src/prover/prep/md5.ts +26 -29
- package/src/prover/smt/rewrite.ts +2 -7
- package/src/prover/smt/simplify.ts +1 -1
- package/src/prover/smt/solver/arith-rewriter.ts +11 -3
- package/src/prover/smt/solver/array-rewriter.ts +12 -2
- package/src/prover/smt/solver/asserted-formulas.ts +164 -58
- package/src/prover/smt/solver/ast-lt.ts +1 -1
- package/src/prover/smt/solver/ast.ts +65 -13
- package/src/prover/smt/solver/auf-solver.ts +23 -12
- package/src/prover/smt/solver/bit-blast-tactic.ts +27 -1
- package/src/prover/smt/solver/blast-term-ite.ts +47 -0
- package/src/prover/smt/solver/bound-simplifier.ts +11 -13
- package/src/prover/smt/solver/bv-decl-plugin.ts +13 -10
- package/src/prover/smt/solver/bv-rewriter.ts +1 -1
- package/src/prover/smt/solver/card2bv.ts +35 -18
- package/src/prover/smt/solver/cofactor-elim-term-ite.ts +39 -24
- package/src/prover/smt/solver/context.ts +65 -14
- package/src/prover/smt/solver/ctx-simplify.ts +1 -2
- package/src/prover/smt/solver/datatype-decl-plugin.ts +15 -7
- package/src/prover/smt/solver/dependent-expr-state.ts +28 -16
- package/src/prover/smt/solver/diff-neq.ts +1 -2
- package/src/prover/smt/solver/dt2bv-tactic.ts +57 -21
- package/src/prover/smt/solver/elim-bounds.ts +89 -0
- package/src/prover/smt/solver/elim-term-ite-tactic.ts +48 -0
- package/src/prover/smt/solver/elim-uncnstr.ts +5 -8
- package/src/prover/smt/solver/euf/arith-internalize.ts +1 -1
- package/src/prover/smt/solver/euf/array-internalize.ts +1 -1
- package/src/prover/smt/solver/euf/bv-internalize.ts +1 -1
- package/src/prover/smt/solver/euf/egraph.ts +3 -9
- package/src/prover/smt/solver/euf/euf-solver.ts +1 -2
- package/src/prover/smt/solver/euf/mam.ts +1 -5
- package/src/prover/smt/solver/euf/q-ematch.ts +1 -2
- package/src/prover/smt/solver/euf/th-solver.ts +0 -7
- package/src/prover/smt/solver/fd-solver.ts +608 -141
- package/src/prover/smt/solver/fix-dl-var.ts +1 -2
- package/src/prover/smt/solver/fpa2bv-rewriter.ts +1 -0
- package/src/prover/smt/solver/goal.ts +4 -3
- package/src/prover/smt/solver/hashtable.ts +4 -0
- package/src/prover/smt/solver/internalizer.ts +1 -1
- package/src/prover/smt/solver/logic-tactics.ts +15 -5
- package/src/prover/smt/solver/lp/core-solver.ts +12 -8
- package/src/prover/smt/solver/lp/lar-solver.ts +1 -1
- package/src/prover/smt/solver/lp/lp-settings.ts +6 -2
- package/src/prover/smt/solver/lp/nla-grobner.ts +2 -2
- package/src/prover/smt/solver/lp/pdd.ts +2 -3
- package/src/prover/smt/solver/lp/union-find.ts +1 -1
- package/src/prover/smt/solver/mam-compiler.ts +1 -1
- package/src/prover/smt/solver/maxcore.ts +2 -1
- package/src/prover/smt/solver/maxsmt-base.ts +1 -0
- package/src/prover/smt/solver/model-based-opt.ts +1 -1
- package/src/prover/smt/solver/model-checker.ts +1 -1
- package/src/prover/smt/solver/model-evaluator.ts +2 -0
- package/src/prover/smt/solver/model-generator.ts +85 -43
- package/src/prover/smt/solver/mpf.ts +2 -4
- package/src/prover/smt/solver/mus.ts +2 -3
- package/src/prover/smt/solver/muz/dl-context.ts +14 -42
- package/src/prover/smt/solver/muz/dl-mk-coi-filter.ts +1 -1
- package/src/prover/smt/solver/muz/dl-mk-slice.ts +3 -3
- package/src/prover/smt/solver/muz/dl-rule.ts +8 -9
- package/src/prover/smt/solver/muz/hnf.ts +2 -2
- package/src/prover/smt/solver/muz/horn-subsume-model-converter.ts +1 -1
- package/src/prover/smt/solver/muz/horn-tactic.ts +15 -2
- package/src/prover/smt/solver/muz/rule-properties.ts +22 -0
- package/src/prover/smt/solver/muz/spacer-context.ts +1 -4
- package/src/prover/smt/solver/muz/spacer-prop-solver.ts +1 -1
- package/src/prover/smt/solver/nlqsat.ts +1 -1
- package/src/prover/smt/solver/nlsat/algebraic.ts +4 -5
- package/src/prover/smt/solver/nlsat/levelwise.ts +0 -4
- package/src/prover/smt/solver/nlsat/polynomial.ts +1 -36
- package/src/prover/smt/solver/nlsat/upolynomial.ts +1 -1
- package/src/prover/smt/solver/nlsat-tactic.ts +1 -1
- package/src/prover/smt/solver/nnf.ts +6 -2
- package/src/prover/smt/solver/opt-context.ts +16 -7
- package/src/prover/smt/solver/opt-pareto.ts +19 -0
- package/src/prover/smt/solver/opt-preprocess.ts +1 -1
- package/src/prover/smt/solver/opt-solver.ts +4 -3
- package/src/prover/smt/solver/optsmt.ts +1 -1
- package/src/prover/smt/solver/parallel-tactic.ts +1 -1
- package/src/prover/smt/solver/pb-rewriter.ts +1 -4
- package/src/prover/smt/solver/poly-rewriter.ts +75 -18
- package/src/prover/smt/solver/probes.ts +88 -23
- package/src/prover/smt/solver/proto-model.ts +8 -8
- package/src/prover/smt/solver/push-app-ite.ts +37 -0
- package/src/prover/smt/solver/qe-arith-plugin.ts +2 -4
- package/src/prover/smt/solver/qe-lite.ts +2 -2
- package/src/prover/smt/solver/qe.ts +3 -2
- package/src/prover/smt/solver/qsat.ts +23 -8
- package/src/prover/smt/solver/recfun-decl-plugin.ts +2 -1
- package/src/prover/smt/solver/rewriter-tpl.ts +7 -6
- package/src/prover/smt/solver/rewriter.ts +31 -25
- package/src/prover/smt/solver/rlimit.ts +7 -3
- package/src/prover/smt/solver/sat/config.ts +1 -1
- package/src/prover/smt/solver/sat/goal2sat.ts +65 -12
- package/src/prover/smt/solver/sat/inc-sat-solver.ts +129 -43
- package/src/prover/smt/solver/sat/model-converter.ts +1 -1
- package/src/prover/smt/solver/sat/pb-constraint.ts +7 -0
- package/src/prover/smt/solver/sat/pb-solver.ts +26 -7
- package/src/prover/smt/solver/sat/sat-tactic.ts +15 -6
- package/src/prover/smt/solver/sat/sat2goal.ts +72 -48
- package/src/prover/smt/solver/sat/simplifier.ts +1 -1
- package/src/prover/smt/solver/sat/solver.ts +27 -47
- package/src/prover/smt/solver/seq-axioms.ts +20 -35
- package/src/prover/smt/solver/seq-decl-plugin.ts +1 -1
- package/src/prover/smt/solver/seq-derive.ts +1 -1
- package/src/prover/smt/solver/seq-eq-solver.ts +2 -2
- package/src/prover/smt/solver/seq-monadic.ts +7 -5
- package/src/prover/smt/solver/seq-re-rewriter.ts +2 -1
- package/src/prover/smt/solver/seq-re-util.ts +1 -1
- package/src/prover/smt/solver/seq-regex-bisim.ts +1 -1
- package/src/prover/smt/solver/seq-regex-live.ts +2 -2
- package/src/prover/smt/solver/seq-rewriter.ts +31 -29
- package/src/prover/smt/solver/seq-skolem.ts +0 -23
- package/src/prover/smt/solver/seq-view-witness.ts +4 -4
- package/src/prover/smt/solver/smt-consequences.ts +1 -1
- package/src/prover/smt/solver/smt-kernel.ts +40 -6
- package/src/prover/smt/solver/smt-setup.ts +106 -13
- package/src/prover/smt/solver/smtlib-parser.ts +579 -214
- package/src/prover/smt/solver/smtlib-script.ts +600 -170
- package/src/prover/smt/solver/solve-eqs.ts +36 -37
- package/src/prover/smt/solver/solver.ts +18 -3
- package/src/prover/smt/solver/tactic.ts +342 -196
- package/src/prover/smt/solver/theory-bv.ts +13 -3
- package/src/prover/smt/solver/theory-fpa.ts +1 -1
- package/src/prover/smt/solver/theory-lra-final-check.ts +1 -0
- package/src/prover/smt/solver/theory-lra-internalize.ts +2 -0
- package/src/prover/smt/solver/theory-lra-propagate.ts +11 -3
- package/src/prover/smt/solver/theory-lra-state.ts +1 -1
- package/src/prover/smt/solver/theory-lra.ts +1 -1
- package/src/prover/smt/solver/theory-pb.ts +24 -7
- package/src/prover/smt/solver/theory-seq-solve.ts +1 -1
- package/src/prover/smt/solver/theory-seq-state.ts +2 -21
- package/src/prover/smt/solver/theory-without-terms.ts +24 -0
- package/src/prover/smt/solver/tseitin-cnf.ts +1 -0
- package/src/prover/tlapm/cache.ts +8 -8
- package/src/prover/zenon/index-table.ts +5 -2
- package/src/prover/zenon/isar-case.ts +1 -1
- package/src/prover/zenon/isar.ts +2 -2
- package/src/prover/zenon/phrase.ts +1 -1
- package/src/resolve.ts +1226 -246
- package/src/runtime.ts +19 -2
- package/src/sany/builtins.ts +10 -10
- package/src/sany/generation.ts +4 -2
- package/src/sany/generator-def-entries.ts +123 -36
- package/src/sany/generator-definitions.ts +4 -2
- package/src/sany/generator-expressions.ts +51 -20
- package/src/sany/generator-proofs.ts +17 -11
- package/src/sany/generator.ts +11 -5
- package/src/sany/lexer.ts +15 -7
- package/src/sany/modules.ts +4 -2
- package/src/sany/nodes.ts +1 -1
- package/src/sany/selectors.ts +11 -6
- package/src/sany/xml.ts +2 -3
- package/src/search.ts +283 -126
- package/src/simulate.ts +247 -185
- package/src/spec-description.ts +15 -7
- package/src/standard-definitions.ts +1 -0
- package/src/standard-modules.ts +56 -22
- package/src/subexpressions.ts +563 -139
- package/src/successors.ts +50 -20
- package/src/symmetry.ts +2 -1
- package/src/tlc/jar-data.ts +1 -3
- package/src/tlc/messages.ts +3 -3
- package/src/tlc/random.ts +2 -1
- package/src/tlc/replay.ts +147 -46
- package/src/tlc/tlc-operators.ts +10 -8
- package/src/tlc/tlcext-operators.ts +26 -10
- package/src/tlc/trace-spec.ts +9 -22
- package/src/trace-liveness.ts +529 -0
- package/src/typed-tier.ts +52 -31
- package/src/typescript/types.ts +2 -2
- package/src/values.ts +150 -79
package/src/evaluate.ts
CHANGED
|
@@ -1,5 +1,6 @@
|
|
|
1
1
|
import {
|
|
2
2
|
getChildren,
|
|
3
|
+
getFunctionConstruction,
|
|
3
4
|
getReferencedName,
|
|
4
5
|
isLocallyResolved,
|
|
5
6
|
type Bound,
|
|
@@ -22,13 +23,27 @@ import {
|
|
|
22
23
|
} from "./errors";
|
|
23
24
|
import { EXIT_STATUS, setExitCode } from "./exit-codes";
|
|
24
25
|
import { generateEvaluator } from "./codegen";
|
|
25
|
-
import {
|
|
26
|
+
import {
|
|
27
|
+
chargeContexts,
|
|
28
|
+
chargeFunctionConstruction,
|
|
29
|
+
chargeSetOperation,
|
|
30
|
+
costCoverage,
|
|
31
|
+
countCoverage,
|
|
32
|
+
createChargedEnumerator,
|
|
33
|
+
createProductSetEnumerator,
|
|
34
|
+
getCoverageNode,
|
|
35
|
+
runAtCoverageNode,
|
|
36
|
+
tagSubset,
|
|
37
|
+
type Coverage,
|
|
38
|
+
} from "./coverage";
|
|
26
39
|
import { MESSAGE_CODE } from "./tlc/messages";
|
|
27
40
|
import type { CheckerRuntime } from "./runtime";
|
|
28
41
|
import {
|
|
29
|
-
|
|
42
|
+
isEvaluatedAtStartup,
|
|
43
|
+
isExpressionImpure,
|
|
30
44
|
isImpureDefinition,
|
|
31
45
|
isNonconstant,
|
|
46
|
+
isTlcEvalReached,
|
|
32
47
|
type DefinitionFacts,
|
|
33
48
|
} from "./dependencies";
|
|
34
49
|
import { contextualApplications, substitutionFrames } from "./instances";
|
|
@@ -152,6 +167,7 @@ export interface Environment {
|
|
|
152
167
|
variableIndex: Map<string, number>;
|
|
153
168
|
facts: DefinitionFacts;
|
|
154
169
|
startupValues: (Value | undefined)[];
|
|
170
|
+
tlcEvalValues: WeakMap<Expression, Value>;
|
|
155
171
|
substitutedDefinitions: Set<Definition>;
|
|
156
172
|
instanceParams: Set<OperatorParam>;
|
|
157
173
|
evaluators: WeakMap<Expression, Evaluator>;
|
|
@@ -320,15 +336,14 @@ export const getDomainOperator = (expression: Expression) => (value: Value) => {
|
|
|
320
336
|
};
|
|
321
337
|
|
|
322
338
|
export const getSubsetOperator =
|
|
323
|
-
(expression: Expression,
|
|
339
|
+
(expression: Expression, subset: (left: Value, right: Value) => Value) =>
|
|
340
|
+
(left: Value, right: Value) => {
|
|
324
341
|
if (!isSetValue(left) || isOverriddenSet(left)) {
|
|
325
342
|
throw new TlaEvaluationError(
|
|
326
343
|
`Attempted to evaluate an expression of form S \\subseteq T, but S was not enumerable.\n${describeRange(expression)}`,
|
|
327
344
|
);
|
|
328
345
|
}
|
|
329
|
-
return
|
|
330
|
-
? builtin.evaluateBinary(left, right)
|
|
331
|
-
: builtin.evaluate([left, right]);
|
|
346
|
+
return subset(left, right);
|
|
332
347
|
};
|
|
333
348
|
|
|
334
349
|
export const createRealNumberError = (expression: DecimalExpression) =>
|
|
@@ -523,10 +538,13 @@ const someElement = (
|
|
|
523
538
|
return false;
|
|
524
539
|
};
|
|
525
540
|
|
|
526
|
-
export const mapBoundSets = <Result>(
|
|
541
|
+
export const mapBoundSets = <Result>(
|
|
542
|
+
bounds: Bound[],
|
|
543
|
+
map: (set: Expression, index: number) => Result,
|
|
544
|
+
) =>
|
|
527
545
|
bounds.reduce<Result[]>((results, bound, index) => {
|
|
528
546
|
results.push(
|
|
529
|
-
index > 0 && bounds[index - 1].set === bound.set ? results[index - 1] : map(bound.set),
|
|
547
|
+
index > 0 && bounds[index - 1].set === bound.set ? results[index - 1] : map(bound.set, index),
|
|
530
548
|
);
|
|
531
549
|
return results;
|
|
532
550
|
}, []);
|
|
@@ -557,6 +575,31 @@ export const forEachBinding = (
|
|
|
557
575
|
visit: (scope: Scope | undefined) => boolean,
|
|
558
576
|
) => forEachBoundElement(bounds, getBoundElements(bounds, context), context.scope, visit);
|
|
559
577
|
|
|
578
|
+
const forEachChargedBinding = (
|
|
579
|
+
bounds: Bound[],
|
|
580
|
+
context: Context,
|
|
581
|
+
coverage: Coverage,
|
|
582
|
+
visit: (scope: Scope | undefined) => boolean,
|
|
583
|
+
) => {
|
|
584
|
+
const bounded = mapBoundSets(bounds, (set) => {
|
|
585
|
+
const value = evaluate(set, context);
|
|
586
|
+
return {
|
|
587
|
+
value,
|
|
588
|
+
elements: getQuantifierElements(value, set, context.environment.runtime.version),
|
|
589
|
+
};
|
|
590
|
+
});
|
|
591
|
+
const sets = bounded.map((item) => item.elements);
|
|
592
|
+
const charge = chargeContexts(
|
|
593
|
+
coverage,
|
|
594
|
+
bounded.map((item) => item.value),
|
|
595
|
+
sets,
|
|
596
|
+
);
|
|
597
|
+
return forEachBoundElement(bounds, sets, context.scope, (scope) => {
|
|
598
|
+
charge();
|
|
599
|
+
return visit(scope);
|
|
600
|
+
});
|
|
601
|
+
};
|
|
602
|
+
|
|
560
603
|
const getBoundsDomain = (bounds: Bound[], context: Context): Value => {
|
|
561
604
|
const sets = mapBoundSets(bounds, (set) => evaluate(set, context));
|
|
562
605
|
return sets.length === 1 ? sets[0] : { kind: "ProductSet", factors: sets };
|
|
@@ -673,7 +716,7 @@ const getLazyFunctionTemplate = (bounds: Bound[], body: Expression) => {
|
|
|
673
716
|
},
|
|
674
717
|
],
|
|
675
718
|
),
|
|
676
|
-
body:
|
|
719
|
+
body: describeNode(body),
|
|
677
720
|
};
|
|
678
721
|
};
|
|
679
722
|
|
|
@@ -719,28 +762,29 @@ const getBoundTupleLengths = (bounds: Bound[]) =>
|
|
|
719
762
|
bound.pattern.kind === "Tuple" ? bound.pattern.names.length : undefined,
|
|
720
763
|
);
|
|
721
764
|
|
|
722
|
-
const getDefinitionSource = (definition: FunctionDefinition): Expression => ({
|
|
723
|
-
kind: "FunctionConstruction",
|
|
724
|
-
bounds: definition.bounds,
|
|
725
|
-
body: definition.body,
|
|
726
|
-
location: definition.location,
|
|
727
|
-
});
|
|
728
|
-
|
|
729
765
|
const createRecursiveFunction = (
|
|
730
766
|
definition: FunctionDefinition,
|
|
731
767
|
context: Context,
|
|
732
768
|
): RebindableLazyFunction => {
|
|
733
769
|
const domain = getBoundsDomain(definition.bounds, context);
|
|
770
|
+
const compute = (argument: Value, self: Value) =>
|
|
771
|
+
evaluate(
|
|
772
|
+
definition.body,
|
|
773
|
+
withScope(
|
|
774
|
+
context,
|
|
775
|
+
bindArgument(definition.bounds, bindValue(undefined, definition.name, self), argument),
|
|
776
|
+
),
|
|
777
|
+
);
|
|
778
|
+
const coverage = context.environment.coverage;
|
|
779
|
+
const node = coverage && !context.environment.callStack ? coverage.current : -1;
|
|
734
780
|
const functionValue = createLazyFunction(
|
|
735
781
|
domain,
|
|
736
|
-
|
|
737
|
-
|
|
738
|
-
|
|
739
|
-
|
|
740
|
-
|
|
741
|
-
|
|
742
|
-
),
|
|
743
|
-
),
|
|
782
|
+
coverage
|
|
783
|
+
? (argument, self) =>
|
|
784
|
+
coverage.current === -1
|
|
785
|
+
? compute(argument, self)
|
|
786
|
+
: runAtCoverageNode(coverage, node, () => compute(argument, self))
|
|
787
|
+
: compute,
|
|
744
788
|
getLazyFunctionSource(
|
|
745
789
|
getLazyFunctionTemplate(definition.bounds, definition.body),
|
|
746
790
|
definition.bounds,
|
|
@@ -792,9 +836,17 @@ const compileDefinitionBody = (definition: Definition, environment: Environment)
|
|
|
792
836
|
};
|
|
793
837
|
}
|
|
794
838
|
if (definition.kind !== "Function") return getEntryEvaluator(definition.body, environment);
|
|
795
|
-
|
|
796
|
-
|
|
797
|
-
|
|
839
|
+
const construction = getFunctionConstruction(definition, false);
|
|
840
|
+
if (!definition.isSelfReferential) return getEntryEvaluator(construction, environment);
|
|
841
|
+
const evaluator: Evaluator = (context) => createRecursiveFunction(definition, context);
|
|
842
|
+
const coverage = environment.coverage;
|
|
843
|
+
return coverage ? countEvaluator(construction, evaluator, coverage) : evaluator;
|
|
844
|
+
};
|
|
845
|
+
|
|
846
|
+
const CALLER_SCOPE: Scope = {
|
|
847
|
+
name: "",
|
|
848
|
+
binding: { kind: "Value", value: false },
|
|
849
|
+
parent: undefined,
|
|
798
850
|
};
|
|
799
851
|
|
|
800
852
|
const getDefinitionEvaluator = (definition: Definition, environment: Environment): Evaluator => {
|
|
@@ -803,8 +855,15 @@ const getDefinitionEvaluator = (definition: Definition, environment: Environment
|
|
|
803
855
|
const body = compileDefinitionBody(definition, environment);
|
|
804
856
|
const definitionId = environment.facts.ids.get(definition);
|
|
805
857
|
const startupValues = environment.startupValues;
|
|
806
|
-
const
|
|
807
|
-
|
|
858
|
+
const isInCallerContext =
|
|
859
|
+
definition.kind === "Operator" &&
|
|
860
|
+
definition.params.length === 0 &&
|
|
861
|
+
isTlcEvalReached(definition.body, environment);
|
|
862
|
+
const evaluator: Evaluator = isInCallerContext
|
|
863
|
+
? (context) =>
|
|
864
|
+
(definitionId === undefined ? undefined : startupValues[definitionId]) ??
|
|
865
|
+
body(withScope(context, isTlcContextEmpty(context.scope) ? undefined : CALLER_SCOPE))
|
|
866
|
+
: definitionId === undefined
|
|
808
867
|
? (context) => body(withScope(context, undefined))
|
|
809
868
|
: (context) => startupValues[definitionId] ?? body(withScope(context, undefined));
|
|
810
869
|
environment.definitionEvaluators.set(definition, evaluator);
|
|
@@ -821,7 +880,7 @@ export const evaluateStartupDefinitions = (definitions: Definition[], environmen
|
|
|
821
880
|
if (definition.kind === "Operator" && definition.params.length > 0) return;
|
|
822
881
|
const name = definition.name;
|
|
823
882
|
if (environment.constants.has(name) || environment.substitutions.has(name)) return;
|
|
824
|
-
if (!
|
|
883
|
+
if (!isEvaluatedAtStartup(definition, environment)) return;
|
|
825
884
|
const definitionId = environment.facts.ids.get(definition);
|
|
826
885
|
if (definitionId === undefined || environment.startupValues[definitionId] !== undefined) return;
|
|
827
886
|
const context = { environment, scope: undefined, state: undefined, next: undefined };
|
|
@@ -973,6 +1032,7 @@ const isOperatorArgument = (expression: Expression, context: Context) => {
|
|
|
973
1032
|
return operator !== undefined && getArity(operator) > 0;
|
|
974
1033
|
};
|
|
975
1034
|
|
|
1035
|
+
// Deviation from TLC: SymbolNodeValueLookupProvider#lookup takes an operator whose body is a literal for that literal, so a Java override rejects it as an argument.
|
|
976
1036
|
const evaluateBuiltinArguments = (args: Expression[], context: Context) =>
|
|
977
1037
|
args.map((arg) =>
|
|
978
1038
|
isOperatorArgument(arg, context)
|
|
@@ -1087,20 +1147,29 @@ interface ReevaluatedDefinitions {
|
|
|
1087
1147
|
streamed: ReadonlySet<Definition>;
|
|
1088
1148
|
}
|
|
1089
1149
|
|
|
1090
|
-
const
|
|
1150
|
+
const isRecursiveOperator = (definition: Definition) =>
|
|
1151
|
+
definition.kind === "Operator" && definition.isRecursive && definition.params.length > 0;
|
|
1091
1152
|
|
|
1092
|
-
|
|
1093
|
-
|
|
1094
|
-
|
|
1095
|
-
|
|
1096
|
-
|
|
1097
|
-
|
|
1098
|
-
|
|
1099
|
-
|
|
1100
|
-
|
|
1101
|
-
|
|
1102
|
-
|
|
1103
|
-
|
|
1153
|
+
// TLC finds a RECURSIVE operator with parameters by its definition, not in its context, so every definition reaches it.
|
|
1154
|
+
const chainRecursiveOperatorsFirst = (
|
|
1155
|
+
definitions: Definition[],
|
|
1156
|
+
nodes: Scope[],
|
|
1157
|
+
outer: Scope | undefined,
|
|
1158
|
+
) => {
|
|
1159
|
+
let scope = outer;
|
|
1160
|
+
for (let index = 0; index < definitions.length; index++) {
|
|
1161
|
+
if (isRecursiveOperator(definitions[index])) {
|
|
1162
|
+
nodes[index].parent = scope;
|
|
1163
|
+
scope = nodes[index];
|
|
1164
|
+
}
|
|
1165
|
+
}
|
|
1166
|
+
for (let index = 0; index < definitions.length; index++) {
|
|
1167
|
+
if (!isRecursiveOperator(definitions[index])) {
|
|
1168
|
+
nodes[index].parent = scope;
|
|
1169
|
+
scope = nodes[index];
|
|
1170
|
+
}
|
|
1171
|
+
}
|
|
1172
|
+
return scope;
|
|
1104
1173
|
};
|
|
1105
1174
|
|
|
1106
1175
|
export const bindDefinitions = (
|
|
@@ -1113,16 +1182,29 @@ export const bindDefinitions = (
|
|
|
1113
1182
|
binding: { kind: "Value", value: false },
|
|
1114
1183
|
parent: undefined,
|
|
1115
1184
|
}));
|
|
1116
|
-
|
|
1117
|
-
|
|
1118
|
-
|
|
1119
|
-
|
|
1120
|
-
|
|
1185
|
+
let scope = context.scope;
|
|
1186
|
+
let hasRecursive = false;
|
|
1187
|
+
for (let index = 0; index < nodes.length; index++) {
|
|
1188
|
+
nodes[index].parent = scope;
|
|
1189
|
+
scope = nodes[index];
|
|
1190
|
+
hasRecursive ||= definitions[index].isRecursive;
|
|
1191
|
+
}
|
|
1192
|
+
if (hasRecursive) scope = chainRecursiveOperatorsFirst(definitions, nodes, context.scope);
|
|
1193
|
+
let isRecursiveValueAtOrAfter = false;
|
|
1194
|
+
for (let index = definitions.length - 1; index >= 0; index--) {
|
|
1195
|
+
const definition = definitions[index];
|
|
1196
|
+
isRecursiveValueAtOrAfter ||=
|
|
1197
|
+
definition.isRecursive && definition.kind === "Operator" && definition.params.length === 0;
|
|
1198
|
+
// TLC's LET evaluates an operator without parameters in the context before it, which TLCEval#tlcEval tells from an empty one.
|
|
1199
|
+
const ownScope =
|
|
1200
|
+
definition.kind === "Operator" && definition.params.length === 0 && !isRecursiveValueAtOrAfter
|
|
1201
|
+
? nodes[index].parent
|
|
1202
|
+
: scope;
|
|
1121
1203
|
nodes[index].binding =
|
|
1122
1204
|
definition.kind === "Function"
|
|
1123
1205
|
? {
|
|
1124
1206
|
kind: "Thunk",
|
|
1125
|
-
expression:
|
|
1207
|
+
expression: getFunctionConstruction(definition, true),
|
|
1126
1208
|
scope,
|
|
1127
1209
|
state: context.state,
|
|
1128
1210
|
next: context.next,
|
|
@@ -1137,19 +1219,19 @@ export const bindDefinitions = (
|
|
|
1137
1219
|
name: definition.name,
|
|
1138
1220
|
params: definition.params,
|
|
1139
1221
|
body: definition.body,
|
|
1140
|
-
scope,
|
|
1222
|
+
scope: ownScope,
|
|
1141
1223
|
},
|
|
1142
1224
|
}
|
|
1143
1225
|
: {
|
|
1144
1226
|
kind: "Thunk",
|
|
1145
1227
|
expression: definition.body,
|
|
1146
|
-
scope,
|
|
1228
|
+
scope: ownScope,
|
|
1147
1229
|
state: context.state,
|
|
1148
1230
|
next: context.next,
|
|
1149
1231
|
cache: undefined,
|
|
1150
1232
|
isStreamed: reevaluated?.streamed.has(definition) ?? false,
|
|
1151
1233
|
};
|
|
1152
|
-
}
|
|
1234
|
+
}
|
|
1153
1235
|
const coverage = context.environment.coverage;
|
|
1154
1236
|
if (coverage && coverage.current !== -1) {
|
|
1155
1237
|
nodes.forEach((node) => {
|
|
@@ -1179,7 +1261,9 @@ const evaluateLocalIdentifier = (name: string, expression: Expression, context:
|
|
|
1179
1261
|
if (global?.kind === "Definition") {
|
|
1180
1262
|
return getDefinitionEvaluator(global.definition, context.environment)(context);
|
|
1181
1263
|
}
|
|
1182
|
-
const builtin = context.environment.builtins.get(
|
|
1264
|
+
const builtin = context.environment.builtins.get(
|
|
1265
|
+
context.environment.substitutions.get(name) ?? name,
|
|
1266
|
+
);
|
|
1183
1267
|
if (builtin?.arity === 0) return builtin.evaluate([], context);
|
|
1184
1268
|
throw new TlaEvaluationError(
|
|
1185
1269
|
`In evaluation, the identifier ${name} is either undefined or not an operator.\n${describeRange(expression)}`,
|
|
@@ -1190,7 +1274,9 @@ export const getReevaluatedDefinitions = (
|
|
|
1190
1274
|
definitions: Definition[],
|
|
1191
1275
|
environment: Environment,
|
|
1192
1276
|
): ReevaluatedDefinitions => ({
|
|
1193
|
-
impure: new Set(
|
|
1277
|
+
impure: new Set(
|
|
1278
|
+
definitions.filter((definition) => isImpureDefinition(definition, environment, "varying")),
|
|
1279
|
+
),
|
|
1194
1280
|
streamed: new Set(
|
|
1195
1281
|
definitions.filter((definition) => isImpureDefinition(definition, environment, "streamed")),
|
|
1196
1282
|
),
|
|
@@ -1322,7 +1408,6 @@ const headFingerprint = (callStack: CallStack, source: Expression, error: unknow
|
|
|
1322
1408
|
|
|
1323
1409
|
export const createTracingEnvironment = (environment: Environment): Environment => ({
|
|
1324
1410
|
...environment,
|
|
1325
|
-
coverage: undefined,
|
|
1326
1411
|
evaluators: new WeakMap(),
|
|
1327
1412
|
entryEvaluators: new WeakMap(),
|
|
1328
1413
|
definitionEvaluators: new WeakMap(),
|
|
@@ -1335,6 +1420,41 @@ export const createTracingEnvironment = (environment: Environment): Environment
|
|
|
1335
1420
|
},
|
|
1336
1421
|
});
|
|
1337
1422
|
|
|
1423
|
+
// TLC evaluates `a /\ b /\ c` as `(a /\ b) /\ c`, so its call stack holds each prefix.
|
|
1424
|
+
const compileTracedJunction = (
|
|
1425
|
+
expression: Expression & { kind: "And" | "Or" },
|
|
1426
|
+
operands: Evaluator[],
|
|
1427
|
+
callStack: CallStack | undefined,
|
|
1428
|
+
): Evaluator | undefined => {
|
|
1429
|
+
const range = expression.location.range;
|
|
1430
|
+
const prefixEnds = expression.prefixEnds;
|
|
1431
|
+
if (!callStack || expression.isBulleted || !range || !prefixEnds || operands.length < 3) {
|
|
1432
|
+
return undefined;
|
|
1433
|
+
}
|
|
1434
|
+
const prefixes = prefixEnds
|
|
1435
|
+
.slice(0, operands.length - 2)
|
|
1436
|
+
.map((end) => ({
|
|
1437
|
+
...expression,
|
|
1438
|
+
location: { ...expression.location, range: { ...range, end } },
|
|
1439
|
+
}))
|
|
1440
|
+
.reverse();
|
|
1441
|
+
const isAnd = expression.kind === "And";
|
|
1442
|
+
return (context) => {
|
|
1443
|
+
callStack.expressions.push(...prefixes);
|
|
1444
|
+
for (let index = 0; index < operands.length; index++) {
|
|
1445
|
+
if (index >= 2 && !callStack.isFrozen) callStack.expressions.pop();
|
|
1446
|
+
const value = operands[index](context);
|
|
1447
|
+
if (typeof value !== "boolean") throw createJunctionError(expression, index, value);
|
|
1448
|
+
if (value !== isAnd) {
|
|
1449
|
+
if (!callStack.isFrozen)
|
|
1450
|
+
callStack.expressions.length -= prefixes.length - Math.max(index - 1, 0);
|
|
1451
|
+
return value;
|
|
1452
|
+
}
|
|
1453
|
+
}
|
|
1454
|
+
return isAnd;
|
|
1455
|
+
};
|
|
1456
|
+
};
|
|
1457
|
+
|
|
1338
1458
|
const traceFrames =
|
|
1339
1459
|
(
|
|
1340
1460
|
expression: Expression,
|
|
@@ -1362,9 +1482,21 @@ const countEvaluator =
|
|
|
1362
1482
|
coverage.current = node;
|
|
1363
1483
|
try {
|
|
1364
1484
|
const value = evaluator(context);
|
|
1365
|
-
|
|
1366
|
-
|
|
1367
|
-
|
|
1485
|
+
const isTagged =
|
|
1486
|
+
expression.kind === "SetEnumeration" ||
|
|
1487
|
+
((expression.kind === "SetFilter" || expression.kind === "SetMap") &&
|
|
1488
|
+
isReducibleSet(value)) ||
|
|
1489
|
+
(expression.kind === "SetFilter" &&
|
|
1490
|
+
typeof value === "object" &&
|
|
1491
|
+
value.kind === "FilteredSet") ||
|
|
1492
|
+
((expression.kind === "FunctionSet" || expression.kind === "RecordSet") &&
|
|
1493
|
+
typeof value === "object" &&
|
|
1494
|
+
value.kind === expression.kind) ||
|
|
1495
|
+
(expression.kind === "Apply" &&
|
|
1496
|
+
expression.operator === "SUBSET" &&
|
|
1497
|
+
typeof value === "object" &&
|
|
1498
|
+
value.kind === "Subset");
|
|
1499
|
+
if (typeof value === "object" && isTagged) coverage.values.set(value, node);
|
|
1368
1500
|
return value;
|
|
1369
1501
|
} finally {
|
|
1370
1502
|
coverage.current = outer;
|
|
@@ -1514,6 +1646,26 @@ const compileClosureCall = (
|
|
|
1514
1646
|
};
|
|
1515
1647
|
};
|
|
1516
1648
|
|
|
1649
|
+
// TLC's LET conses only its arity-0 definitions onto the context that TLCEval#tlcEval caches under when it is empty.
|
|
1650
|
+
const isTlcContextEmpty = (scope: Scope | undefined) => {
|
|
1651
|
+
for (let node = scope; node !== undefined; node = node.parent) {
|
|
1652
|
+
const binding = node.binding;
|
|
1653
|
+
if (
|
|
1654
|
+
binding.kind !== "Operator" ||
|
|
1655
|
+
binding.operator.kind !== "Closure" ||
|
|
1656
|
+
binding.operator.params.length === 0
|
|
1657
|
+
) {
|
|
1658
|
+
return false;
|
|
1659
|
+
}
|
|
1660
|
+
let letScope = binding.operator.scope;
|
|
1661
|
+
while (letScope !== undefined && letScope !== node) letScope = letScope.parent;
|
|
1662
|
+
if (letScope !== node) return false;
|
|
1663
|
+
}
|
|
1664
|
+
return true;
|
|
1665
|
+
};
|
|
1666
|
+
|
|
1667
|
+
const SET_OPERATORS = new Set(["\\cup", "\\cap", "\\"]);
|
|
1668
|
+
|
|
1517
1669
|
const compileApply = (
|
|
1518
1670
|
expression: Expression & { kind: "Apply" },
|
|
1519
1671
|
environment: Environment,
|
|
@@ -1553,19 +1705,63 @@ const compileApply = (
|
|
|
1553
1705
|
return (context) => domain(operand(context));
|
|
1554
1706
|
}
|
|
1555
1707
|
if (global?.kind === "Builtin" && global.name === "TLCEval" && args.length === 1) {
|
|
1708
|
+
// Deviation from TLC: TLCEval#tlcEval evaluates an argument SANY takes for constant, such as Print(v, TRUE), in an empty state.
|
|
1556
1709
|
const isCached =
|
|
1557
1710
|
!contextualApplications.has(expression) && !isNonconstant(args[0], environment);
|
|
1558
|
-
|
|
1559
|
-
|
|
1560
|
-
|
|
1561
|
-
|
|
1562
|
-
|
|
1711
|
+
const tlcEvalValues = environment.tlcEvalValues;
|
|
1712
|
+
return (context) => {
|
|
1713
|
+
if (!isCached || !isTlcContextEmpty(context.scope)) {
|
|
1714
|
+
return global.evaluate(getLazyArguments(args, context), context);
|
|
1715
|
+
}
|
|
1716
|
+
const cached = tlcEvalValues.get(expression);
|
|
1717
|
+
if (cached !== undefined) return cached;
|
|
1718
|
+
const value = global.evaluate(getLazyArguments(args, context), undefined);
|
|
1719
|
+
tlcEvalValues.set(expression, value);
|
|
1720
|
+
return value;
|
|
1721
|
+
};
|
|
1722
|
+
}
|
|
1723
|
+
if (
|
|
1724
|
+
global?.kind === "Builtin" &&
|
|
1725
|
+
global.name === "\\subseteq" &&
|
|
1726
|
+
global.evaluateBinary &&
|
|
1727
|
+
args.length === 2
|
|
1728
|
+
) {
|
|
1729
|
+
const left = getEvaluator(args[0], environment);
|
|
1730
|
+
const right = getEvaluator(args[1], environment);
|
|
1731
|
+
const subset = getSubsetOperator(expression, global.evaluateBinary);
|
|
1732
|
+
const coverage = environment.coverage;
|
|
1733
|
+
if (!coverage) return (context) => subset(left(context), right(context));
|
|
1734
|
+
return (context) => {
|
|
1735
|
+
const leftValue = left(context);
|
|
1736
|
+
const rightValue = right(context);
|
|
1737
|
+
if (
|
|
1738
|
+
typeof leftValue !== "object" ||
|
|
1739
|
+
leftValue.kind !== "Set" ||
|
|
1740
|
+
!coverage.values.has(leftValue)
|
|
1741
|
+
) {
|
|
1742
|
+
return subset(leftValue, rightValue);
|
|
1743
|
+
}
|
|
1744
|
+
const missing = leftValue.elements.findIndex((element) => !isElementOf(element, rightValue));
|
|
1745
|
+
costCoverage(coverage, leftValue, (missing === -1 ? leftValue.elements.length : missing) + 1);
|
|
1746
|
+
return missing === -1;
|
|
1747
|
+
};
|
|
1563
1748
|
}
|
|
1564
|
-
|
|
1749
|
+
const coverage = environment.coverage;
|
|
1750
|
+
const combine = global?.kind === "Builtin" ? global.evaluateBinary : undefined;
|
|
1751
|
+
if (coverage && combine && SET_OPERATORS.has(expression.operator) && args.length === 2) {
|
|
1565
1752
|
const left = getEvaluator(args[0], environment);
|
|
1566
1753
|
const right = getEvaluator(args[1], environment);
|
|
1567
|
-
|
|
1568
|
-
|
|
1754
|
+
return (context) => {
|
|
1755
|
+
const leftValue = left(context);
|
|
1756
|
+
const rightValue = right(context);
|
|
1757
|
+
return chargeSetOperation(
|
|
1758
|
+
coverage,
|
|
1759
|
+
expression.operator,
|
|
1760
|
+
leftValue,
|
|
1761
|
+
rightValue,
|
|
1762
|
+
combine(leftValue, rightValue),
|
|
1763
|
+
);
|
|
1764
|
+
};
|
|
1569
1765
|
}
|
|
1570
1766
|
if (global?.kind === "Builtin") return compileBuiltinCall(global, args, environment);
|
|
1571
1767
|
if (expression.operator === "\\cdot" && args.length === 2) {
|
|
@@ -1598,6 +1794,18 @@ const compileQuantifier = (
|
|
|
1598
1794
|
const isForall = expression.kind === "Forall";
|
|
1599
1795
|
const body = getEvaluator(expression.body, environment);
|
|
1600
1796
|
const bound = expression.bounds[0];
|
|
1797
|
+
const coverage = environment.coverage;
|
|
1798
|
+
if (coverage) {
|
|
1799
|
+
return (context) => {
|
|
1800
|
+
const isFound = forEachChargedBinding(
|
|
1801
|
+
expression.bounds,
|
|
1802
|
+
context,
|
|
1803
|
+
coverage,
|
|
1804
|
+
(scope) => expectBooleanBody(body(withScope(context, scope)), expression) !== isForall,
|
|
1805
|
+
);
|
|
1806
|
+
return isFound ? !isForall : isForall;
|
|
1807
|
+
};
|
|
1808
|
+
}
|
|
1601
1809
|
if (expression.bounds.length === 1 && bound.pattern.kind === "Name") {
|
|
1602
1810
|
const name = bound.pattern.name;
|
|
1603
1811
|
const set = getEvaluator(bound.set, environment);
|
|
@@ -1723,8 +1931,14 @@ export const getFunctionBuilder = (
|
|
|
1723
1931
|
return markLambdaFunction(functionValue);
|
|
1724
1932
|
}
|
|
1725
1933
|
const pairs: [Value, Value][] = [];
|
|
1726
|
-
const sets = mapBoundSets(bounds, (set) =>
|
|
1727
|
-
getNormalizedElements(
|
|
1934
|
+
const sets = mapBoundSets(bounds, (set, index) =>
|
|
1935
|
+
getNormalizedElements(
|
|
1936
|
+
bounds.length > 1 && typeof domain === "object" && domain.kind === "ProductSet"
|
|
1937
|
+
? domain.factors[index]
|
|
1938
|
+
: domain,
|
|
1939
|
+
set,
|
|
1940
|
+
context.environment.runtime.version,
|
|
1941
|
+
),
|
|
1728
1942
|
);
|
|
1729
1943
|
forEachBoundElement(bounds, sets, context.scope, (scope) => {
|
|
1730
1944
|
const key =
|
|
@@ -1739,13 +1953,22 @@ export const getFunctionBuilder = (
|
|
|
1739
1953
|
const template = getLazyFunctionTemplate(bounds, expression.body);
|
|
1740
1954
|
const boundTupleLengths = getBoundTupleLengths(bounds);
|
|
1741
1955
|
const bodyNames = getScopeNames(expression.body);
|
|
1956
|
+
const coverage = environment.coverage;
|
|
1742
1957
|
const createLazy = (domain: Value, context: Context) => {
|
|
1743
1958
|
const scope = trimScope(context.scope, bodyNames);
|
|
1744
1959
|
const lambdaContext = withScope(context, scope);
|
|
1960
|
+
const compute = (argument: Value) =>
|
|
1961
|
+
body(withScope(lambdaContext, bindArgument(bounds, scope, argument)));
|
|
1962
|
+
const node = coverage && !environment.callStack ? coverage.current : -1;
|
|
1745
1963
|
const functionValue = keepLambda({
|
|
1746
1964
|
value: createLazyFunction(
|
|
1747
1965
|
domain,
|
|
1748
|
-
|
|
1966
|
+
coverage
|
|
1967
|
+
? (argument) =>
|
|
1968
|
+
coverage.current === -1
|
|
1969
|
+
? compute(argument)
|
|
1970
|
+
: runAtCoverageNode(coverage, node, () => compute(argument))
|
|
1971
|
+
: compute,
|
|
1749
1972
|
getLazyFunctionSource(template, bounds, domain),
|
|
1750
1973
|
boundTupleLengths,
|
|
1751
1974
|
),
|
|
@@ -1797,6 +2020,23 @@ const compileFunctionConstruction = (
|
|
|
1797
2020
|
): Evaluator => {
|
|
1798
2021
|
const build = getFunctionBuilder(expression, environment).build;
|
|
1799
2022
|
const bounds = expression.bounds;
|
|
2023
|
+
const coverage = environment.coverage;
|
|
2024
|
+
if (coverage) {
|
|
2025
|
+
return (context) => {
|
|
2026
|
+
const domain = getBoundsDomain(bounds, context);
|
|
2027
|
+
const value = build(domain, context);
|
|
2028
|
+
const sets =
|
|
2029
|
+
bounds.length === 1 || typeof domain !== "object" || domain.kind !== "ProductSet"
|
|
2030
|
+
? [domain]
|
|
2031
|
+
: domain.factors;
|
|
2032
|
+
const isConverted =
|
|
2033
|
+
(typeof value !== "object" || value.kind !== "LazyFunction") && sets.every(isReducibleSet);
|
|
2034
|
+
if (isConverted && coverage.current !== -1 && coverage.covered.has(expression)) {
|
|
2035
|
+
chargeFunctionConstruction(coverage, coverage.current, sets);
|
|
2036
|
+
}
|
|
2037
|
+
return value;
|
|
2038
|
+
};
|
|
2039
|
+
}
|
|
1800
2040
|
if (bounds.length === 1 && bounds[0].pattern.kind === "Name") {
|
|
1801
2041
|
const set = getEvaluator(bounds[0].set, environment);
|
|
1802
2042
|
return (context) => build(set(context), context);
|
|
@@ -1870,29 +2110,19 @@ export const getLazyFilter = (
|
|
|
1870
2110
|
) => {
|
|
1871
2111
|
const predicate = getEvaluator(expression.predicate, environment);
|
|
1872
2112
|
const pattern = expression.bound.pattern;
|
|
1873
|
-
const
|
|
1874
|
-
const source = range && {
|
|
2113
|
+
const predicateNode = describeNode(expression.predicate);
|
|
2114
|
+
const source = expression.predicate.location.range && {
|
|
1875
2115
|
names: pattern.kind === "Name" ? pattern.name : pattern.names.join(", "),
|
|
1876
|
-
predicate:
|
|
2116
|
+
predicate: predicateNode,
|
|
1877
2117
|
};
|
|
1878
|
-
const predicateNode = describeNode(expression.predicate);
|
|
1879
2118
|
const coverage = environment.coverage;
|
|
1880
|
-
const testCovered = (node: number, isMember: boolean, test: () => Value) => {
|
|
1881
|
-
if (!coverage || node === -1) return test();
|
|
1882
|
-
if (!isMember) coverage.secondary[node]++;
|
|
1883
|
-
const value = runAtCoverageNode(coverage, isMember ? -1 : node, test);
|
|
1884
|
-
if (!isMember && value === true) coverage.secondary[node]++;
|
|
1885
|
-
return value;
|
|
1886
|
-
};
|
|
1887
2119
|
const createFiltered = (
|
|
1888
2120
|
base: Value,
|
|
1889
2121
|
context: Context,
|
|
1890
2122
|
evaluator: Evaluator,
|
|
1891
2123
|
node: number,
|
|
1892
|
-
): RebindableFilteredSet =>
|
|
1893
|
-
|
|
1894
|
-
base,
|
|
1895
|
-
test: (element, isMember) => {
|
|
2124
|
+
): RebindableFilteredSet => {
|
|
2125
|
+
const test = (element: Value, isMember: boolean) => {
|
|
1896
2126
|
if (
|
|
1897
2127
|
pattern.kind === "Tuple" &&
|
|
1898
2128
|
getSequenceElements(element)?.length !== pattern.names.length
|
|
@@ -1901,29 +2131,60 @@ export const getLazyFilter = (
|
|
|
1901
2131
|
`Attempted to check if the value:\n${prettyPrint(formatValue(element))}\nis an element of a set of ${pattern.names.length}-tuples.`,
|
|
1902
2132
|
);
|
|
1903
2133
|
}
|
|
1904
|
-
const value =
|
|
1905
|
-
evaluator(withScope(context, bindPattern(context.scope, pattern, element))),
|
|
1906
|
-
);
|
|
2134
|
+
const value = evaluator(withScope(context, bindPattern(context.scope, pattern, element)));
|
|
1907
2135
|
if (typeof value !== "boolean") {
|
|
1908
2136
|
throw new TlaEvaluationError(
|
|
1909
2137
|
`${isMember ? "The evaluation of predicate" : "Evaluating predicate"} ${predicateNode} yielded non-Boolean value.`,
|
|
1910
2138
|
);
|
|
1911
2139
|
}
|
|
1912
2140
|
return value;
|
|
1913
|
-
}
|
|
1914
|
-
|
|
1915
|
-
rebind: (tracing) =>
|
|
2141
|
+
};
|
|
2142
|
+
const rebind = (tracing: Environment) =>
|
|
1916
2143
|
createFiltered(
|
|
1917
2144
|
base,
|
|
1918
2145
|
{ ...context, environment: tracing },
|
|
1919
2146
|
getEvaluator(expression.predicate, tracing),
|
|
1920
2147
|
-1,
|
|
1921
|
-
)
|
|
1922
|
-
|
|
2148
|
+
);
|
|
2149
|
+
if (!coverage || node === -1) return { kind: "FilteredSet", base, test, source, rebind };
|
|
2150
|
+
return {
|
|
2151
|
+
kind: "FilteredSet",
|
|
2152
|
+
base,
|
|
2153
|
+
test: (element, isMember) =>
|
|
2154
|
+
runAtCoverageNode(coverage, isMember ? -1 : node, () => test(element, isMember)),
|
|
2155
|
+
startPass: (isMaterialized) => {
|
|
2156
|
+
const draws = createProductSetEnumerator(coverage, base);
|
|
2157
|
+
return (element) => {
|
|
2158
|
+
draws?.next();
|
|
2159
|
+
tagSubset(coverage, base, element);
|
|
2160
|
+
coverage.secondary[node]++;
|
|
2161
|
+
const value = runAtCoverageNode(coverage, node, () => test(element, false));
|
|
2162
|
+
if (isMaterialized && value) coverage.secondary[node]++;
|
|
2163
|
+
return value;
|
|
2164
|
+
};
|
|
2165
|
+
},
|
|
2166
|
+
source,
|
|
2167
|
+
rebind,
|
|
2168
|
+
};
|
|
2169
|
+
};
|
|
1923
2170
|
return (base: Value, context: Context, node = -1) =>
|
|
1924
2171
|
createFiltered(base, context, predicate, node);
|
|
1925
2172
|
};
|
|
1926
2173
|
|
|
2174
|
+
const hasLocalName = (expression: Expression): boolean =>
|
|
2175
|
+
isLocallyResolved(expression) ||
|
|
2176
|
+
expression.kind === "OperatorReference" ||
|
|
2177
|
+
getChildren(expression).some(hasLocalName);
|
|
2178
|
+
|
|
2179
|
+
export const isUniformPredicate = (
|
|
2180
|
+
expression: Expression & { kind: "SetFilter" },
|
|
2181
|
+
environment: Environment,
|
|
2182
|
+
) =>
|
|
2183
|
+
expression.bound.pattern.kind === "Name" &&
|
|
2184
|
+
!environment.coverage &&
|
|
2185
|
+
!hasLocalName(expression.predicate) &&
|
|
2186
|
+
!isExpressionImpure([expression.predicate], environment, "varying");
|
|
2187
|
+
|
|
1927
2188
|
export const expectFilterPredicate = (
|
|
1928
2189
|
value: Value,
|
|
1929
2190
|
expression: Expression & { kind: "SetFilter" },
|
|
@@ -1966,32 +2227,34 @@ const compileSetComprehension = (
|
|
|
1966
2227
|
const filterLazily = getLazyFilter(expression, environment);
|
|
1967
2228
|
const pattern = expression.bound.pattern;
|
|
1968
2229
|
const coverage = environment.coverage;
|
|
2230
|
+
const isUniform = isUniformPredicate(expression, environment);
|
|
1969
2231
|
return (context) => {
|
|
1970
2232
|
const base = set(context);
|
|
1971
2233
|
if (!isReducibleSet(base)) return filterLazily(base, context, coverage?.current);
|
|
1972
2234
|
const kept: Value[] = [];
|
|
1973
|
-
const
|
|
2235
|
+
const elements = base.kind === "Interval" ? base : toFiniteSet(base).elements;
|
|
2236
|
+
const size = Array.isArray(elements) ? elements.length : elements.high - elements.low + 1;
|
|
2237
|
+
for (let position = 0; position < size; position++) {
|
|
2238
|
+
const element = Array.isArray(elements) ? elements[position] : elements.low + position;
|
|
1974
2239
|
const value = predicate(withScope(context, bindPattern(context.scope, pattern, element)));
|
|
1975
2240
|
if (expectFilterPredicate(value, expression)) addBoundedElement(kept, element);
|
|
1976
|
-
|
|
1977
|
-
const elements = base.kind === "Interval" ? base : toFiniteSet(base).elements;
|
|
1978
|
-
forEachElement(elements, visit);
|
|
1979
|
-
if (coverage && coverage.current !== -1) {
|
|
1980
|
-
coverage.secondary[coverage.current] +=
|
|
1981
|
-
(Array.isArray(elements) ? elements.length : elements.high - elements.low + 1) +
|
|
1982
|
-
kept.length;
|
|
2241
|
+
else if (isUniform) break;
|
|
1983
2242
|
}
|
|
2243
|
+
if (coverage) costCoverage(coverage, base, size + 1);
|
|
1984
2244
|
return createNormalizedSet(kept);
|
|
1985
2245
|
};
|
|
1986
2246
|
}
|
|
1987
2247
|
if (expression.kind === "SetMap") {
|
|
1988
2248
|
const mapped = getEvaluator(expression.expression, environment);
|
|
2249
|
+
const coverage = environment.coverage;
|
|
1989
2250
|
return (context) => {
|
|
1990
2251
|
const elements: Value[] = [];
|
|
1991
|
-
|
|
2252
|
+
const add = (scope: Scope | undefined) => {
|
|
1992
2253
|
addBoundedElement(elements, mapped(withScope(context, scope)));
|
|
1993
2254
|
return false;
|
|
1994
|
-
}
|
|
2255
|
+
};
|
|
2256
|
+
if (coverage) forEachChargedBinding(expression.bounds, context, coverage, add);
|
|
2257
|
+
else forEachBinding(expression.bounds, context, add);
|
|
1995
2258
|
return createEnumeratedSet(elements);
|
|
1996
2259
|
};
|
|
1997
2260
|
}
|
|
@@ -2005,16 +2268,15 @@ const compileSetComprehension = (
|
|
|
2005
2268
|
}
|
|
2006
2269
|
const body = getEvaluator(expression.body, environment);
|
|
2007
2270
|
const evaluateSet = getEvaluator(set, environment);
|
|
2271
|
+
const coverage = environment.coverage;
|
|
2008
2272
|
return (context) => {
|
|
2009
|
-
const
|
|
2010
|
-
|
|
2011
|
-
|
|
2012
|
-
set,
|
|
2013
|
-
context.environment.runtime.version,
|
|
2014
|
-
);
|
|
2273
|
+
const base = evaluateSet(context);
|
|
2274
|
+
const elements = getChoiceElements(base, expression, set, context.environment.runtime.version);
|
|
2275
|
+
const enumerator = coverage && createChargedEnumerator(coverage, base, elements, true);
|
|
2015
2276
|
let chosen: Value | undefined;
|
|
2016
2277
|
const pattern = expression.pattern;
|
|
2017
2278
|
someElement(elements, (element) => {
|
|
2279
|
+
enumerator?.next();
|
|
2018
2280
|
if (
|
|
2019
2281
|
pattern.kind === "Tuple" &&
|
|
2020
2282
|
getSequenceElements(element)?.length !== pattern.names.length
|
|
@@ -2028,8 +2290,9 @@ const compileSetComprehension = (
|
|
|
2028
2290
|
chosen = getBoundValue(pattern, scope);
|
|
2029
2291
|
return true;
|
|
2030
2292
|
});
|
|
2031
|
-
if (chosen
|
|
2032
|
-
|
|
2293
|
+
if (chosen !== undefined) return chosen;
|
|
2294
|
+
enumerator?.next();
|
|
2295
|
+
throw createNoChoiceError(expression);
|
|
2033
2296
|
};
|
|
2034
2297
|
};
|
|
2035
2298
|
|
|
@@ -2041,20 +2304,21 @@ export const hasDuplicateFields = (sortedFields: RecordField[]) =>
|
|
|
2041
2304
|
|
|
2042
2305
|
const compileRecord = (recordFields: RecordField[], environment: Environment): Evaluator => {
|
|
2043
2306
|
const fields = getSortedFields(recordFields);
|
|
2044
|
-
const
|
|
2045
|
-
|
|
2046
|
-
if (hasDuplicates) {
|
|
2307
|
+
const values = recordFields.map((field) => getEvaluator(field.value, environment));
|
|
2308
|
+
if (hasDuplicateFields(fields)) {
|
|
2047
2309
|
return (context) =>
|
|
2048
2310
|
createRecord(
|
|
2049
|
-
|
|
2311
|
+
recordFields.map((field, index): [string, Value] => [field.name, values[index](context)]),
|
|
2050
2312
|
);
|
|
2051
2313
|
}
|
|
2052
2314
|
const names = fields.map((field) => field.name);
|
|
2053
2315
|
const writtenNames = recordFields.map((field) => field.name);
|
|
2054
2316
|
if (writtenNames.some((name, index) => name !== names[index])) {
|
|
2317
|
+
const writtenIndexes = fields.map((field) => recordFields.indexOf(field));
|
|
2055
2318
|
return (context) =>
|
|
2056
2319
|
createWrittenRecord(
|
|
2057
2320
|
names,
|
|
2321
|
+
writtenIndexes,
|
|
2058
2322
|
values.map((value) => value(context)),
|
|
2059
2323
|
writtenNames,
|
|
2060
2324
|
);
|
|
@@ -2104,25 +2368,31 @@ const compile = (expression: Expression, environment: Environment): Evaluator =>
|
|
|
2104
2368
|
};
|
|
2105
2369
|
case "And": {
|
|
2106
2370
|
const operands = expression.operands.map(getChildEvaluator);
|
|
2107
|
-
return (
|
|
2108
|
-
|
|
2109
|
-
|
|
2110
|
-
|
|
2111
|
-
|
|
2112
|
-
|
|
2113
|
-
|
|
2114
|
-
|
|
2371
|
+
return (
|
|
2372
|
+
compileTracedJunction(expression, operands, environment.callStack) ??
|
|
2373
|
+
((context) => {
|
|
2374
|
+
for (let index = 0; index < operands.length; index++) {
|
|
2375
|
+
const value = operands[index](context);
|
|
2376
|
+
if (typeof value !== "boolean") throw createJunctionError(expression, index, value);
|
|
2377
|
+
if (!value) return false;
|
|
2378
|
+
}
|
|
2379
|
+
return true;
|
|
2380
|
+
})
|
|
2381
|
+
);
|
|
2115
2382
|
}
|
|
2116
2383
|
case "Or": {
|
|
2117
2384
|
const operands = expression.operands.map(getChildEvaluator);
|
|
2118
|
-
return (
|
|
2119
|
-
|
|
2120
|
-
|
|
2121
|
-
|
|
2122
|
-
|
|
2123
|
-
|
|
2124
|
-
|
|
2125
|
-
|
|
2385
|
+
return (
|
|
2386
|
+
compileTracedJunction(expression, operands, environment.callStack) ??
|
|
2387
|
+
((context) => {
|
|
2388
|
+
for (let index = 0; index < operands.length; index++) {
|
|
2389
|
+
const value = operands[index](context);
|
|
2390
|
+
if (typeof value !== "boolean") throw createJunctionError(expression, index, value);
|
|
2391
|
+
if (value) return true;
|
|
2392
|
+
}
|
|
2393
|
+
return false;
|
|
2394
|
+
})
|
|
2395
|
+
);
|
|
2126
2396
|
}
|
|
2127
2397
|
case "Prime": {
|
|
2128
2398
|
const inner = getChildEvaluator(expression.expression);
|
|
@@ -2208,8 +2478,19 @@ const compile = (expression: Expression, environment: Environment): Evaluator =>
|
|
|
2208
2478
|
case "RecordSet": {
|
|
2209
2479
|
const fields = getSortedFields(expression.fields);
|
|
2210
2480
|
const names = fields.map((field) => field.name);
|
|
2211
|
-
const
|
|
2212
|
-
|
|
2481
|
+
const writtenIndexes = fields.map((field) => expression.fields.indexOf(field));
|
|
2482
|
+
const sets = expression.fields.map((field) => getChildEvaluator(field.value));
|
|
2483
|
+
if (writtenIndexes.every((writtenIndex, index) => writtenIndex === index)) {
|
|
2484
|
+
return (context) => ({ kind: "RecordSet", names, sets: sets.map((set) => set(context)) });
|
|
2485
|
+
}
|
|
2486
|
+
return (context) => {
|
|
2487
|
+
const writtenSets = sets.map((set) => set(context));
|
|
2488
|
+
return {
|
|
2489
|
+
kind: "RecordSet",
|
|
2490
|
+
names,
|
|
2491
|
+
sets: writtenIndexes.map((index) => writtenSets[index]),
|
|
2492
|
+
};
|
|
2493
|
+
};
|
|
2213
2494
|
}
|
|
2214
2495
|
case "Except":
|
|
2215
2496
|
return compileExcept(expression, environment);
|
|
@@ -2276,6 +2557,8 @@ const compile = (expression: Expression, environment: Environment): Evaluator =>
|
|
|
2276
2557
|
}
|
|
2277
2558
|
case "Label":
|
|
2278
2559
|
return getChildEvaluator(expression.body);
|
|
2560
|
+
case "Selection":
|
|
2561
|
+
return getChildEvaluator(expression.expression);
|
|
2279
2562
|
case "Subexpression":
|
|
2280
2563
|
return () => {
|
|
2281
2564
|
throw new TlaEvaluationError(
|