@bramas/simulant-lang 0.0.0-stage → 0.1.0

package/dist/check.js

@@ -0,0 +1,540 @@
+/**
+ * Typechecking and validation of an experiment's IR: types, inference of
+ * nondeterminism (plan 3.1), field ownership (3.5), where parameters may
+ * appear, and the memory model (3.7).
+ */
+import { BUILTINS } from "./builtins.js";
+import { layout } from "./layout.js";
+import { fieldType, isCollection, isData, isStorable, MOVES, resolvePub, showType, T, typeEq, VERDICTS } from "./types.js";
+class CheckError extends Error {
+    node;
+    constructor(message, node) {
+        super(message);
+        this.node = node;
+    }
+}
+/** A literal whose type is still to be inferred: `.ctor`, `none`, `[]`. */
+const isHole = (e) => e.e === 'lit' && e.type.k === 'infer';
+export class Checker {
+    exp;
+    lay;
+    errors = [];
+    diagnostics = [];
+    nondeterministic = new Set();
+    resolutions = new Map();
+    defState = new Map();
+    /** The expressions being inferred, innermost last: errors point at the innermost. */
+    stack = [];
+    /** Enumerations mentioned anywhere in the experiment, for constructors without an expected type. */
+    enums;
+    constructor(exp) {
+        this.exp = exp;
+        this.lay = layout(exp);
+        for (const e of this.lay.errors)
+            this.report(e);
+        this.enums = [T.move, T.verdict, ...enumsIn(exp)];
+    }
+    report(message, node) {
+        this.errors.push(message);
+        this.diagnostics.push({ message, node });
+    }
+    fail(unit, msg) {
+        throw new CheckError(`${unit.where}: ${msg}`, this.stack[this.stack.length - 1]);
+    }
+    /**
+     * Checks a root expression; reports its first error. `hint` guides the
+     * types of literals without requiring the result to have that type.
+     */
+    root(expr, scope, unit, expected, hint) {
+        try {
+            const r = this.infer(expr, new Map(Object.entries(scope)), unit, expected ?? hint);
+            if (expected)
+                this.expect(r.t, expected, unit, 'result');
+            return r;
+        }
+        catch (e) {
+            if (!(e instanceof CheckError))
+                throw e;
+            this.report(e.message, e.node ?? expr);
+        }
+    }
+    /** The type of a literal of type `infer`, from the expected type or a unique constructor. */
+    resolveHole(expr, expected, unit) {
+        const v = expr.value;
+        const ctorsOf = (t) => t.k === 'enum' ? t.ctors : t.k === 'move' ? [...MOVES] : t.k === 'verdict' ? [...VERDICTS] : undefined;
+        let t = expected && expected.k !== 'infer' ? resolvePub(expected, this.lay.pub) : undefined;
+        if (t) {
+            const ok = typeof v === 'string' ? ctorsOf(t)?.includes(v)
+                : v === null ? t.k === 'option' || t.k === 'unit'
+                    : Array.isArray(v) && v.length === 0 && isCollection(t);
+            if (!ok)
+                this.fail(unit, `${showHole(v)} is not a value of type ${showType(t)}`);
+        }
+        else if (typeof v === 'string') {
+            const candidates = this.enums.filter(e => ctorsOf(e).includes(v));
+            const names = [...new Set(candidates.map(showType))];
+            if (!names.length)
+                this.fail(unit, `unknown constructor .${v}`);
+            if (names.length > 1)
+                this.fail(unit, `ambiguous constructor .${v}: it could be ${names.join(' or ')}; write ${names[0]}.${v}`);
+            t = candidates[0];
+        }
+        else {
+            this.fail(unit, `cannot infer the type of ${showHole(v)}; add a type ascription, as in (${showHole(v)} : ${v === null ? 'Option Nat' : 'List Nat'})`);
+        }
+        this.resolutions.set(expr, t);
+        return t;
+    }
+    expect(actual, expected, unit, what) {
+        actual = resolvePub(actual, this.lay.pub);
+        expected = resolvePub(expected, this.lay.pub);
+        if (!typeEq(actual, expected))
+            this.fail(unit, `${what}: expected ${showType(expected)}, got ${showType(actual)}`);
+    }
+    param(name, unit) {
+        if (!['init', 'domain'].includes(unit.ctx))
+            this.fail(unit, `param ${name} is only allowed in initialisation`);
+        const p = this.exp.params.find(p => p.name === name);
+        if (!p)
+            this.fail(unit, `unknown parameter ${name}`);
+        return p.type;
+    }
+    infer(expr, scope, unit, expected) {
+        this.stack.push(expr);
+        try {
+            return this.inferIn(expr, scope, unit, expected);
+        }
+        finally {
+            this.stack.pop();
+        }
+    }
+    /** Infers the types of `exprs` in order, giving holes the type of the first other one (or `expected`). */
+    joined(exprs, scope, unit, expected) {
+        const out = new Array(exprs.length);
+        let t = expected;
+        const order = [...exprs.keys()].sort((a, b) => Number(isHole(exprs[a])) - Number(isHole(exprs[b])));
+        for (const i of order) {
+            out[i] = this.infer(exprs[i], scope, unit, t);
+            t ??= out[i].t;
+        }
+        return out;
+    }
+    inferIn(expr, scope, unit, expected) {
+        const det = (t) => ({ t, nd: false });
+        switch (expr.e) {
+            case 'lit':
+                if (expr.type.k === 'infer')
+                    return det(this.resolveHole(expr, expected, unit));
+                if (expr.type.k === 'node' && !['init', 'domain'].includes(unit.ctx)) {
+                    this.fail(unit, 'node literals are only allowed in initialisation');
+                }
+                return det(expr.type);
+            case 'var': {
+                const t = scope.get(expr.name);
+                if (!t)
+                    this.fail(unit, `unknown variable ${expr.name}`);
+                return det(t);
+            }
+            case 'param':
+                return det(this.param(expr.name, unit));
+            case 'let': {
+                const v = this.infer(expr.value, scope, unit);
+                const b = this.infer(expr.body, new Map(scope).set(expr.name, v.t), unit, expected);
+                return { t: b.t, nd: v.nd || b.nd };
+            }
+            case 'if': {
+                const c = this.infer(expr.cond, scope, unit, T.bool);
+                this.expect(c.t, T.bool, unit, 'condition');
+                const [a, b] = this.joined([expr.then, expr.else], scope, unit, expected);
+                this.expect(b.t, a.t, unit, 'else branch');
+                return { t: a.t, nd: c.nd || a.nd || b.nd };
+            }
+            case 'match': {
+                const on = this.infer(expr.on, scope, unit);
+                const ctors = on.t.k === 'enum' ? on.t.ctors : on.t.k === 'move' ? [...MOVES] : on.t.k === 'verdict' ? [...VERDICTS]
+                    : this.fail(unit, `cannot match on ${showType(on.t)}`);
+                for (const c of Object.keys(expr.cases))
+                    if (!ctors.includes(c))
+                        this.fail(unit, `unknown case ${c} of ${showType(on.t)}`);
+                if (!expr.else && ctors.some(c => !(c in expr.cases)))
+                    this.fail(unit, `non-exhaustive match on ${showType(on.t)}`);
+                const branches = this.joined([...Object.values(expr.cases), ...(expr.else ? [expr.else] : [])], scope, unit, expected);
+                for (const b of branches.slice(1))
+                    this.expect(b.t, branches[0].t, unit, 'match branch');
+                return { t: branches[0].t, nd: on.nd || branches.some(b => b.nd) };
+            }
+            case 'fn':
+                return this.fail(unit, 'a function is only allowed as an argument of a builtin');
+            case 'record': {
+                let nd = false;
+                const target = expected && resolvePub(expected, this.lay.pub);
+                const fields = Object.entries(expr.fields).map(([name, e]) => {
+                    const r = this.infer(e, scope, unit, target ? fieldType(target, name) : undefined);
+                    nd ||= r.nd;
+                    return { name, type: r.t };
+                });
+                return { t: T.record(fields), nd };
+            }
+            case 'with': {
+                const on = this.infer(expr.on, scope, unit);
+                let nd = on.nd;
+                for (const [name, e] of Object.entries(expr.fields)) {
+                    const ft = fieldType(on.t, name) ?? this.fail(unit, `${showType(on.t)} has no field ${name}`);
+                    const r = this.infer(e, scope, unit, ft);
+                    this.expect(r.t, ft, unit, `field ${name}`);
+                    nd ||= r.nd;
+                }
+                return { t: on.t, nd };
+            }
+            case 'get': {
+                // A component reads only its own world fields: `C.world.f`, never `C.world` as a whole.
+                if (unit.owner && expr.on.e === 'get' && expr.on.field === 'world') {
+                    const inner = this.infer(expr.on.on, scope, unit);
+                    if (inner.t.k === 'config') {
+                        const f = this.lay.world.find(f => f.name === expr.field) ?? this.fail(unit, `unknown world field ${expr.field}`);
+                        if (f.owner !== unit.owner)
+                            this.fail(unit, `world field ${expr.field} belongs to ${f.owner}`);
+                        return { t: f.type, nd: inner.nd };
+                    }
+                }
+                const on = this.infer(expr.on, scope, unit);
+                if (unit.owner && on.t.k === 'config' && expr.field === 'world') {
+                    this.fail(unit, 'a component reads world fields one by one (C.world.f)');
+                }
+                return { t: this.field(on.t, expr.field, unit), nd: on.nd };
+            }
+            case 'choose': {
+                const where = { task: 'tasks', algorithm: 'algorithms', domain: 'parameter domains' }[unit.ctx];
+                if (where)
+                    this.fail(unit, `choices are not allowed in ${where}`);
+                const from = this.infer(expr.from, scope, unit);
+                if (!isCollection(from.t))
+                    this.fail(unit, `choose: expected a List or Multiset, got ${showType(from.t)}`);
+                const elem = from.t.of;
+                if (expr.such)
+                    this.lambda(expr.such, [elem], T.bool, scope, unit, 'such');
+                if (expr.label)
+                    this.lambda(expr.label, [elem], T.string, scope, unit, 'label');
+                return { t: elem, nd: true };
+            }
+            case 'effect':
+                return this.effect(expr, scope, unit);
+            case 'call':
+                return this.call(expr, scope, unit, expected);
+        }
+    }
+    field(t, name, unit) {
+        switch (t.k) {
+            case 'record':
+                return fieldType(t, name) ?? this.fail(unit, `${showType(t)} has no field ${name}`);
+            case 'config':
+                if (name === 'world')
+                    return this.lay.worldType;
+                if (name === 'agents')
+                    return T.multiset(T.agent);
+                return this.fail(unit, `a configuration has no field ${name}`);
+            case 'agent': {
+                if (name === 'pos')
+                    return T.node;
+                if (name === 'pub')
+                    return this.lay.pub;
+                if (name === 'mem') {
+                    if (unit.ctx !== 'task')
+                        this.fail(unit, 'the private memory of an agent can only be read by a task');
+                    return this.lay.mem;
+                }
+                const flag = this.lay.flags.find(f => f.name === name);
+                const f = flag ?? this.lay.agentFields.find(f => f.name === name) ?? this.fail(unit, `agents have no field ${name}`);
+                // Components read their own flags and fields; others' only through `correct` and `present`.
+                if (unit.owner && f.owner !== unit.owner)
+                    this.fail(unit, `${flag ? 'flag' : 'agent field'} ${name} belongs to ${f.owner}`);
+                return flag ? T.bool : f.type;
+            }
+            case 'decision': {
+                if (name === 'move')
+                    return T.move;
+                if (name === 'decided')
+                    return T.bool;
+                const a = this.lay.actions.find(a => a.name === name);
+                return a?.type ?? this.fail(unit, `decisions have no action ${name}`);
+            }
+            default:
+                return this.fail(unit, `${showType(t)} has no fields`);
+        }
+    }
+    effect(expr, scope, unit) {
+        if (!['hook', 'beforeMove', 'def'].includes(unit.ctx))
+            this.fail(unit, 'effects are only returned by hooks');
+        let nd = false;
+        for (const [name, e] of Object.entries(expr.world ?? {})) {
+            const f = this.lay.world.find(f => f.name === name) ?? this.fail(unit, `unknown world field ${name}`);
+            if (unit.owner && f.owner !== unit.owner)
+                this.fail(unit, `world field ${name} belongs to ${f.owner}`);
+            const r = this.infer(e, scope, unit, f.type);
+            this.expect(r.t, f.type, unit, `world field ${name}`);
+            nd ||= r.nd;
+        }
+        for (const [name, e] of Object.entries(expr.raise ?? {})) {
+            const f = this.lay.flags.find(f => f.name === name) ?? this.fail(unit, `unknown flag ${name}`);
+            if (unit.owner && f.owner !== unit.owner)
+                this.fail(unit, `flag ${name} belongs to ${f.owner}`);
+            if (e.e === 'fn') {
+                this.lambda(e, [T.agent], T.bool, scope, unit, `raise ${name}`);
+            }
+            else {
+                const r = this.infer(e, scope, unit);
+                if (!(isCollection(r.t) && r.t.of.k === 'agent'))
+                    this.fail(unit, `raise ${name}: expected agents or a predicate on agents`);
+                nd ||= r.nd;
+            }
+        }
+        return { t: T.effect, nd };
+    }
+    /** A deterministic lambda with the given parameter types. Returns its result type. */
+    lambda(e, params, ret, scope, unit, what) {
+        if (e.e !== 'fn')
+            this.fail(unit, `${what}: expected a function`);
+        if (e.params.length !== params.length)
+            this.fail(unit, `${what}: expected ${params.length} parameter(s)`);
+        params = params.map(p => resolvePub(p, this.lay.pub));
+        const inner = new Map(scope);
+        e.params.forEach((p, i) => {
+            if (p.type)
+                this.expect(params[i], p.type, unit, `${what}, parameter ${p.name}`);
+            inner.set(p.name, params[i]);
+        });
+        const body = this.infer(e.body, inner, unit);
+        if (body.nd)
+            this.fail(unit, `${what}: a function passed to a builtin cannot contain choices`);
+        if (ret)
+            this.expect(body.t, ret, unit, what);
+        return body.t;
+    }
+    call(expr, scope, unit, expected) {
+        const sig = BUILTINS[expr.fn];
+        if (!sig)
+            return this.callDef(expr, scope, unit);
+        if (sig.arity !== undefined ? expr.args.length !== sig.arity : expr.args.length === 0) {
+            this.fail(unit, `${expr.fn}: wrong number of arguments`);
+        }
+        if (sig.only && !sig.only.includes(unit.ctx))
+            this.fail(unit, `${expr.fn} is not allowed in a ${unit.ctx}`);
+        if (sig.config && unit.ctx === 'algorithm')
+            this.fail(unit, `${expr.fn}: an algorithm only knows its sensors`);
+        const types = [];
+        let nd = false;
+        // Expected types of arguments, from the other arguments or the expected result.
+        const args = expr.args;
+        const hinted = (i) => {
+            const value = (j) => this.infer(args[j], scope, unit).t;
+            switch (expr.fn) {
+                case 'eq':
+                case 'ne':
+                case 'append':
+                case 'diff':
+                    return isHole(args[i]) && !isHole(args[1 - i]) ? value(1 - i) : expr.fn === 'append' ? expected : undefined;
+                case 'getD': return i === 1 ? optionOf(types[0]) : undefined;
+                case 'mem': return i === 0 && isHole(args[0]) ? elementOf(value(1)) : undefined;
+                case 'some': return optionOf(expected);
+                case 'list': {
+                    const other = args.findIndex(a => !isHole(a));
+                    return elementOf(expected) ?? (isHole(args[i]) && other >= 0 ? value(other) : undefined);
+                }
+                default: return undefined;
+            }
+        };
+        args.forEach((arg, i) => {
+            const lam = sig.lambdas?.[i];
+            if (lam) {
+                const params = lam(types);
+                if (typeof params === 'string')
+                    this.fail(unit, params);
+                const ret = this.lambda(arg, params, undefined, scope, unit, `${expr.fn}, argument ${i + 1}`);
+                types.push(T.fn(params, ret));
+            }
+            else {
+                const r = this.infer(arg, scope, unit, hinted(i));
+                types.push(r.t);
+                nd ||= r.nd;
+            }
+        });
+        const t = sig.ret(types);
+        if (typeof t === 'string')
+            this.fail(unit, t);
+        return { t, nd };
+    }
+    callDef(expr, scope, unit) {
+        const def = unit.defs.get(expr.fn) ?? this.fail(unit, `unknown function ${expr.fn}`);
+        if (expr.args.length !== def.params.length)
+            this.fail(unit, `${expr.fn}: expected ${def.params.length} argument(s)`);
+        let nd = false;
+        expr.args.forEach((arg, i) => {
+            const r = this.infer(arg, scope, unit, def.params[i].type);
+            this.expect(r.t, def.params[i].type, unit, `${expr.fn}, argument ${def.params[i].name}`);
+            nd ||= r.nd;
+        });
+        const body = this.checkDef(def, unit);
+        if (body.nd && ['task', 'algorithm', 'domain'].includes(unit.ctx))
+            this.fail(unit, `${expr.fn} contains choices`);
+        return { t: resolvePub(def.ret, this.lay.pub), nd: nd || body.nd };
+    }
+    checkDef(def, caller) {
+        const state = this.defState.get(def);
+        if (state === 'checking')
+            this.fail(caller, `${def.name} is recursive`);
+        if (state)
+            return state;
+        this.defState.set(def, 'checking');
+        const unit = { ctx: 'def', where: `def ${def.name}`, owner: caller.owner, defs: caller.defs };
+        const r = this.infer(def.body, new Map(def.params.map(p => [p.name, resolvePub(p.type, this.lay.pub)])), unit);
+        this.expect(r.t, def.ret, unit, 'result');
+        this.defState.set(def, r);
+        if (r.nd)
+            this.nondeterministic.add(def.name);
+        return r;
+    }
+    check() {
+        const { exp, lay } = this;
+        const { model, algorithm, task } = exp;
+        const defsOf = (...lists) => new Map(lists.flatMap(l => l ?? []).map(d => [d.name, d]));
+        const modelDefs = defsOf(model.defs);
+        const unit = (ctx, where, defs = modelDefs, owner) => ({ ctx, where, defs, owner });
+        const sensorScope = { C: T.config, me: T.agent, frame: T.frame };
+        for (const p of exp.params) {
+            if (!isStorable(p.type))
+                this.report(`parameter ${p.name}: ${showType(p.type)} cannot be stored`);
+            if (p.domain)
+                this.root(p.domain, {}, unit('domain', `domain of ${p.name}`), T.list(p.type));
+        }
+        this.root(model.topology.size, {}, unit('domain', 'topology size'), T.nat);
+        this.root(exp.agents.count, {}, unit('init', 'agent count'), T.nat);
+        this.root(exp.agents.pos, { i: T.nat }, unit('init', 'agent positions'), T.node);
+        for (const s of model.sensors)
+            this.root(s.body, sensorScope, unit('sensor', `sensor ${s.name}`), s.type);
+        for (const c of model.components) {
+            const defs = defsOf(model.defs, c.defs);
+            const params = Object.fromEntries((c.params ?? []).map(p => [p.name, p.type]));
+            for (const p of c.params ?? []) {
+                if (!isStorable(p.type))
+                    this.report(`${c.name}: parameter ${p.name} cannot be stored`);
+                if (!(p.name in (c.args ?? {})))
+                    this.report(`${c.name}: no value for parameter ${p.name}`);
+            }
+            const sensorScope = { ...params, C: T.config, me: T.agent, frame: T.frame };
+            for (const s of c.sensors ?? [])
+                this.root(s.body, sensorScope, unit('sensor', `${c.name}.${s.name}`, defs, c.name), s.type);
+            for (const f of c.world ?? []) {
+                if (!isStorable(f.type))
+                    this.report(`${c.name}: world field ${f.name} cannot be stored`);
+                const init = c.init?.world?.[f.name];
+                if (!init)
+                    this.report(`${c.name}: world field ${f.name} has no initial value`);
+                else
+                    this.root(init, params, unit('init', `${c.name}.init.${f.name}`, defs, c.name), f.type);
+            }
+            for (const f of c.agent ?? []) {
+                if (!isStorable(f.type))
+                    this.report(`${c.name}: agent field ${f.name} cannot be stored`);
+                const init = c.init?.agent?.[f.name];
+                if (!init)
+                    this.report(`${c.name}: agent field ${f.name} has no initial value`);
+                else
+                    this.root(init, { ...params, i: T.nat }, unit('init', `${c.name}.init.${f.name}`, defs, c.name), f.type);
+            }
+            for (const name of Object.keys(c.init?.world ?? {})) {
+                if (!c.world?.some(f => f.name === name))
+                    this.report(`${c.name}: initial value for unknown world field ${name}`);
+            }
+            for (const name of Object.keys(c.init?.agent ?? {})) {
+                if (!c.agent?.some(f => f.name === name))
+                    this.report(`${c.name}: initial value for unknown agent field ${name}`);
+            }
+            for (const hook of ['beforeLook', 'beforeMove', 'afterMove']) {
+                const body = c[hook];
+                if (body)
+                    this.root(body, { ...params, C: T.config }, unit(hook === 'beforeMove' ? 'beforeMove' : 'hook', `${c.name}.${hook}`, defs, c.name), T.effect);
+            }
+        }
+        if (model.frame.kind === 'persistent') {
+            const name = model.frame.field;
+            const f = lay.agentFields.find(f => f.name === name);
+            if (!f || f.type.k !== 'frame')
+                this.report(`frame model: agent field ${name} of type Frame does not exist`);
+        }
+        // Algorithm: only its sensors; deterministic; memory model.
+        const algDefs = defsOf(model.defs, algorithm.defs);
+        if (!isStorable(algorithm.pub))
+            this.report(`algorithm ${algorithm.name}: public state cannot be stored`);
+        if (!isStorable(algorithm.mem))
+            this.report(`algorithm ${algorithm.name}: memory cannot be stored`);
+        if (model.memory === 'oblivious' && algorithm.mem.k !== 'unit') {
+            this.report(`algorithm ${algorithm.name}: the model is oblivious, but the algorithm keeps memory of type ${showType(algorithm.mem)}`);
+        }
+        this.root(algorithm.init.pub, { i: T.nat }, unit('algorithm', `${algorithm.name}.init.pub`, algDefs), algorithm.pub);
+        this.root(algorithm.init.mem, { i: T.nat }, unit('algorithm', `${algorithm.name}.init.mem`, algDefs), algorithm.mem);
+        if (!algorithm.native) {
+            // A step may omit actions (they keep their defaults): the decision type is only a hint.
+            const step = this.root(algorithm.step, { mem: algorithm.mem, pub: algorithm.pub, view: lay.view }, unit('algorithm', `${algorithm.name}.step`, algDefs), undefined, lay.decision);
+            if (step)
+                this.checkDecision(step.t, `${algorithm.name}.step`);
+        }
+        if (algorithm.line)
+            this.root(algorithm.line, { mem: algorithm.mem }, unit('algorithm', `${algorithm.name}.line`, algDefs), T.nat);
+        this.root(task.verdict, { C: T.config }, unit('task', `task ${task.name}`, defsOf(model.defs, task.defs)), T.verdict);
+        return { errors: this.errors, diagnostics: this.diagnostics, layout: lay, nondeterministic: this.nondeterministic, resolutions: this.resolutions };
+    }
+    /** A step returns `move`, `pub` and `mem`, and possibly some actions. */
+    checkDecision(t, where) {
+        if (t.k !== 'record') {
+            this.report(`${where}: expected a decision record, got ${showType(t)}`);
+            return;
+        }
+        const expected = this.lay.decision;
+        for (const f of t.fields) {
+            const e = expected.fields.find(g => g.name === f.name);
+            if (!e)
+                this.report(`${where}: unknown decision field ${f.name}`);
+            else if (!typeEq(e.type, f.type))
+                this.report(`${where}: decision field ${f.name}: expected ${showType(e.type)}, got ${showType(f.type)}`);
+        }
+        for (const name of ['move', 'pub', 'mem']) {
+            if (!t.fields.some(f => f.name === name))
+                this.report(`${where}: the decision has no ${name}`);
+        }
+    }
+}
+export function check(exp) {
+    if (exp.irVersion !== 1) {
+        const message = `unsupported IR version ${exp.irVersion}`;
+        return { errors: [message], diagnostics: [{ message }], layout: layout(exp), nondeterministic: new Set(), resolutions: new Map() };
+    }
+    return new Checker(exp).check();
+}
+function showHole(v) {
+    return typeof v === 'string' ? `.${v}` : v === null ? 'none' : '[]';
+}
+function optionOf(t) {
+    return t?.k === 'option' ? t.of : undefined;
+}
+function elementOf(t) {
+    return t && isCollection(t) ? t.of : undefined;
+}
+/** Every enumeration type mentioned in the experiment. */
+function enumsIn(exp) {
+    const found = new Map();
+    const visit = (x) => {
+        if (!x || typeof x !== 'object')
+            return;
+        if (Array.isArray(x)) {
+            x.forEach(visit);
+            return;
+        }
+        const o = x;
+        if (o.k === 'enum')
+            found.set(JSON.stringify(o), o);
+        for (const v of Object.values(o))
+            visit(v);
+    };
+    visit(exp);
+    return [...found.values()];
+}