tla-ts 0.0.10-dev.d618a2d79 → 0.0.10-dev.e3e5dd576
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 +36 -36
- package/dist/deciders.js +53 -53
- package/dist/index.cjs +1 -1
- package/dist/index.d.cts +18 -4
- package/dist/index.d.ts +18 -4
- 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 +56 -56
- package/dist/prove.js +78 -78
- package/dist/run.cjs +40 -44
- package/dist/run.js +42 -46
- package/dist/tlapm.cjs +1 -1
- package/dist/tlapm.js +2 -2
- package/dist/transfer.cjs +49 -44
- package/dist/transfer.js +48 -43
- package/dist/worker.cjs +7 -7
- package/dist/worker.js +7 -7
- package/package.json +1 -1
- package/src/ast.ts +14 -2
- package/src/bags.ts +50 -29
- package/src/builtins.ts +4 -3
- package/src/check-failure.ts +13 -11
- package/src/check-trace.ts +116 -64
- package/src/check.ts +516 -280
- package/src/cli/runtime-invariants.ts +20 -56
- package/src/cli/tlc-arguments.ts +2 -2
- package/src/cli/tlc-output.ts +18 -4
- package/src/cli/tlc.ts +18 -12
- package/src/cli/xml-exporter.ts +1 -1
- package/src/codegen.ts +23 -10
- package/src/coverage.ts +190 -1
- package/src/dependencies.ts +68 -15
- package/src/dfid.ts +101 -36
- package/src/environment.ts +123 -38
- package/src/errors.ts +7 -0
- package/src/evaluate.ts +370 -99
- package/src/exit-codes.ts +28 -14
- package/src/instances.ts +135 -11
- package/src/java-hash.ts +14 -0
- package/src/java-overrides.ts +2 -2
- package/src/levels.ts +675 -236
- package/src/lexer.ts +12 -2
- package/src/liveness-checker.ts +179 -60
- package/src/liveness.ts +51 -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/parallel-worker.ts +8 -2
- package/src/parallel.ts +5 -0
- package/src/parser.ts +180 -149
- 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 +171 -58
- package/src/prover/smt/solver/ast-lt.ts +1 -1
- package/src/prover/smt/solver/ast.ts +66 -14
- 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 +84 -15
- 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 +4 -11
- 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/expr2polynomial.ts +204 -79
- package/src/prover/smt/solver/factor.ts +36 -14
- package/src/prover/smt/solver/fd-solver.ts +608 -139
- package/src/prover/smt/solver/fix-dl-var.ts +1 -2
- package/src/prover/smt/solver/fpa-rewriter.ts +1 -2
- package/src/prover/smt/solver/fpa2bv-converter.ts +3 -1
- package/src/prover/smt/solver/fpa2bv-rewriter.ts +1 -0
- package/src/prover/smt/solver/goal.ts +6 -3
- package/src/prover/smt/solver/goal2nlsat.ts +57 -30
- 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-core.ts +1 -1
- package/src/prover/smt/solver/lp/nla-grobner.ts +158 -80
- package/src/prover/smt/solver/lp/nra-solver.ts +45 -39
- package/src/prover/smt/solver/lp/pdd-interval.ts +6 -2
- package/src/prover/smt/solver/lp/pdd-simplifier.ts +60 -20
- package/src/prover/smt/solver/lp/pdd-solver.ts +72 -39
- package/src/prover/smt/solver/lp/pdd.ts +725 -290
- 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 +22 -44
- 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 +2 -4
- package/src/prover/smt/solver/muz/spacer-pdr.ts +1 -0
- 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 +196 -92
- package/src/prover/smt/solver/nlsat/atoms.ts +52 -33
- package/src/prover/smt/solver/nlsat/explain.ts +375 -217
- package/src/prover/smt/solver/nlsat/levelwise.ts +460 -240
- package/src/prover/smt/solver/nlsat/polynomial.ts +2366 -681
- package/src/prover/smt/solver/nlsat/solver.ts +74 -64
- package/src/prover/smt/solver/nlsat/transcendentals.ts +41 -17
- package/src/prover/smt/solver/nlsat/upolynomial-factorization.ts +8 -4
- package/src/prover/smt/solver/nlsat/upolynomial.ts +41 -18
- 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 +21 -7
- package/src/prover/smt/solver/opt-nlsat.ts +29 -18
- 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 +10 -6
- 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/quantifier-manager.ts +14 -9
- 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 +17 -7
- 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 +2 -2
- 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 +48 -7
- package/src/prover/smt/solver/smt-setup.ts +106 -13
- package/src/prover/smt/solver/smtlib-parser.ts +589 -224
- package/src/prover/smt/solver/smtlib-script.ts +713 -210
- 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 +350 -195
- 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 +1274 -257
- package/src/runtime.ts +7 -1
- package/src/sany/builtins.ts +10 -10
- package/src/sany/generation.ts +5 -15
- package/src/sany/generator-def-entries.ts +123 -36
- package/src/sany/generator-definitions.ts +5 -3
- package/src/sany/generator-expressions.ts +60 -37
- package/src/sany/generator-proofs.ts +18 -12
- package/src/sany/generator.ts +12 -6
- 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 +319 -135
- package/src/simulate.ts +235 -182
- package/src/spec-description.ts +8 -6
- package/src/standard-definitions.ts +1 -0
- package/src/standard-modules.ts +56 -22
- package/src/subexpressions.ts +564 -138
- package/src/successors.ts +37 -13
- package/src/symmetry.ts +2 -1
- package/src/tlc/jar-data.ts +10 -0
- package/src/tlc/messages.ts +3 -3
- package/src/tlc/order.ts +14 -3
- package/src/tlc/random.ts +2 -1
- package/src/tlc/replay.ts +67 -43
- package/src/tlc/tlc-operators.ts +10 -8
- package/src/tlc/tlcext-operators.ts +44 -15
- 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
|
@@ -22,13 +22,27 @@ import {
|
|
|
22
22
|
} from "./errors";
|
|
23
23
|
import { EXIT_STATUS, setExitCode } from "./exit-codes";
|
|
24
24
|
import { generateEvaluator } from "./codegen";
|
|
25
|
-
import {
|
|
25
|
+
import {
|
|
26
|
+
chargeContexts,
|
|
27
|
+
chargeFunctionConstruction,
|
|
28
|
+
chargeSetOperation,
|
|
29
|
+
costCoverage,
|
|
30
|
+
countCoverage,
|
|
31
|
+
createChargedEnumerator,
|
|
32
|
+
createProductSetEnumerator,
|
|
33
|
+
getCoverageNode,
|
|
34
|
+
runAtCoverageNode,
|
|
35
|
+
tagSubset,
|
|
36
|
+
type Coverage,
|
|
37
|
+
} from "./coverage";
|
|
26
38
|
import { MESSAGE_CODE } from "./tlc/messages";
|
|
27
39
|
import type { CheckerRuntime } from "./runtime";
|
|
28
40
|
import {
|
|
29
|
-
|
|
41
|
+
isEvaluatedAtStartup,
|
|
42
|
+
isExpressionImpure,
|
|
30
43
|
isImpureDefinition,
|
|
31
44
|
isNonconstant,
|
|
45
|
+
isTlcEvalReached,
|
|
32
46
|
type DefinitionFacts,
|
|
33
47
|
} from "./dependencies";
|
|
34
48
|
import { contextualApplications, substitutionFrames } from "./instances";
|
|
@@ -152,6 +166,7 @@ export interface Environment {
|
|
|
152
166
|
variableIndex: Map<string, number>;
|
|
153
167
|
facts: DefinitionFacts;
|
|
154
168
|
startupValues: (Value | undefined)[];
|
|
169
|
+
tlcEvalValues: WeakMap<Expression, Value>;
|
|
155
170
|
substitutedDefinitions: Set<Definition>;
|
|
156
171
|
instanceParams: Set<OperatorParam>;
|
|
157
172
|
evaluators: WeakMap<Expression, Evaluator>;
|
|
@@ -320,15 +335,14 @@ export const getDomainOperator = (expression: Expression) => (value: Value) => {
|
|
|
320
335
|
};
|
|
321
336
|
|
|
322
337
|
export const getSubsetOperator =
|
|
323
|
-
(expression: Expression,
|
|
338
|
+
(expression: Expression, subset: (left: Value, right: Value) => Value) =>
|
|
339
|
+
(left: Value, right: Value) => {
|
|
324
340
|
if (!isSetValue(left) || isOverriddenSet(left)) {
|
|
325
341
|
throw new TlaEvaluationError(
|
|
326
342
|
`Attempted to evaluate an expression of form S \\subseteq T, but S was not enumerable.\n${describeRange(expression)}`,
|
|
327
343
|
);
|
|
328
344
|
}
|
|
329
|
-
return
|
|
330
|
-
? builtin.evaluateBinary(left, right)
|
|
331
|
-
: builtin.evaluate([left, right]);
|
|
345
|
+
return subset(left, right);
|
|
332
346
|
};
|
|
333
347
|
|
|
334
348
|
export const createRealNumberError = (expression: DecimalExpression) =>
|
|
@@ -523,10 +537,13 @@ const someElement = (
|
|
|
523
537
|
return false;
|
|
524
538
|
};
|
|
525
539
|
|
|
526
|
-
export const mapBoundSets = <Result>(
|
|
540
|
+
export const mapBoundSets = <Result>(
|
|
541
|
+
bounds: Bound[],
|
|
542
|
+
map: (set: Expression, index: number) => Result,
|
|
543
|
+
) =>
|
|
527
544
|
bounds.reduce<Result[]>((results, bound, index) => {
|
|
528
545
|
results.push(
|
|
529
|
-
index > 0 && bounds[index - 1].set === bound.set ? results[index - 1] : map(bound.set),
|
|
546
|
+
index > 0 && bounds[index - 1].set === bound.set ? results[index - 1] : map(bound.set, index),
|
|
530
547
|
);
|
|
531
548
|
return results;
|
|
532
549
|
}, []);
|
|
@@ -557,6 +574,31 @@ export const forEachBinding = (
|
|
|
557
574
|
visit: (scope: Scope | undefined) => boolean,
|
|
558
575
|
) => forEachBoundElement(bounds, getBoundElements(bounds, context), context.scope, visit);
|
|
559
576
|
|
|
577
|
+
const forEachChargedBinding = (
|
|
578
|
+
bounds: Bound[],
|
|
579
|
+
context: Context,
|
|
580
|
+
coverage: Coverage,
|
|
581
|
+
visit: (scope: Scope | undefined) => boolean,
|
|
582
|
+
) => {
|
|
583
|
+
const bounded = mapBoundSets(bounds, (set) => {
|
|
584
|
+
const value = evaluate(set, context);
|
|
585
|
+
return {
|
|
586
|
+
value,
|
|
587
|
+
elements: getQuantifierElements(value, set, context.environment.runtime.version),
|
|
588
|
+
};
|
|
589
|
+
});
|
|
590
|
+
const sets = bounded.map((item) => item.elements);
|
|
591
|
+
const charge = chargeContexts(
|
|
592
|
+
coverage,
|
|
593
|
+
bounded.map((item) => item.value),
|
|
594
|
+
sets,
|
|
595
|
+
);
|
|
596
|
+
return forEachBoundElement(bounds, sets, context.scope, (scope) => {
|
|
597
|
+
charge();
|
|
598
|
+
return visit(scope);
|
|
599
|
+
});
|
|
600
|
+
};
|
|
601
|
+
|
|
560
602
|
const getBoundsDomain = (bounds: Bound[], context: Context): Value => {
|
|
561
603
|
const sets = mapBoundSets(bounds, (set) => evaluate(set, context));
|
|
562
604
|
return sets.length === 1 ? sets[0] : { kind: "ProductSet", factors: sets };
|
|
@@ -615,12 +657,16 @@ export const bindLazyArguments = (
|
|
|
615
657
|
typeof value.domain === "object" && value.domain.kind === "ProductSet"
|
|
616
658
|
? value.domain.factors
|
|
617
659
|
: [];
|
|
618
|
-
|
|
660
|
+
if (elements === undefined) {
|
|
661
|
+
throw new TlaEvaluationError(
|
|
662
|
+
`Attempted to apply a function to an argument not in its domain.\n${describeRange(expression.function)}`,
|
|
663
|
+
);
|
|
664
|
+
}
|
|
665
|
+
// Deviation from TLC: Tool#getFcnContext indexes past an argument tuple shorter than the bounds and ignores a longer one.
|
|
619
666
|
const createListError = () =>
|
|
620
667
|
new TlaEvaluationError(
|
|
621
668
|
`In applying the function\n${prettyPrint(formatValue(value))},\nthe argument list is:\n${prettyPrint(formatValue(argument))}\nwhich does not match its formal parameter.\n`,
|
|
622
669
|
);
|
|
623
|
-
if (elements === undefined) throw createListError();
|
|
624
670
|
bounds.forEach((bound, index) => {
|
|
625
671
|
if (index >= elements.length) throw createListError();
|
|
626
672
|
const element = elements[index];
|
|
@@ -669,7 +715,7 @@ const getLazyFunctionTemplate = (bounds: Bound[], body: Expression) => {
|
|
|
669
715
|
},
|
|
670
716
|
],
|
|
671
717
|
),
|
|
672
|
-
body:
|
|
718
|
+
body: describeNode(body),
|
|
673
719
|
};
|
|
674
720
|
};
|
|
675
721
|
|
|
@@ -793,14 +839,27 @@ const compileDefinitionBody = (definition: Definition, environment: Environment)
|
|
|
793
839
|
return getEntryEvaluator(getDefinitionSource(definition), environment);
|
|
794
840
|
};
|
|
795
841
|
|
|
842
|
+
const CALLER_SCOPE: Scope = {
|
|
843
|
+
name: "",
|
|
844
|
+
binding: { kind: "Value", value: false },
|
|
845
|
+
parent: undefined,
|
|
846
|
+
};
|
|
847
|
+
|
|
796
848
|
const getDefinitionEvaluator = (definition: Definition, environment: Environment): Evaluator => {
|
|
797
849
|
const compiled = environment.definitionEvaluators.get(definition);
|
|
798
850
|
if (compiled) return compiled;
|
|
799
851
|
const body = compileDefinitionBody(definition, environment);
|
|
800
852
|
const definitionId = environment.facts.ids.get(definition);
|
|
801
853
|
const startupValues = environment.startupValues;
|
|
802
|
-
const
|
|
803
|
-
|
|
854
|
+
const isInCallerContext =
|
|
855
|
+
definition.kind === "Operator" &&
|
|
856
|
+
definition.params.length === 0 &&
|
|
857
|
+
isTlcEvalReached(definition.body, environment);
|
|
858
|
+
const evaluator: Evaluator = isInCallerContext
|
|
859
|
+
? (context) =>
|
|
860
|
+
(definitionId === undefined ? undefined : startupValues[definitionId]) ??
|
|
861
|
+
body(withScope(context, isTlcContextEmpty(context.scope) ? undefined : CALLER_SCOPE))
|
|
862
|
+
: definitionId === undefined
|
|
804
863
|
? (context) => body(withScope(context, undefined))
|
|
805
864
|
: (context) => startupValues[definitionId] ?? body(withScope(context, undefined));
|
|
806
865
|
environment.definitionEvaluators.set(definition, evaluator);
|
|
@@ -817,7 +876,7 @@ export const evaluateStartupDefinitions = (definitions: Definition[], environmen
|
|
|
817
876
|
if (definition.kind === "Operator" && definition.params.length > 0) return;
|
|
818
877
|
const name = definition.name;
|
|
819
878
|
if (environment.constants.has(name) || environment.substitutions.has(name)) return;
|
|
820
|
-
if (!
|
|
879
|
+
if (!isEvaluatedAtStartup(definition, environment)) return;
|
|
821
880
|
const definitionId = environment.facts.ids.get(definition);
|
|
822
881
|
if (definitionId === undefined || environment.startupValues[definitionId] !== undefined) return;
|
|
823
882
|
const context = { environment, scope: undefined, state: undefined, next: undefined };
|
|
@@ -969,6 +1028,7 @@ const isOperatorArgument = (expression: Expression, context: Context) => {
|
|
|
969
1028
|
return operator !== undefined && getArity(operator) > 0;
|
|
970
1029
|
};
|
|
971
1030
|
|
|
1031
|
+
// 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.
|
|
972
1032
|
const evaluateBuiltinArguments = (args: Expression[], context: Context) =>
|
|
973
1033
|
args.map((arg) =>
|
|
974
1034
|
isOperatorArgument(arg, context)
|
|
@@ -1113,7 +1173,15 @@ export const bindDefinitions = (
|
|
|
1113
1173
|
node.parent = parent;
|
|
1114
1174
|
return node;
|
|
1115
1175
|
}, context.scope);
|
|
1116
|
-
|
|
1176
|
+
let isRecursiveAtOrAfter = false;
|
|
1177
|
+
for (let index = definitions.length - 1; index >= 0; index--) {
|
|
1178
|
+
const definition = definitions[index];
|
|
1179
|
+
isRecursiveAtOrAfter ||= definition.isRecursive;
|
|
1180
|
+
// TLC's LET evaluates an operator without parameters in the context before it, which TLCEval#tlcEval tells from an empty one.
|
|
1181
|
+
const ownScope =
|
|
1182
|
+
definition.kind === "Operator" && definition.params.length === 0 && !isRecursiveAtOrAfter
|
|
1183
|
+
? nodes[index].parent
|
|
1184
|
+
: scope;
|
|
1117
1185
|
nodes[index].binding =
|
|
1118
1186
|
definition.kind === "Function"
|
|
1119
1187
|
? {
|
|
@@ -1133,19 +1201,19 @@ export const bindDefinitions = (
|
|
|
1133
1201
|
name: definition.name,
|
|
1134
1202
|
params: definition.params,
|
|
1135
1203
|
body: definition.body,
|
|
1136
|
-
scope,
|
|
1204
|
+
scope: ownScope,
|
|
1137
1205
|
},
|
|
1138
1206
|
}
|
|
1139
1207
|
: {
|
|
1140
1208
|
kind: "Thunk",
|
|
1141
1209
|
expression: definition.body,
|
|
1142
|
-
scope,
|
|
1210
|
+
scope: ownScope,
|
|
1143
1211
|
state: context.state,
|
|
1144
1212
|
next: context.next,
|
|
1145
1213
|
cache: undefined,
|
|
1146
1214
|
isStreamed: reevaluated?.streamed.has(definition) ?? false,
|
|
1147
1215
|
};
|
|
1148
|
-
}
|
|
1216
|
+
}
|
|
1149
1217
|
const coverage = context.environment.coverage;
|
|
1150
1218
|
if (coverage && coverage.current !== -1) {
|
|
1151
1219
|
nodes.forEach((node) => {
|
|
@@ -1175,16 +1243,22 @@ const evaluateLocalIdentifier = (name: string, expression: Expression, context:
|
|
|
1175
1243
|
if (global?.kind === "Definition") {
|
|
1176
1244
|
return getDefinitionEvaluator(global.definition, context.environment)(context);
|
|
1177
1245
|
}
|
|
1178
|
-
const builtin = context.environment.builtins.get(
|
|
1246
|
+
const builtin = context.environment.builtins.get(
|
|
1247
|
+
context.environment.substitutions.get(name) ?? name,
|
|
1248
|
+
);
|
|
1179
1249
|
if (builtin?.arity === 0) return builtin.evaluate([], context);
|
|
1180
|
-
throw new TlaEvaluationError(
|
|
1250
|
+
throw new TlaEvaluationError(
|
|
1251
|
+
`In evaluation, the identifier ${name} is either undefined or not an operator.\n${describeRange(expression)}`,
|
|
1252
|
+
);
|
|
1181
1253
|
};
|
|
1182
1254
|
|
|
1183
1255
|
export const getReevaluatedDefinitions = (
|
|
1184
1256
|
definitions: Definition[],
|
|
1185
1257
|
environment: Environment,
|
|
1186
1258
|
): ReevaluatedDefinitions => ({
|
|
1187
|
-
impure: new Set(
|
|
1259
|
+
impure: new Set(
|
|
1260
|
+
definitions.filter((definition) => isImpureDefinition(definition, environment, "varying")),
|
|
1261
|
+
),
|
|
1188
1262
|
streamed: new Set(
|
|
1189
1263
|
definitions.filter((definition) => isImpureDefinition(definition, environment, "streamed")),
|
|
1190
1264
|
),
|
|
@@ -1316,7 +1390,6 @@ const headFingerprint = (callStack: CallStack, source: Expression, error: unknow
|
|
|
1316
1390
|
|
|
1317
1391
|
export const createTracingEnvironment = (environment: Environment): Environment => ({
|
|
1318
1392
|
...environment,
|
|
1319
|
-
coverage: undefined,
|
|
1320
1393
|
evaluators: new WeakMap(),
|
|
1321
1394
|
entryEvaluators: new WeakMap(),
|
|
1322
1395
|
definitionEvaluators: new WeakMap(),
|
|
@@ -1329,6 +1402,41 @@ export const createTracingEnvironment = (environment: Environment): Environment
|
|
|
1329
1402
|
},
|
|
1330
1403
|
});
|
|
1331
1404
|
|
|
1405
|
+
// TLC evaluates `a /\ b /\ c` as `(a /\ b) /\ c`, so its call stack holds each prefix.
|
|
1406
|
+
const compileTracedJunction = (
|
|
1407
|
+
expression: Expression & { kind: "And" | "Or" },
|
|
1408
|
+
operands: Evaluator[],
|
|
1409
|
+
callStack: CallStack | undefined,
|
|
1410
|
+
): Evaluator | undefined => {
|
|
1411
|
+
const range = expression.location.range;
|
|
1412
|
+
const prefixEnds = expression.prefixEnds;
|
|
1413
|
+
if (!callStack || expression.isBulleted || !range || !prefixEnds || operands.length < 3) {
|
|
1414
|
+
return undefined;
|
|
1415
|
+
}
|
|
1416
|
+
const prefixes = prefixEnds
|
|
1417
|
+
.slice(0, operands.length - 2)
|
|
1418
|
+
.map((end) => ({
|
|
1419
|
+
...expression,
|
|
1420
|
+
location: { ...expression.location, range: { ...range, end } },
|
|
1421
|
+
}))
|
|
1422
|
+
.reverse();
|
|
1423
|
+
const isAnd = expression.kind === "And";
|
|
1424
|
+
return (context) => {
|
|
1425
|
+
callStack.expressions.push(...prefixes);
|
|
1426
|
+
for (let index = 0; index < operands.length; index++) {
|
|
1427
|
+
if (index >= 2 && !callStack.isFrozen) callStack.expressions.pop();
|
|
1428
|
+
const value = operands[index](context);
|
|
1429
|
+
if (typeof value !== "boolean") throw createJunctionError(expression, index, value);
|
|
1430
|
+
if (value !== isAnd) {
|
|
1431
|
+
if (!callStack.isFrozen)
|
|
1432
|
+
callStack.expressions.length -= prefixes.length - Math.max(index - 1, 0);
|
|
1433
|
+
return value;
|
|
1434
|
+
}
|
|
1435
|
+
}
|
|
1436
|
+
return isAnd;
|
|
1437
|
+
};
|
|
1438
|
+
};
|
|
1439
|
+
|
|
1332
1440
|
const traceFrames =
|
|
1333
1441
|
(
|
|
1334
1442
|
expression: Expression,
|
|
@@ -1356,9 +1464,21 @@ const countEvaluator =
|
|
|
1356
1464
|
coverage.current = node;
|
|
1357
1465
|
try {
|
|
1358
1466
|
const value = evaluator(context);
|
|
1359
|
-
|
|
1360
|
-
|
|
1361
|
-
|
|
1467
|
+
const isTagged =
|
|
1468
|
+
expression.kind === "SetEnumeration" ||
|
|
1469
|
+
((expression.kind === "SetFilter" || expression.kind === "SetMap") &&
|
|
1470
|
+
isReducibleSet(value)) ||
|
|
1471
|
+
(expression.kind === "SetFilter" &&
|
|
1472
|
+
typeof value === "object" &&
|
|
1473
|
+
value.kind === "FilteredSet") ||
|
|
1474
|
+
((expression.kind === "FunctionSet" || expression.kind === "RecordSet") &&
|
|
1475
|
+
typeof value === "object" &&
|
|
1476
|
+
value.kind === expression.kind) ||
|
|
1477
|
+
(expression.kind === "Apply" &&
|
|
1478
|
+
expression.operator === "SUBSET" &&
|
|
1479
|
+
typeof value === "object" &&
|
|
1480
|
+
value.kind === "Subset");
|
|
1481
|
+
if (typeof value === "object" && isTagged) coverage.values.set(value, node);
|
|
1362
1482
|
return value;
|
|
1363
1483
|
} finally {
|
|
1364
1484
|
coverage.current = outer;
|
|
@@ -1508,6 +1628,26 @@ const compileClosureCall = (
|
|
|
1508
1628
|
};
|
|
1509
1629
|
};
|
|
1510
1630
|
|
|
1631
|
+
// TLC's LET conses only its arity-0 definitions onto the context that TLCEval#tlcEval caches under when it is empty.
|
|
1632
|
+
const isTlcContextEmpty = (scope: Scope | undefined) => {
|
|
1633
|
+
for (let node = scope; node !== undefined; node = node.parent) {
|
|
1634
|
+
const binding = node.binding;
|
|
1635
|
+
if (
|
|
1636
|
+
binding.kind !== "Operator" ||
|
|
1637
|
+
binding.operator.kind !== "Closure" ||
|
|
1638
|
+
binding.operator.params.length === 0
|
|
1639
|
+
) {
|
|
1640
|
+
return false;
|
|
1641
|
+
}
|
|
1642
|
+
let letScope = binding.operator.scope;
|
|
1643
|
+
while (letScope !== undefined && letScope !== node) letScope = letScope.parent;
|
|
1644
|
+
if (letScope !== node) return false;
|
|
1645
|
+
}
|
|
1646
|
+
return true;
|
|
1647
|
+
};
|
|
1648
|
+
|
|
1649
|
+
const SET_OPERATORS = new Set(["\\cup", "\\cap", "\\"]);
|
|
1650
|
+
|
|
1511
1651
|
const compileApply = (
|
|
1512
1652
|
expression: Expression & { kind: "Apply" },
|
|
1513
1653
|
environment: Environment,
|
|
@@ -1547,19 +1687,63 @@ const compileApply = (
|
|
|
1547
1687
|
return (context) => domain(operand(context));
|
|
1548
1688
|
}
|
|
1549
1689
|
if (global?.kind === "Builtin" && global.name === "TLCEval" && args.length === 1) {
|
|
1690
|
+
// Deviation from TLC: TLCEval#tlcEval evaluates an argument SANY takes for constant, such as Print(v, TRUE), in an empty state.
|
|
1550
1691
|
const isCached =
|
|
1551
1692
|
!contextualApplications.has(expression) && !isNonconstant(args[0], environment);
|
|
1552
|
-
|
|
1553
|
-
|
|
1554
|
-
|
|
1555
|
-
|
|
1556
|
-
|
|
1693
|
+
const tlcEvalValues = environment.tlcEvalValues;
|
|
1694
|
+
return (context) => {
|
|
1695
|
+
if (!isCached || !isTlcContextEmpty(context.scope)) {
|
|
1696
|
+
return global.evaluate(getLazyArguments(args, context), context);
|
|
1697
|
+
}
|
|
1698
|
+
const cached = tlcEvalValues.get(expression);
|
|
1699
|
+
if (cached !== undefined) return cached;
|
|
1700
|
+
const value = global.evaluate(getLazyArguments(args, context), undefined);
|
|
1701
|
+
tlcEvalValues.set(expression, value);
|
|
1702
|
+
return value;
|
|
1703
|
+
};
|
|
1557
1704
|
}
|
|
1558
|
-
if (
|
|
1705
|
+
if (
|
|
1706
|
+
global?.kind === "Builtin" &&
|
|
1707
|
+
global.name === "\\subseteq" &&
|
|
1708
|
+
global.evaluateBinary &&
|
|
1709
|
+
args.length === 2
|
|
1710
|
+
) {
|
|
1559
1711
|
const left = getEvaluator(args[0], environment);
|
|
1560
1712
|
const right = getEvaluator(args[1], environment);
|
|
1561
|
-
const subset = getSubsetOperator(expression, global);
|
|
1562
|
-
|
|
1713
|
+
const subset = getSubsetOperator(expression, global.evaluateBinary);
|
|
1714
|
+
const coverage = environment.coverage;
|
|
1715
|
+
if (!coverage) return (context) => subset(left(context), right(context));
|
|
1716
|
+
return (context) => {
|
|
1717
|
+
const leftValue = left(context);
|
|
1718
|
+
const rightValue = right(context);
|
|
1719
|
+
if (
|
|
1720
|
+
typeof leftValue !== "object" ||
|
|
1721
|
+
leftValue.kind !== "Set" ||
|
|
1722
|
+
!coverage.values.has(leftValue)
|
|
1723
|
+
) {
|
|
1724
|
+
return subset(leftValue, rightValue);
|
|
1725
|
+
}
|
|
1726
|
+
const missing = leftValue.elements.findIndex((element) => !isElementOf(element, rightValue));
|
|
1727
|
+
costCoverage(coverage, leftValue, (missing === -1 ? leftValue.elements.length : missing) + 1);
|
|
1728
|
+
return missing === -1;
|
|
1729
|
+
};
|
|
1730
|
+
}
|
|
1731
|
+
const coverage = environment.coverage;
|
|
1732
|
+
const combine = global?.kind === "Builtin" ? global.evaluateBinary : undefined;
|
|
1733
|
+
if (coverage && combine && SET_OPERATORS.has(expression.operator) && args.length === 2) {
|
|
1734
|
+
const left = getEvaluator(args[0], environment);
|
|
1735
|
+
const right = getEvaluator(args[1], environment);
|
|
1736
|
+
return (context) => {
|
|
1737
|
+
const leftValue = left(context);
|
|
1738
|
+
const rightValue = right(context);
|
|
1739
|
+
return chargeSetOperation(
|
|
1740
|
+
coverage,
|
|
1741
|
+
expression.operator,
|
|
1742
|
+
leftValue,
|
|
1743
|
+
rightValue,
|
|
1744
|
+
combine(leftValue, rightValue),
|
|
1745
|
+
);
|
|
1746
|
+
};
|
|
1563
1747
|
}
|
|
1564
1748
|
if (global?.kind === "Builtin") return compileBuiltinCall(global, args, environment);
|
|
1565
1749
|
if (expression.operator === "\\cdot" && args.length === 2) {
|
|
@@ -1592,6 +1776,18 @@ const compileQuantifier = (
|
|
|
1592
1776
|
const isForall = expression.kind === "Forall";
|
|
1593
1777
|
const body = getEvaluator(expression.body, environment);
|
|
1594
1778
|
const bound = expression.bounds[0];
|
|
1779
|
+
const coverage = environment.coverage;
|
|
1780
|
+
if (coverage) {
|
|
1781
|
+
return (context) => {
|
|
1782
|
+
const isFound = forEachChargedBinding(
|
|
1783
|
+
expression.bounds,
|
|
1784
|
+
context,
|
|
1785
|
+
coverage,
|
|
1786
|
+
(scope) => expectBooleanBody(body(withScope(context, scope)), expression) !== isForall,
|
|
1787
|
+
);
|
|
1788
|
+
return isFound ? !isForall : isForall;
|
|
1789
|
+
};
|
|
1790
|
+
}
|
|
1595
1791
|
if (expression.bounds.length === 1 && bound.pattern.kind === "Name") {
|
|
1596
1792
|
const name = bound.pattern.name;
|
|
1597
1793
|
const set = getEvaluator(bound.set, environment);
|
|
@@ -1717,8 +1913,14 @@ export const getFunctionBuilder = (
|
|
|
1717
1913
|
return markLambdaFunction(functionValue);
|
|
1718
1914
|
}
|
|
1719
1915
|
const pairs: [Value, Value][] = [];
|
|
1720
|
-
const sets = mapBoundSets(bounds, (set) =>
|
|
1721
|
-
getNormalizedElements(
|
|
1916
|
+
const sets = mapBoundSets(bounds, (set, index) =>
|
|
1917
|
+
getNormalizedElements(
|
|
1918
|
+
bounds.length > 1 && typeof domain === "object" && domain.kind === "ProductSet"
|
|
1919
|
+
? domain.factors[index]
|
|
1920
|
+
: domain,
|
|
1921
|
+
set,
|
|
1922
|
+
context.environment.runtime.version,
|
|
1923
|
+
),
|
|
1722
1924
|
);
|
|
1723
1925
|
forEachBoundElement(bounds, sets, context.scope, (scope) => {
|
|
1724
1926
|
const key =
|
|
@@ -1733,13 +1935,22 @@ export const getFunctionBuilder = (
|
|
|
1733
1935
|
const template = getLazyFunctionTemplate(bounds, expression.body);
|
|
1734
1936
|
const boundTupleLengths = getBoundTupleLengths(bounds);
|
|
1735
1937
|
const bodyNames = getScopeNames(expression.body);
|
|
1938
|
+
const coverage = environment.coverage;
|
|
1736
1939
|
const createLazy = (domain: Value, context: Context) => {
|
|
1737
1940
|
const scope = trimScope(context.scope, bodyNames);
|
|
1738
1941
|
const lambdaContext = withScope(context, scope);
|
|
1942
|
+
const compute = (argument: Value) =>
|
|
1943
|
+
body(withScope(lambdaContext, bindArgument(bounds, scope, argument)));
|
|
1944
|
+
const node = coverage && !environment.callStack ? coverage.current : -1;
|
|
1739
1945
|
const functionValue = keepLambda({
|
|
1740
1946
|
value: createLazyFunction(
|
|
1741
1947
|
domain,
|
|
1742
|
-
|
|
1948
|
+
coverage
|
|
1949
|
+
? (argument) =>
|
|
1950
|
+
coverage.current === -1
|
|
1951
|
+
? compute(argument)
|
|
1952
|
+
: runAtCoverageNode(coverage, node, () => compute(argument))
|
|
1953
|
+
: compute,
|
|
1743
1954
|
getLazyFunctionSource(template, bounds, domain),
|
|
1744
1955
|
boundTupleLengths,
|
|
1745
1956
|
),
|
|
@@ -1791,6 +2002,23 @@ const compileFunctionConstruction = (
|
|
|
1791
2002
|
): Evaluator => {
|
|
1792
2003
|
const build = getFunctionBuilder(expression, environment).build;
|
|
1793
2004
|
const bounds = expression.bounds;
|
|
2005
|
+
const coverage = environment.coverage;
|
|
2006
|
+
if (coverage) {
|
|
2007
|
+
return (context) => {
|
|
2008
|
+
const domain = getBoundsDomain(bounds, context);
|
|
2009
|
+
const value = build(domain, context);
|
|
2010
|
+
const sets =
|
|
2011
|
+
bounds.length === 1 || typeof domain !== "object" || domain.kind !== "ProductSet"
|
|
2012
|
+
? [domain]
|
|
2013
|
+
: domain.factors;
|
|
2014
|
+
const isConverted =
|
|
2015
|
+
(typeof value !== "object" || value.kind !== "LazyFunction") && sets.every(isReducibleSet);
|
|
2016
|
+
if (isConverted && coverage.current !== -1 && coverage.covered.has(expression)) {
|
|
2017
|
+
chargeFunctionConstruction(coverage, coverage.current, sets);
|
|
2018
|
+
}
|
|
2019
|
+
return value;
|
|
2020
|
+
};
|
|
2021
|
+
}
|
|
1794
2022
|
if (bounds.length === 1 && bounds[0].pattern.kind === "Name") {
|
|
1795
2023
|
const set = getEvaluator(bounds[0].set, environment);
|
|
1796
2024
|
return (context) => build(set(context), context);
|
|
@@ -1864,29 +2092,19 @@ export const getLazyFilter = (
|
|
|
1864
2092
|
) => {
|
|
1865
2093
|
const predicate = getEvaluator(expression.predicate, environment);
|
|
1866
2094
|
const pattern = expression.bound.pattern;
|
|
1867
|
-
const
|
|
1868
|
-
const source = range && {
|
|
2095
|
+
const predicateNode = describeNode(expression.predicate);
|
|
2096
|
+
const source = expression.predicate.location.range && {
|
|
1869
2097
|
names: pattern.kind === "Name" ? pattern.name : pattern.names.join(", "),
|
|
1870
|
-
predicate:
|
|
2098
|
+
predicate: predicateNode,
|
|
1871
2099
|
};
|
|
1872
|
-
const predicateNode = describeNode(expression.predicate);
|
|
1873
2100
|
const coverage = environment.coverage;
|
|
1874
|
-
const testCovered = (node: number, isMember: boolean, test: () => Value) => {
|
|
1875
|
-
if (!coverage || node === -1) return test();
|
|
1876
|
-
if (!isMember) coverage.secondary[node]++;
|
|
1877
|
-
const value = runAtCoverageNode(coverage, isMember ? -1 : node, test);
|
|
1878
|
-
if (!isMember && value === true) coverage.secondary[node]++;
|
|
1879
|
-
return value;
|
|
1880
|
-
};
|
|
1881
2101
|
const createFiltered = (
|
|
1882
2102
|
base: Value,
|
|
1883
2103
|
context: Context,
|
|
1884
2104
|
evaluator: Evaluator,
|
|
1885
2105
|
node: number,
|
|
1886
|
-
): RebindableFilteredSet =>
|
|
1887
|
-
|
|
1888
|
-
base,
|
|
1889
|
-
test: (element, isMember) => {
|
|
2106
|
+
): RebindableFilteredSet => {
|
|
2107
|
+
const test = (element: Value, isMember: boolean) => {
|
|
1890
2108
|
if (
|
|
1891
2109
|
pattern.kind === "Tuple" &&
|
|
1892
2110
|
getSequenceElements(element)?.length !== pattern.names.length
|
|
@@ -1895,29 +2113,60 @@ export const getLazyFilter = (
|
|
|
1895
2113
|
`Attempted to check if the value:\n${prettyPrint(formatValue(element))}\nis an element of a set of ${pattern.names.length}-tuples.`,
|
|
1896
2114
|
);
|
|
1897
2115
|
}
|
|
1898
|
-
const value =
|
|
1899
|
-
evaluator(withScope(context, bindPattern(context.scope, pattern, element))),
|
|
1900
|
-
);
|
|
2116
|
+
const value = evaluator(withScope(context, bindPattern(context.scope, pattern, element)));
|
|
1901
2117
|
if (typeof value !== "boolean") {
|
|
1902
2118
|
throw new TlaEvaluationError(
|
|
1903
2119
|
`${isMember ? "The evaluation of predicate" : "Evaluating predicate"} ${predicateNode} yielded non-Boolean value.`,
|
|
1904
2120
|
);
|
|
1905
2121
|
}
|
|
1906
2122
|
return value;
|
|
1907
|
-
}
|
|
1908
|
-
|
|
1909
|
-
rebind: (tracing) =>
|
|
2123
|
+
};
|
|
2124
|
+
const rebind = (tracing: Environment) =>
|
|
1910
2125
|
createFiltered(
|
|
1911
2126
|
base,
|
|
1912
2127
|
{ ...context, environment: tracing },
|
|
1913
2128
|
getEvaluator(expression.predicate, tracing),
|
|
1914
2129
|
-1,
|
|
1915
|
-
)
|
|
1916
|
-
|
|
2130
|
+
);
|
|
2131
|
+
if (!coverage || node === -1) return { kind: "FilteredSet", base, test, source, rebind };
|
|
2132
|
+
return {
|
|
2133
|
+
kind: "FilteredSet",
|
|
2134
|
+
base,
|
|
2135
|
+
test: (element, isMember) =>
|
|
2136
|
+
runAtCoverageNode(coverage, isMember ? -1 : node, () => test(element, isMember)),
|
|
2137
|
+
startPass: (isMaterialized) => {
|
|
2138
|
+
const draws = createProductSetEnumerator(coverage, base);
|
|
2139
|
+
return (element) => {
|
|
2140
|
+
draws?.next();
|
|
2141
|
+
tagSubset(coverage, base, element);
|
|
2142
|
+
coverage.secondary[node]++;
|
|
2143
|
+
const value = runAtCoverageNode(coverage, node, () => test(element, false));
|
|
2144
|
+
if (isMaterialized && value) coverage.secondary[node]++;
|
|
2145
|
+
return value;
|
|
2146
|
+
};
|
|
2147
|
+
},
|
|
2148
|
+
source,
|
|
2149
|
+
rebind,
|
|
2150
|
+
};
|
|
2151
|
+
};
|
|
1917
2152
|
return (base: Value, context: Context, node = -1) =>
|
|
1918
2153
|
createFiltered(base, context, predicate, node);
|
|
1919
2154
|
};
|
|
1920
2155
|
|
|
2156
|
+
const hasLocalName = (expression: Expression): boolean =>
|
|
2157
|
+
isLocallyResolved(expression) ||
|
|
2158
|
+
expression.kind === "OperatorReference" ||
|
|
2159
|
+
getChildren(expression).some(hasLocalName);
|
|
2160
|
+
|
|
2161
|
+
export const isUniformPredicate = (
|
|
2162
|
+
expression: Expression & { kind: "SetFilter" },
|
|
2163
|
+
environment: Environment,
|
|
2164
|
+
) =>
|
|
2165
|
+
expression.bound.pattern.kind === "Name" &&
|
|
2166
|
+
!environment.coverage &&
|
|
2167
|
+
!hasLocalName(expression.predicate) &&
|
|
2168
|
+
!isExpressionImpure([expression.predicate], environment, "varying");
|
|
2169
|
+
|
|
1921
2170
|
export const expectFilterPredicate = (
|
|
1922
2171
|
value: Value,
|
|
1923
2172
|
expression: Expression & { kind: "SetFilter" },
|
|
@@ -1960,32 +2209,34 @@ const compileSetComprehension = (
|
|
|
1960
2209
|
const filterLazily = getLazyFilter(expression, environment);
|
|
1961
2210
|
const pattern = expression.bound.pattern;
|
|
1962
2211
|
const coverage = environment.coverage;
|
|
2212
|
+
const isUniform = isUniformPredicate(expression, environment);
|
|
1963
2213
|
return (context) => {
|
|
1964
2214
|
const base = set(context);
|
|
1965
2215
|
if (!isReducibleSet(base)) return filterLazily(base, context, coverage?.current);
|
|
1966
2216
|
const kept: Value[] = [];
|
|
1967
|
-
const
|
|
2217
|
+
const elements = base.kind === "Interval" ? base : toFiniteSet(base).elements;
|
|
2218
|
+
const size = Array.isArray(elements) ? elements.length : elements.high - elements.low + 1;
|
|
2219
|
+
for (let position = 0; position < size; position++) {
|
|
2220
|
+
const element = Array.isArray(elements) ? elements[position] : elements.low + position;
|
|
1968
2221
|
const value = predicate(withScope(context, bindPattern(context.scope, pattern, element)));
|
|
1969
2222
|
if (expectFilterPredicate(value, expression)) addBoundedElement(kept, element);
|
|
1970
|
-
|
|
1971
|
-
const elements = base.kind === "Interval" ? base : toFiniteSet(base).elements;
|
|
1972
|
-
forEachElement(elements, visit);
|
|
1973
|
-
if (coverage && coverage.current !== -1) {
|
|
1974
|
-
coverage.secondary[coverage.current] +=
|
|
1975
|
-
(Array.isArray(elements) ? elements.length : elements.high - elements.low + 1) +
|
|
1976
|
-
kept.length;
|
|
2223
|
+
else if (isUniform) break;
|
|
1977
2224
|
}
|
|
2225
|
+
if (coverage) costCoverage(coverage, base, size + 1);
|
|
1978
2226
|
return createNormalizedSet(kept);
|
|
1979
2227
|
};
|
|
1980
2228
|
}
|
|
1981
2229
|
if (expression.kind === "SetMap") {
|
|
1982
2230
|
const mapped = getEvaluator(expression.expression, environment);
|
|
2231
|
+
const coverage = environment.coverage;
|
|
1983
2232
|
return (context) => {
|
|
1984
2233
|
const elements: Value[] = [];
|
|
1985
|
-
|
|
2234
|
+
const add = (scope: Scope | undefined) => {
|
|
1986
2235
|
addBoundedElement(elements, mapped(withScope(context, scope)));
|
|
1987
2236
|
return false;
|
|
1988
|
-
}
|
|
2237
|
+
};
|
|
2238
|
+
if (coverage) forEachChargedBinding(expression.bounds, context, coverage, add);
|
|
2239
|
+
else forEachBinding(expression.bounds, context, add);
|
|
1989
2240
|
return createEnumeratedSet(elements);
|
|
1990
2241
|
};
|
|
1991
2242
|
}
|
|
@@ -1999,16 +2250,15 @@ const compileSetComprehension = (
|
|
|
1999
2250
|
}
|
|
2000
2251
|
const body = getEvaluator(expression.body, environment);
|
|
2001
2252
|
const evaluateSet = getEvaluator(set, environment);
|
|
2253
|
+
const coverage = environment.coverage;
|
|
2002
2254
|
return (context) => {
|
|
2003
|
-
const
|
|
2004
|
-
|
|
2005
|
-
|
|
2006
|
-
set,
|
|
2007
|
-
context.environment.runtime.version,
|
|
2008
|
-
);
|
|
2255
|
+
const base = evaluateSet(context);
|
|
2256
|
+
const elements = getChoiceElements(base, expression, set, context.environment.runtime.version);
|
|
2257
|
+
const enumerator = coverage && createChargedEnumerator(coverage, base, elements, true);
|
|
2009
2258
|
let chosen: Value | undefined;
|
|
2010
2259
|
const pattern = expression.pattern;
|
|
2011
2260
|
someElement(elements, (element) => {
|
|
2261
|
+
enumerator?.next();
|
|
2012
2262
|
if (
|
|
2013
2263
|
pattern.kind === "Tuple" &&
|
|
2014
2264
|
getSequenceElements(element)?.length !== pattern.names.length
|
|
@@ -2022,8 +2272,9 @@ const compileSetComprehension = (
|
|
|
2022
2272
|
chosen = getBoundValue(pattern, scope);
|
|
2023
2273
|
return true;
|
|
2024
2274
|
});
|
|
2025
|
-
if (chosen
|
|
2026
|
-
|
|
2275
|
+
if (chosen !== undefined) return chosen;
|
|
2276
|
+
enumerator?.next();
|
|
2277
|
+
throw createNoChoiceError(expression);
|
|
2027
2278
|
};
|
|
2028
2279
|
};
|
|
2029
2280
|
|
|
@@ -2035,20 +2286,21 @@ export const hasDuplicateFields = (sortedFields: RecordField[]) =>
|
|
|
2035
2286
|
|
|
2036
2287
|
const compileRecord = (recordFields: RecordField[], environment: Environment): Evaluator => {
|
|
2037
2288
|
const fields = getSortedFields(recordFields);
|
|
2038
|
-
const
|
|
2039
|
-
|
|
2040
|
-
if (hasDuplicates) {
|
|
2289
|
+
const values = recordFields.map((field) => getEvaluator(field.value, environment));
|
|
2290
|
+
if (hasDuplicateFields(fields)) {
|
|
2041
2291
|
return (context) =>
|
|
2042
2292
|
createRecord(
|
|
2043
|
-
|
|
2293
|
+
recordFields.map((field, index): [string, Value] => [field.name, values[index](context)]),
|
|
2044
2294
|
);
|
|
2045
2295
|
}
|
|
2046
2296
|
const names = fields.map((field) => field.name);
|
|
2047
2297
|
const writtenNames = recordFields.map((field) => field.name);
|
|
2048
2298
|
if (writtenNames.some((name, index) => name !== names[index])) {
|
|
2299
|
+
const writtenIndexes = fields.map((field) => recordFields.indexOf(field));
|
|
2049
2300
|
return (context) =>
|
|
2050
2301
|
createWrittenRecord(
|
|
2051
2302
|
names,
|
|
2303
|
+
writtenIndexes,
|
|
2052
2304
|
values.map((value) => value(context)),
|
|
2053
2305
|
writtenNames,
|
|
2054
2306
|
);
|
|
@@ -2098,25 +2350,31 @@ const compile = (expression: Expression, environment: Environment): Evaluator =>
|
|
|
2098
2350
|
};
|
|
2099
2351
|
case "And": {
|
|
2100
2352
|
const operands = expression.operands.map(getChildEvaluator);
|
|
2101
|
-
return (
|
|
2102
|
-
|
|
2103
|
-
|
|
2104
|
-
|
|
2105
|
-
|
|
2106
|
-
|
|
2107
|
-
|
|
2108
|
-
|
|
2353
|
+
return (
|
|
2354
|
+
compileTracedJunction(expression, operands, environment.callStack) ??
|
|
2355
|
+
((context) => {
|
|
2356
|
+
for (let index = 0; index < operands.length; index++) {
|
|
2357
|
+
const value = operands[index](context);
|
|
2358
|
+
if (typeof value !== "boolean") throw createJunctionError(expression, index, value);
|
|
2359
|
+
if (!value) return false;
|
|
2360
|
+
}
|
|
2361
|
+
return true;
|
|
2362
|
+
})
|
|
2363
|
+
);
|
|
2109
2364
|
}
|
|
2110
2365
|
case "Or": {
|
|
2111
2366
|
const operands = expression.operands.map(getChildEvaluator);
|
|
2112
|
-
return (
|
|
2113
|
-
|
|
2114
|
-
|
|
2115
|
-
|
|
2116
|
-
|
|
2117
|
-
|
|
2118
|
-
|
|
2119
|
-
|
|
2367
|
+
return (
|
|
2368
|
+
compileTracedJunction(expression, operands, environment.callStack) ??
|
|
2369
|
+
((context) => {
|
|
2370
|
+
for (let index = 0; index < operands.length; index++) {
|
|
2371
|
+
const value = operands[index](context);
|
|
2372
|
+
if (typeof value !== "boolean") throw createJunctionError(expression, index, value);
|
|
2373
|
+
if (value) return true;
|
|
2374
|
+
}
|
|
2375
|
+
return false;
|
|
2376
|
+
})
|
|
2377
|
+
);
|
|
2120
2378
|
}
|
|
2121
2379
|
case "Prime": {
|
|
2122
2380
|
const inner = getChildEvaluator(expression.expression);
|
|
@@ -2202,8 +2460,19 @@ const compile = (expression: Expression, environment: Environment): Evaluator =>
|
|
|
2202
2460
|
case "RecordSet": {
|
|
2203
2461
|
const fields = getSortedFields(expression.fields);
|
|
2204
2462
|
const names = fields.map((field) => field.name);
|
|
2205
|
-
const
|
|
2206
|
-
|
|
2463
|
+
const writtenIndexes = fields.map((field) => expression.fields.indexOf(field));
|
|
2464
|
+
const sets = expression.fields.map((field) => getChildEvaluator(field.value));
|
|
2465
|
+
if (writtenIndexes.every((writtenIndex, index) => writtenIndex === index)) {
|
|
2466
|
+
return (context) => ({ kind: "RecordSet", names, sets: sets.map((set) => set(context)) });
|
|
2467
|
+
}
|
|
2468
|
+
return (context) => {
|
|
2469
|
+
const writtenSets = sets.map((set) => set(context));
|
|
2470
|
+
return {
|
|
2471
|
+
kind: "RecordSet",
|
|
2472
|
+
names,
|
|
2473
|
+
sets: writtenIndexes.map((index) => writtenSets[index]),
|
|
2474
|
+
};
|
|
2475
|
+
};
|
|
2207
2476
|
}
|
|
2208
2477
|
case "Except":
|
|
2209
2478
|
return compileExcept(expression, environment);
|
|
@@ -2270,6 +2539,8 @@ const compile = (expression: Expression, environment: Environment): Evaluator =>
|
|
|
2270
2539
|
}
|
|
2271
2540
|
case "Label":
|
|
2272
2541
|
return getChildEvaluator(expression.body);
|
|
2542
|
+
case "Selection":
|
|
2543
|
+
return getChildEvaluator(expression.expression);
|
|
2273
2544
|
case "Subexpression":
|
|
2274
2545
|
return () => {
|
|
2275
2546
|
throw new TlaEvaluationError(
|