tla-ts 0.0.10-dev.3a85c3a9e → 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 +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 +79 -79
- 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 +97 -92
- package/dist/transfer.js +97 -92
- 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 +50 -29
- package/src/builtins.ts +4 -3
- package/src/check-failure.ts +13 -11
- package/src/check-trace.ts +146 -107
- package/src/check.ts +535 -281
- package/src/cli/runtime-invariants.ts +20 -56
- package/src/cli/tlc-arguments.ts +2 -2
- package/src/cli/tlc-output.ts +21 -7
- package/src/cli/tlc.ts +31 -11
- 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 +101 -36
- package/src/environment.ts +131 -41
- package/src/errors.ts +7 -0
- package/src/evaluate.ts +424 -135
- package/src/exit-codes.ts +28 -13
- 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 +204 -62
- 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/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 -10
- 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/containers.ts +7 -1
- package/src/prover/smt/solver/lp/core-solver.ts +12 -8
- package/src/prover/smt/solver/lp/cross-nested.ts +1 -3
- 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/nex-creator.ts +3 -2
- package/src/prover/smt/solver/lp/nex.ts +2 -1
- package/src/prover/smt/solver/lp/nla-basics.ts +46 -1
- package/src/prover/smt/solver/lp/nla-core.ts +26 -6
- package/src/prover/smt/solver/lp/nla-grobner.ts +158 -81
- package/src/prover/smt/solver/lp/nra-solver.ts +138 -95
- 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 -71
- 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 +20 -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 +4 -7
- 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 +10 -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/equality-rules.ts +24 -0
- package/src/prover/zenon/expr.ts +21 -0
- package/src/prover/zenon/index-table.ts +7 -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/prover/zenon/rules.ts +2 -1
- package/src/resolve.ts +1274 -258
- package/src/runtime.ts +25 -2
- 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 +348 -153
- package/src/simulate.ts +250 -185
- package/src/spec-description.ts +15 -7
- package/src/standard-definitions.ts +5 -0
- package/src/standard-modules.ts +56 -22
- package/src/subexpressions.ts +564 -138
- package/src/successors.ts +50 -20
- 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 +147 -46
- package/src/tlc/tlc-operators.ts +10 -8
- package/src/tlc/tlcext-operators.ts +87 -26
- package/src/tlc/trace-spec.ts +11 -25
- 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/coverage.ts
CHANGED
|
@@ -1,4 +1,5 @@
|
|
|
1
1
|
import {
|
|
2
|
+
getFunctionConstruction,
|
|
2
3
|
isLocallyResolved,
|
|
3
4
|
type Bound,
|
|
4
5
|
type Definition,
|
|
@@ -7,10 +8,17 @@ import {
|
|
|
7
8
|
type SourceRange,
|
|
8
9
|
} from "./ast";
|
|
9
10
|
import { formatRange } from "./errors";
|
|
11
|
+
import { SELECTION_NAME } from "./resolve";
|
|
10
12
|
import type { Environment, Scope } from "./evaluate";
|
|
11
13
|
import { getJavaHashCode } from "./java-hash";
|
|
12
14
|
import { getTlcFingerprint } from "./tlc/fingerprint";
|
|
13
|
-
import
|
|
15
|
+
import {
|
|
16
|
+
getCardinality,
|
|
17
|
+
isEmptySet,
|
|
18
|
+
isReducibleSet,
|
|
19
|
+
type IntervalValue,
|
|
20
|
+
type Value,
|
|
21
|
+
} from "./values";
|
|
14
22
|
|
|
15
23
|
export type CoverageKind = "init" | "next" | "invariant" | "constraint" | "implied";
|
|
16
24
|
|
|
@@ -49,6 +57,11 @@ export interface CoverageReport {
|
|
|
49
57
|
relations: CoverageRelationReport[];
|
|
50
58
|
}
|
|
51
59
|
|
|
60
|
+
export interface CoverageOutput {
|
|
61
|
+
kind: "coverage";
|
|
62
|
+
coverage: CoverageReport;
|
|
63
|
+
}
|
|
64
|
+
|
|
52
65
|
interface CoverageVariable {
|
|
53
66
|
label: string;
|
|
54
67
|
distinct: number;
|
|
@@ -81,6 +94,8 @@ interface Resolved {
|
|
|
81
94
|
scope: Local | undefined;
|
|
82
95
|
}
|
|
83
96
|
|
|
97
|
+
export const letDefinitions = new WeakMap<Scope, Definition>();
|
|
98
|
+
|
|
84
99
|
const STANDARD_MODULES = new Set([
|
|
85
100
|
"FiniteSets",
|
|
86
101
|
"Sequences",
|
|
@@ -118,6 +133,17 @@ export const createCoverage = (variableCount: number): Coverage => ({
|
|
|
118
133
|
relations: [],
|
|
119
134
|
});
|
|
120
135
|
|
|
136
|
+
export const createCoverageEnvironment = (
|
|
137
|
+
environment: Environment,
|
|
138
|
+
coverage: Coverage,
|
|
139
|
+
): Environment => ({
|
|
140
|
+
...environment,
|
|
141
|
+
evaluators: new WeakMap(),
|
|
142
|
+
entryEvaluators: new WeakMap(),
|
|
143
|
+
definitionEvaluators: new WeakMap(),
|
|
144
|
+
coverage,
|
|
145
|
+
});
|
|
146
|
+
|
|
121
147
|
const addNode = (
|
|
122
148
|
coverage: Coverage,
|
|
123
149
|
expression: Expression | undefined,
|
|
@@ -154,6 +180,10 @@ const findCoverageRelation = (coverage: Coverage, kind: CoverageKind, expression
|
|
|
154
180
|
(relation) => relation.kind === kind && relation.expression === expression,
|
|
155
181
|
)?.node;
|
|
156
182
|
|
|
183
|
+
const getRelationRange = (expression: Expression) =>
|
|
184
|
+
expression.location.range ??
|
|
185
|
+
(expression.kind === "Let" ? expression.body.location.range : undefined);
|
|
186
|
+
|
|
157
187
|
export const addCoverageRelation = (
|
|
158
188
|
coverage: Coverage,
|
|
159
189
|
kind: CoverageKind,
|
|
@@ -163,7 +193,7 @@ export const addCoverageRelation = (
|
|
|
163
193
|
) => {
|
|
164
194
|
const shared = kind === "next" ? findCoverageRelation(coverage, kind, expression) : undefined;
|
|
165
195
|
if (shared !== undefined) return shared;
|
|
166
|
-
const node = addNode(coverage, undefined, expression
|
|
196
|
+
const node = addNode(coverage, undefined, getRelationRange(expression), -1, false);
|
|
167
197
|
coverage.relations.push({ kind, label, expression, scope, node });
|
|
168
198
|
return node;
|
|
169
199
|
};
|
|
@@ -184,9 +214,9 @@ export const getCoverageLabel = (
|
|
|
184
214
|
) => {
|
|
185
215
|
const definition = name === undefined ? undefined : environment.definitions.get(name);
|
|
186
216
|
const head = definition?.kind === "Operator" ? definition.head : undefined;
|
|
187
|
-
const range = expression
|
|
217
|
+
const range = getRelationRange(expression);
|
|
188
218
|
if (!definition || !head) return `Action ${range ? formatRange(range) : "Unknown location"}`;
|
|
189
|
-
if (isSameRange(definition.body
|
|
219
|
+
if (isSameRange(getRelationRange(definition.body), range) || !range) {
|
|
190
220
|
return `${definition.name} ${formatRange(head)}`;
|
|
191
221
|
}
|
|
192
222
|
return `${definition.name} ${formatRange(head)} (${range.start.line} ${range.start.column} ${range.end.line} ${range.end.column})`;
|
|
@@ -233,6 +263,15 @@ const bindNames = (names: string[], locals: Local | undefined) =>
|
|
|
233
263
|
locals,
|
|
234
264
|
);
|
|
235
265
|
|
|
266
|
+
const bindLocalDefinitions = (definitions: Definition[], locals: Local | undefined) => {
|
|
267
|
+
const inner = definitions.reduce<Local | undefined>(
|
|
268
|
+
(parent, definition) => ({ name: definition.name, definition, scope: undefined, parent }),
|
|
269
|
+
locals,
|
|
270
|
+
);
|
|
271
|
+
for (let local = inner; local !== locals && local; local = local.parent) local.scope = inner;
|
|
272
|
+
return inner;
|
|
273
|
+
};
|
|
274
|
+
|
|
236
275
|
const getBoundNames = (bounds: Bound[]) =>
|
|
237
276
|
bounds.flatMap((bound) =>
|
|
238
277
|
bound.pattern.kind === "Name" ? [bound.pattern.name] : bound.pattern.names,
|
|
@@ -302,10 +341,13 @@ export const buildCoverage = (
|
|
|
302
341
|
definition.kind === "Function"
|
|
303
342
|
? getBoundNames(definition.bounds)
|
|
304
343
|
: definition.params.map((param) => param.name);
|
|
305
|
-
walk(definition.body, bindNames(names, resolved.scope));
|
|
306
344
|
if (definition.kind === "Function") {
|
|
307
|
-
|
|
308
|
-
|
|
345
|
+
const isLet = resolved.scope !== undefined;
|
|
346
|
+
enter(getFunctionConstruction(definition, isLet), definition.location.range, () => {
|
|
347
|
+
walk(definition.body, bindNames(names, resolved.scope));
|
|
348
|
+
getBoundSets(definition.bounds).forEach((set) => walk(set, resolved.scope));
|
|
349
|
+
});
|
|
350
|
+
} else walk(definition.body, bindNames(names, resolved.scope));
|
|
309
351
|
walking.pop();
|
|
310
352
|
};
|
|
311
353
|
|
|
@@ -380,20 +422,18 @@ export const buildCoverage = (
|
|
|
380
422
|
case "Lambda":
|
|
381
423
|
walk(expression.body, bindNames(expression.params, locals));
|
|
382
424
|
return;
|
|
425
|
+
case "Selection":
|
|
426
|
+
if (range === undefined) walk(expression.expression, locals);
|
|
427
|
+
else enter(expression, range, () => walk(expression.expression, locals));
|
|
428
|
+
return;
|
|
383
429
|
case "Let": {
|
|
384
|
-
const inner = expression.definitions
|
|
385
|
-
(parent, definition) => ({ name: definition.name, definition, scope: undefined, parent }),
|
|
386
|
-
locals,
|
|
387
|
-
);
|
|
388
|
-
for (let local = inner; local !== locals && local; local = local.parent) {
|
|
389
|
-
local.scope = inner;
|
|
390
|
-
}
|
|
430
|
+
const inner = bindLocalDefinitions(expression.definitions, locals);
|
|
391
431
|
expression.definitions.forEach((definition) => {
|
|
392
432
|
if (definition.kind === "Operator") letBodies.set(definition.body, expression.body);
|
|
393
433
|
});
|
|
394
|
-
getHashtableOrder(expression.definitions).forEach((definition) =>
|
|
395
|
-
walkDefinition({ definition, scope: inner })
|
|
396
|
-
);
|
|
434
|
+
getHashtableOrder(expression.definitions).forEach((definition) => {
|
|
435
|
+
if (definition.name !== SELECTION_NAME) walkDefinition({ definition, scope: inner });
|
|
436
|
+
});
|
|
397
437
|
walk(expression.body, inner);
|
|
398
438
|
return;
|
|
399
439
|
}
|
|
@@ -551,9 +591,18 @@ export const buildCoverage = (
|
|
|
551
591
|
}
|
|
552
592
|
};
|
|
553
593
|
|
|
594
|
+
const getScopeLocals = (scope: Scope | undefined) => {
|
|
595
|
+
const scoped: Definition[] = [];
|
|
596
|
+
for (let node = scope; node; node = node.parent) {
|
|
597
|
+
const definition = letDefinitions.get(node);
|
|
598
|
+
if (definition) scoped.unshift(definition);
|
|
599
|
+
}
|
|
600
|
+
return bindLocalDefinitions(scoped, undefined);
|
|
601
|
+
};
|
|
602
|
+
|
|
554
603
|
coverage.relations.forEach((relation) => {
|
|
555
604
|
stack.push(relation.node);
|
|
556
|
-
walk(relation.expression,
|
|
605
|
+
walk(relation.expression, getScopeLocals(relation.scope));
|
|
557
606
|
stack.pop();
|
|
558
607
|
});
|
|
559
608
|
};
|
|
@@ -602,6 +651,194 @@ export const costCoverage = (coverage: Coverage, value: Value, cost: number) =>
|
|
|
602
651
|
if (node !== undefined) coverage.secondary[node] += cost;
|
|
603
652
|
};
|
|
604
653
|
|
|
654
|
+
export const chargeSetOperation = (
|
|
655
|
+
coverage: Coverage,
|
|
656
|
+
operator: string,
|
|
657
|
+
left: Value,
|
|
658
|
+
right: Value,
|
|
659
|
+
result: Value,
|
|
660
|
+
): Value => {
|
|
661
|
+
const receiver = isReducibleSet(left)
|
|
662
|
+
? left
|
|
663
|
+
: operator !== "\\" && isReducibleSet(right)
|
|
664
|
+
? right
|
|
665
|
+
: undefined;
|
|
666
|
+
if (receiver === undefined || typeof result !== "object") return result;
|
|
667
|
+
const other = receiver === left ? right : left;
|
|
668
|
+
if (operator === "\\cup") {
|
|
669
|
+
if (isEmptySet(receiver) || !isReducibleSet(other)) return result;
|
|
670
|
+
const otherNode = coverage.values.get(other);
|
|
671
|
+
if (otherNode !== undefined) coverage.secondary[otherNode] += getCardinality(other) + 1;
|
|
672
|
+
}
|
|
673
|
+
const node = operator === "\\cup" ? undefined : coverage.values.get(receiver);
|
|
674
|
+
if (coverage.values.get(result) === node) return result;
|
|
675
|
+
const isShared = result === left || result === right || coverage.values.has(result);
|
|
676
|
+
const charged = isShared ? { ...result } : result;
|
|
677
|
+
if (node !== undefined) coverage.values.set(charged, node);
|
|
678
|
+
return charged;
|
|
679
|
+
};
|
|
680
|
+
|
|
681
|
+
interface ChargedEnumerator {
|
|
682
|
+
next: () => boolean;
|
|
683
|
+
reset: () => void;
|
|
684
|
+
}
|
|
685
|
+
|
|
686
|
+
const createListEnumerator = (coverage: Coverage, node: number | undefined, size: number) => {
|
|
687
|
+
let position = 0;
|
|
688
|
+
return {
|
|
689
|
+
next: () => {
|
|
690
|
+
if (node !== undefined) coverage.secondary[node]++;
|
|
691
|
+
return position++ < size;
|
|
692
|
+
},
|
|
693
|
+
reset: () => {
|
|
694
|
+
position = 0;
|
|
695
|
+
},
|
|
696
|
+
};
|
|
697
|
+
};
|
|
698
|
+
|
|
699
|
+
const createProductEnumerator = (
|
|
700
|
+
coverage: Coverage,
|
|
701
|
+
node: number,
|
|
702
|
+
sets: Value[],
|
|
703
|
+
): ChargedEnumerator => {
|
|
704
|
+
if (sets.some((set) => isEmptySet(set))) return { next: () => false, reset: () => undefined };
|
|
705
|
+
const enumerators = sets.map((set) =>
|
|
706
|
+
createEnumerator(coverage, set, getCardinality(set), false),
|
|
707
|
+
);
|
|
708
|
+
const advance = () => {
|
|
709
|
+
for (let index = enumerators.length - 1; index > 0; index--) {
|
|
710
|
+
if (enumerators[index].next()) return true;
|
|
711
|
+
enumerators[index].reset();
|
|
712
|
+
enumerators[index].next();
|
|
713
|
+
}
|
|
714
|
+
return enumerators.length > 0 && enumerators[0].next();
|
|
715
|
+
};
|
|
716
|
+
let isDone = !enumerators.every((enumerator) => enumerator.next());
|
|
717
|
+
return {
|
|
718
|
+
next: () => {
|
|
719
|
+
if (isDone) return false;
|
|
720
|
+
coverage.secondary[node] += Math.max(enumerators.length, 1);
|
|
721
|
+
isDone = !advance();
|
|
722
|
+
return true;
|
|
723
|
+
},
|
|
724
|
+
reset: () => {
|
|
725
|
+
enumerators.forEach((enumerator) => {
|
|
726
|
+
enumerator.reset();
|
|
727
|
+
enumerator.next();
|
|
728
|
+
});
|
|
729
|
+
isDone = false;
|
|
730
|
+
},
|
|
731
|
+
};
|
|
732
|
+
};
|
|
733
|
+
|
|
734
|
+
export const createProductSetEnumerator = (coverage: Coverage, set: Value) => {
|
|
735
|
+
const node = typeof set === "object" ? coverage.values.get(set) : undefined;
|
|
736
|
+
if (node === undefined || typeof set !== "object") return undefined;
|
|
737
|
+
if (set.kind === "RecordSet") return createProductEnumerator(coverage, node, set.sets);
|
|
738
|
+
if (set.kind !== "FunctionSet") return undefined;
|
|
739
|
+
return createProductEnumerator(
|
|
740
|
+
coverage,
|
|
741
|
+
node,
|
|
742
|
+
Array.from({ length: getCardinality(set.domain) }, () => set.range),
|
|
743
|
+
);
|
|
744
|
+
};
|
|
745
|
+
|
|
746
|
+
const createEnumerator = (
|
|
747
|
+
coverage: Coverage,
|
|
748
|
+
set: Value,
|
|
749
|
+
size: number,
|
|
750
|
+
isNormalized: boolean,
|
|
751
|
+
): ChargedEnumerator => {
|
|
752
|
+
const node = typeof set === "object" ? coverage.values.get(set) : undefined;
|
|
753
|
+
if (
|
|
754
|
+
typeof set === "object" &&
|
|
755
|
+
(set.kind === "Subset" || (!isNormalized && set.kind === "FilteredSet"))
|
|
756
|
+
) {
|
|
757
|
+
return createListEnumerator(coverage, undefined, size);
|
|
758
|
+
}
|
|
759
|
+
const elements = createProductSetEnumerator(coverage, set);
|
|
760
|
+
if (!elements || node === undefined) return createListEnumerator(coverage, node, size);
|
|
761
|
+
if (!isNormalized) return elements;
|
|
762
|
+
let count = 0;
|
|
763
|
+
while (elements.next()) count++;
|
|
764
|
+
coverage.secondary[node] += count;
|
|
765
|
+
return createListEnumerator(coverage, node, count);
|
|
766
|
+
};
|
|
767
|
+
|
|
768
|
+
export const tagSubset = (coverage: Coverage, set: Value, subset: Value) => {
|
|
769
|
+
const node =
|
|
770
|
+
typeof set === "object" && set.kind === "Subset" ? coverage.values.get(set) : undefined;
|
|
771
|
+
if (node !== undefined && typeof subset === "object") coverage.values.set(subset, node);
|
|
772
|
+
};
|
|
773
|
+
|
|
774
|
+
const RANDOMLY_INDEXED_KINDS = new Set<string>([
|
|
775
|
+
"Set",
|
|
776
|
+
"MixedSet",
|
|
777
|
+
"Interval",
|
|
778
|
+
"FunctionSet",
|
|
779
|
+
"RecordSet",
|
|
780
|
+
"ProductSet",
|
|
781
|
+
]);
|
|
782
|
+
|
|
783
|
+
// TLC's EnumerableValue#elements(Ordering.RANDOMIZED) draws indices, but a value class without its own k-out-of-n enumerator draws the whole set first, and SubsetValue converts itself to a SetEnumValue.
|
|
784
|
+
export const chargeRandomOrder = (coverage: Coverage, set: Value, size: number, order: Value[]) => {
|
|
785
|
+
if (typeof set !== "object" || RANDOMLY_INDEXED_KINDS.has(set.kind)) return;
|
|
786
|
+
if (set.kind !== "Subset") {
|
|
787
|
+
const enumerator = createEnumerator(coverage, set, size, false);
|
|
788
|
+
for (let position = 0; position <= size; position++) enumerator.next();
|
|
789
|
+
return;
|
|
790
|
+
}
|
|
791
|
+
const node = coverage.values.get(set);
|
|
792
|
+
if (node !== undefined) coverage.secondary[node] += size;
|
|
793
|
+
for (let position = 0; position < order.length; position++) {
|
|
794
|
+
tagSubset(coverage, set, order[position]);
|
|
795
|
+
}
|
|
796
|
+
};
|
|
797
|
+
|
|
798
|
+
export const createChargedEnumerator = (
|
|
799
|
+
coverage: Coverage,
|
|
800
|
+
set: Value,
|
|
801
|
+
list: Value[] | IntervalValue,
|
|
802
|
+
isNormalized: boolean,
|
|
803
|
+
) => {
|
|
804
|
+
const size = Array.isArray(list) ? list.length : list.high - list.low + 1;
|
|
805
|
+
if (typeof set !== "object" || set.kind !== "Subset" || !Array.isArray(list)) {
|
|
806
|
+
return createEnumerator(coverage, set, size, isNormalized);
|
|
807
|
+
}
|
|
808
|
+
list.forEach((subset) => tagSubset(coverage, set, subset));
|
|
809
|
+
return createListEnumerator(coverage, undefined, size);
|
|
810
|
+
};
|
|
811
|
+
|
|
812
|
+
const chargeBindings = (enumerators: ChargedEnumerator[]) => {
|
|
813
|
+
enumerators.every((enumerator) => enumerator.next());
|
|
814
|
+
return () => {
|
|
815
|
+
for (let index = 0; index < enumerators.length; index++) {
|
|
816
|
+
if (enumerators[index].next() || index === enumerators.length - 1) return;
|
|
817
|
+
enumerators[index].reset();
|
|
818
|
+
enumerators[index].next();
|
|
819
|
+
}
|
|
820
|
+
};
|
|
821
|
+
};
|
|
822
|
+
|
|
823
|
+
export const chargeContexts = (
|
|
824
|
+
coverage: Coverage,
|
|
825
|
+
sets: Value[],
|
|
826
|
+
lists: (Value[] | IntervalValue)[],
|
|
827
|
+
) =>
|
|
828
|
+
chargeBindings(
|
|
829
|
+
sets.map((set, index) => createChargedEnumerator(coverage, set, lists[index], true)),
|
|
830
|
+
);
|
|
831
|
+
|
|
832
|
+
export const chargeFunctionConstruction = (coverage: Coverage, node: number, sets: Value[]) => {
|
|
833
|
+
const sizes = sets.map((set) => getCardinality(set));
|
|
834
|
+
const advance = chargeBindings(
|
|
835
|
+
sets.map((set, index) => createEnumerator(coverage, set, sizes[index], false)),
|
|
836
|
+
);
|
|
837
|
+
const size = sizes.reduce((product, setSize) => product * setSize, 1);
|
|
838
|
+
for (let index = 0; index < size; index++) advance();
|
|
839
|
+
coverage.secondary[node] += size;
|
|
840
|
+
};
|
|
841
|
+
|
|
605
842
|
const getLeadingZeros = (value: bigint) => {
|
|
606
843
|
const high = Number(value >> 32n);
|
|
607
844
|
return high === 0 ? 32 + Math.clz32(Number(value & 0xffffffffn)) : Math.clz32(high);
|
package/src/dependencies.ts
CHANGED
|
@@ -29,6 +29,8 @@ const VARIABLE_LEVEL_FLAGS = 32;
|
|
|
29
29
|
const ACTION_LEVEL_FLAGS = VARIABLE_LEVEL_FLAGS | 64;
|
|
30
30
|
const TEMPORAL_LEVEL_FLAGS = ACTION_LEVEL_FLAGS | 128;
|
|
31
31
|
const RANDOM = 256;
|
|
32
|
+
const ABOVE_CONSTANT_BOUND = 512;
|
|
33
|
+
const TLC_EVAL = 1024;
|
|
32
34
|
|
|
33
35
|
const ACTION_KINDS = new Set<Expression["kind"]>([
|
|
34
36
|
"Prime",
|
|
@@ -80,6 +82,7 @@ interface Edge {
|
|
|
80
82
|
callee: Definition;
|
|
81
83
|
isOverridden: boolean;
|
|
82
84
|
isLevelCounted: boolean;
|
|
85
|
+
isOperatorArgument: boolean;
|
|
83
86
|
}
|
|
84
87
|
|
|
85
88
|
const collectLocalFacts = (
|
|
@@ -104,20 +107,34 @@ const collectLocalFacts = (
|
|
|
104
107
|
}
|
|
105
108
|
return undefined;
|
|
106
109
|
};
|
|
107
|
-
const
|
|
110
|
+
const contexts = new Map<Expression, number>();
|
|
111
|
+
const visit = (node: Expression, isLevelCounted: boolean, isOperatorArgument: boolean) => {
|
|
108
112
|
const kind = node.kind;
|
|
113
|
+
if (kind === "Selection") {
|
|
114
|
+
const seen = contexts.get(node.expression) ?? 0;
|
|
115
|
+
const context = isLevelCounted ? (isOperatorArgument ? 1 : 2) : isOperatorArgument ? 4 : 8;
|
|
116
|
+
if ((seen & context) !== 0) return;
|
|
117
|
+
contexts.set(node.expression, seen | context);
|
|
118
|
+
}
|
|
119
|
+
// TLC's getLevelBound takes an operator argument for a constant.
|
|
120
|
+
const nonconstantFlags = isOperatorArgument ? NONCONSTANT : NONCONSTANT | ABOVE_CONSTANT_BOUND;
|
|
109
121
|
if (
|
|
110
122
|
NONCONSTANT_KINDS.has(kind) ||
|
|
111
123
|
(kind === "UnboundedQuantifier" && node.isTemporal === true) ||
|
|
112
124
|
(kind === "Apply" && NONCONSTANT_OPERATORS.has(node.operator))
|
|
113
125
|
) {
|
|
114
|
-
row[0] |=
|
|
126
|
+
row[0] |= nonconstantFlags;
|
|
115
127
|
}
|
|
116
128
|
if (NONCONSTANT_KINDS.has(kind)) row[0] |= READS_IMPURE;
|
|
117
129
|
const ownLevelFlags = getOwnLevelFlags(node);
|
|
118
130
|
if (isLevelCounted && ownLevelFlags !== undefined) row[0] |= ownLevelFlags;
|
|
119
131
|
const isInnerLevelCounted = isLevelCounted && ownLevelFlags === undefined;
|
|
120
132
|
const name = getReferencedName(node);
|
|
133
|
+
// TLC's getLevelBound takes a parameter named like a variable for that variable.
|
|
134
|
+
if (name !== undefined && isLocallyResolved(node) && environment.variableIndex.has(name)) {
|
|
135
|
+
if (!isOperatorArgument) row[0] |= ABOVE_CONSTANT_BOUND;
|
|
136
|
+
if (isInnerLevelCounted) row[0] |= VARIABLE_LEVEL_FLAGS;
|
|
137
|
+
}
|
|
121
138
|
if (name !== undefined && !isLocallyResolved(node)) {
|
|
122
139
|
const target = environment.substitutions.get(name) ?? name;
|
|
123
140
|
const definition = environment.definitions.get(target);
|
|
@@ -125,23 +142,34 @@ const collectLocalFacts = (
|
|
|
125
142
|
const variableIndex = environment.variableIndex.get(name);
|
|
126
143
|
if (
|
|
127
144
|
variableIndex !== undefined ||
|
|
128
|
-
environment.builtins.get(
|
|
145
|
+
environment.builtins.get(target)?.isStateLevel ||
|
|
129
146
|
(definition && environment.variableIndex.has(definition.name))
|
|
130
147
|
) {
|
|
131
|
-
row[0] |=
|
|
148
|
+
row[0] |= nonconstantFlags;
|
|
132
149
|
}
|
|
133
150
|
if (variableIndex !== undefined) {
|
|
134
151
|
if (isInnerLevelCounted) row[0] |= VARIABLE_LEVEL_FLAGS;
|
|
135
152
|
if (!isOverridden) row[1 + (variableIndex >>> 5)] |= 1 << (variableIndex & 31);
|
|
136
153
|
}
|
|
137
154
|
if (definition) {
|
|
138
|
-
edges.push({
|
|
155
|
+
edges.push({
|
|
156
|
+
callee: definition,
|
|
157
|
+
isOverridden,
|
|
158
|
+
isLevelCounted: isInnerLevelCounted,
|
|
159
|
+
isOperatorArgument:
|
|
160
|
+
isOperatorArgument ||
|
|
161
|
+
kind === "OperatorReference" ||
|
|
162
|
+
(kind === "Identifier" &&
|
|
163
|
+
definition.kind === "Operator" &&
|
|
164
|
+
definition.params.length > 0),
|
|
165
|
+
});
|
|
139
166
|
} else {
|
|
140
|
-
if (isImpureBuiltin(
|
|
141
|
-
row[0] |= IMPURE | (
|
|
167
|
+
if (isImpureBuiltin(target, environment)) {
|
|
168
|
+
row[0] |= IMPURE | (target === "Assert" ? 0 : REPEATED_EFFECT);
|
|
142
169
|
}
|
|
143
|
-
if (STREAMED_BUILTINS.has(
|
|
144
|
-
if (RANDOM_BUILTINS.has(
|
|
170
|
+
if (STREAMED_BUILTINS.has(target)) row[0] |= STREAMED;
|
|
171
|
+
if (RANDOM_BUILTINS.has(target)) row[0] |= RANDOM;
|
|
172
|
+
if (target === "TLCEval") row[0] |= TLC_EVAL;
|
|
145
173
|
if (!isOverridden && isImpureBuiltin(target, environment)) row[0] |= READS_IMPURE;
|
|
146
174
|
const builtin = environment.builtins.get(target);
|
|
147
175
|
if (
|
|
@@ -155,9 +183,11 @@ const collectLocalFacts = (
|
|
|
155
183
|
}
|
|
156
184
|
}
|
|
157
185
|
}
|
|
158
|
-
getChildren(node).forEach((child) =>
|
|
186
|
+
getChildren(node).forEach((child) =>
|
|
187
|
+
visit(child, isInnerLevelCounted, isOperatorArgument || kind === "Lambda"),
|
|
188
|
+
);
|
|
159
189
|
};
|
|
160
|
-
expressions.forEach((expression) => visit(expression, true));
|
|
190
|
+
expressions.forEach((expression) => visit(expression, true, false));
|
|
161
191
|
return { row, edges };
|
|
162
192
|
};
|
|
163
193
|
|
|
@@ -228,11 +258,12 @@ const closeRows = (local: Uint32Array, words: number, edges: Int32Array[], mask:
|
|
|
228
258
|
return closed;
|
|
229
259
|
};
|
|
230
260
|
|
|
231
|
-
const PURITY_MASK = IMPURE | REPEATED_EFFECT | STREAMED | RANDOM;
|
|
261
|
+
const PURITY_MASK = IMPURE | REPEATED_EFFECT | STREAMED | RANDOM | TLC_EVAL;
|
|
232
262
|
const READ_MASK = NONCONSTANT | READS_IMPURE;
|
|
263
|
+
const STARTUP_MASK = NONCONSTANT | ABOVE_CONSTANT_BOUND;
|
|
233
264
|
|
|
234
265
|
const isEvaluatedOnce = (definition: Definition, flags: number) =>
|
|
235
|
-
definition.kind === "Operator" && definition.params.length === 0 && (flags &
|
|
266
|
+
definition.kind === "Operator" && definition.params.length === 0 && (flags & STARTUP_MASK) === 0;
|
|
236
267
|
|
|
237
268
|
export const createDefinitionFacts = (environment: DefinitionNames): DefinitionFacts => {
|
|
238
269
|
const definitions = [...new Set(environment.definitions.values())];
|
|
@@ -256,18 +287,32 @@ export const createDefinitionFacts = (environment: DefinitionNames): DefinitionF
|
|
|
256
287
|
new Int32Array(own.filter((edge) => !edge.isOverridden && edge.isLevelCounted).map(getId)),
|
|
257
288
|
);
|
|
258
289
|
const levels = closeRows(local, words, levelEdges, TEMPORAL_LEVEL_FLAGS);
|
|
290
|
+
const startupEdges = edges.map(
|
|
291
|
+
(own) =>
|
|
292
|
+
new Int32Array(
|
|
293
|
+
own.filter((edge) => !edge.isOverridden && !edge.isOperatorArgument).map(getId),
|
|
294
|
+
),
|
|
295
|
+
);
|
|
296
|
+
const startup = closeRows(local, words, startupEdges, ABOVE_CONSTANT_BOUND);
|
|
259
297
|
const purityEdges = edges.map(
|
|
260
298
|
(own) =>
|
|
261
299
|
new Int32Array(
|
|
262
300
|
own
|
|
263
301
|
.map(getId)
|
|
264
|
-
.filter(
|
|
302
|
+
.filter(
|
|
303
|
+
(callee) =>
|
|
304
|
+
!isEvaluatedOnce(
|
|
305
|
+
definitions[callee],
|
|
306
|
+
reads[callee * words] | startup[callee * words],
|
|
307
|
+
),
|
|
308
|
+
),
|
|
265
309
|
),
|
|
266
310
|
);
|
|
267
311
|
const purity = closeRows(localImpurity, words, purityEdges, PURITY_MASK);
|
|
268
312
|
const rows = reads.map((word, position) =>
|
|
269
313
|
position % words === 0
|
|
270
314
|
? (word & READ_MASK) |
|
|
315
|
+
(startup[position] & ABOVE_CONSTANT_BOUND) |
|
|
271
316
|
(levels[position] & TEMPORAL_LEVEL_FLAGS) |
|
|
272
317
|
(purity[position] & PURITY_MASK)
|
|
273
318
|
: word,
|
|
@@ -291,6 +336,7 @@ const getExpressionsRow = (expressions: Expression[], environment: Environment)
|
|
|
291
336
|
const callee = getRow(edge.callee, environment);
|
|
292
337
|
if (!edge.isOverridden) {
|
|
293
338
|
row[0] |= callee[0] & READ_MASK;
|
|
339
|
+
if (!edge.isOperatorArgument) row[0] |= callee[0] & ABOVE_CONSTANT_BOUND;
|
|
294
340
|
if (edge.isLevelCounted) row[0] |= callee[0] & TEMPORAL_LEVEL_FLAGS;
|
|
295
341
|
for (let word = 1; word < words; word++) row[word] |= callee[word];
|
|
296
342
|
}
|
|
@@ -300,7 +346,10 @@ const getExpressionsRow = (expressions: Expression[], environment: Environment)
|
|
|
300
346
|
};
|
|
301
347
|
|
|
302
348
|
export const isConstantLevel = (definition: Definition, environment: Environment) =>
|
|
303
|
-
(getRow(definition, environment)[0] &
|
|
349
|
+
(getRow(definition, environment)[0] & STARTUP_MASK) === 0;
|
|
350
|
+
|
|
351
|
+
export const isEvaluatedAtStartup = (definition: Definition, environment: Environment) =>
|
|
352
|
+
(getRow(definition, environment)[0] & ABOVE_CONSTANT_BOUND) === 0;
|
|
304
353
|
|
|
305
354
|
const EFFECT_FLAGS = {
|
|
306
355
|
any: IMPURE,
|
|
@@ -308,6 +357,7 @@ const EFFECT_FLAGS = {
|
|
|
308
357
|
streamed: STREAMED,
|
|
309
358
|
// What a second evaluation shows: output again, or other random draws.
|
|
310
359
|
replayed: REPEATED_EFFECT | RANDOM,
|
|
360
|
+
varying: IMPURE | RANDOM,
|
|
311
361
|
};
|
|
312
362
|
|
|
313
363
|
export const isExpressionImpure = (
|
|
@@ -322,6 +372,9 @@ export const isImpureDefinition = (
|
|
|
322
372
|
effect: keyof typeof EFFECT_FLAGS = "any",
|
|
323
373
|
) => (getRow(definition, environment)[0] & EFFECT_FLAGS[effect]) !== 0;
|
|
324
374
|
|
|
375
|
+
export const isTlcEvalReached = (expression: Expression, environment: Environment) =>
|
|
376
|
+
(getExpressionsRow([expression], environment)[0] & TLC_EVAL) !== 0;
|
|
377
|
+
|
|
325
378
|
export const getDefinitionLevel = (definition: Definition, environment: Environment) => {
|
|
326
379
|
const flags = getRow(definition, environment)[0] & TEMPORAL_LEVEL_FLAGS;
|
|
327
380
|
return flags === TEMPORAL_LEVEL_FLAGS
|