@geastack/compiler 1.0.15

package/dist/ir/hoist.d.ts

@@ -0,0 +1,55 @@
+import type { IrValueId } from '../identity/ids.js';
+import type { IrBlockId, IrBody, IrNonTerminatorOperation } from './model.js';
+/**
+ * Loop-invariant operations, and the block each one moves to.
+ *
+ * `c[i * N + j] += a[i][k] * b[k][j]` recomputes `a[i][k]`, `b[k]` and `i * N`
+ * on every turn of the `j` loop, and no C++ compiler will move them out: an
+ * element read goes through a handle, and a store through another handle may
+ * alias it as far as the optimizer can prove, so the loads have to be repeated.
+ * The compiler that DOES know they are invariant is this one -- the index
+ * expressions name loop variables it can see are not written in the inner loop
+ * -- and hoisting them is what lets clang see a straight-line inner loop it can
+ * then vectorize.
+ *
+ * Two conditions make the move observationally neutral, and both are checked
+ * rather than assumed:
+ *
+ *   - **The loop runs at least once.** Moving a load into the preheader runs
+ *     it even when the body never would, and a load that would not have
+ *     happened can fault. Only a loop whose counter starts at a known constant
+ *     below a known constant bound is hoisted out of.
+ *   - **The operation runs on every iteration.** Its block has to dominate
+ *     every back edge, or the move turns a conditional load into an
+ *     unconditional one -- the same fault, one level in.
+ *
+ * Only operations that read: arithmetic, a cell whose loop writes nothing, and
+ * an Array element load, or native immutable-string length/method reads. Never
+ * a call, a store, a construction, or a property access that could reach an
+ * accessor. Strings need no array-storage alias proof: their values are immutable.
+ */
+export interface HoistPlan {
+    /** Operations to render at the head of a block, in dependency order. */
+    readonly into: ReadonlyMap<IrBlockId, readonly IrNonTerminatorOperation[]>;
+    /** The results of every relocated operation, so its original block skips it. */
+    readonly relocated: ReadonlySet<IrValueId>;
+}
+export declare const emptyHoistPlan: HoistPlan;
+export declare const loopInvariantHoistsOf: (body: IrBody) => HoistPlan;
+/**
+ * The values a loop cannot change: what clang's licm would lift, stated here.
+ *
+ * A value defined where no loop re-enters is invariant by position. Inside a
+ * loop it still is when nothing the loop does can move it: a constant, a formal,
+ * a read of a cell no cyclic block writes, or arithmetic over those. Everything
+ * else -- a merge, a call, a load through a receiver -- is not, and is refused
+ * rather than guessed at, because the caller's transform is only free for a
+ * value that is genuinely computed once.
+ *
+ * This distinction is the whole difference between restating a loop's BOUND and
+ * restating the quantity it is compared against: `x * x + y * y <= 4` in
+ * `mandelbrot.ts` reads two cells the loop writes every iteration, and turning
+ * its left side into an integer bound cost 13% of that fixture before this
+ * existed.
+ */
+export declare const loopInvariantValuesOf: (body: IrBody) => ReadonlySet<IrValueId>;

package/dist/ir/hoist.js

@@ -0,0 +1,375 @@
+import { controlFlowGraphOf, cyclicBlocksOf, dominatorTreeOf, naturalLoopsOf } from './dominance.js';
+import { operandsOfIrOperation, resultOfIrOperation } from './queries.js';
+export const emptyHoistPlan = { into: new Map(), relocated: new Set() };
+/** The operators whose C++ spelling reads nothing and traps on nothing. */
+const pureOperators = new Set([
+    '+',
+    '-',
+    '*',
+    '/',
+    '<',
+    '>',
+    '<=',
+    '>=',
+    '===',
+    '!==',
+    '==',
+    '!=',
+    '&',
+    '|',
+    '^',
+    '<<',
+    '>>',
+    '>>>',
+    '~',
+    '++',
+    '--',
+    // `%` traps on nothing: a narrowed one only ever reaches
+    // `gea::integerRemainder` with a non-zero CONSTANT divisor (the integer
+    // census admits no other), and an unnarrowed one is a double `fmod`.
+    '%'
+]);
+/**
+ * The operation kinds that cannot change what an array answers.
+ *
+ * Deliberately a whitelist: a kind absent here blocks the move, so a kind
+ * added to the IR later is fail-closed rather than silently admitted. `set`,
+ * `convert` and every allocation are out on purpose -- a store writes array
+ * storage, and a conversion of an unknown value can reach user code.
+ */
+const storageNeutralKinds = new Set([
+    'constant',
+    'compute',
+    'binding-read',
+    'binding-write',
+    'parameter',
+    'receiver',
+    'get'
+]);
+export const loopInvariantHoistsOf = (body) => {
+    // A try region renders as one `try { } catch { }` chunk assembled from
+    // several blocks at once, so a relocation into or out of one has no single
+    // place to land. Bodies with a region are left alone entirely.
+    if (body.tryRegions.length > 0 || (body.iteratorCloseRegions?.length ?? 0) > 0)
+        return emptyHoistPlan;
+    const graph = controlFlowGraphOf(body);
+    const dominance = dominatorTreeOf(body);
+    const loops = naturalLoopsOf(graph, dominance);
+    if (loops.length === 0)
+        return emptyHoistPlan;
+    const constants = new Map();
+    const constantTexts = new Map();
+    const cellWrites = new Map();
+    const readsCell = new Map();
+    const location = new Map();
+    const operationOf = new Map();
+    const conditionOf = new Map();
+    for (const blockId of body.blockOrder) {
+        const block = body.blocks.get(blockId);
+        if (!block)
+            continue;
+        if (block.terminator.kind === 'branch')
+            conditionOf.set(blockId, block.terminator.condition.value);
+        for (const operation of block.operations) {
+            const result = 'result' in operation ? operation.result : null;
+            if (result) {
+                location.set(result.id, blockId);
+                operationOf.set(result.id, operation);
+            }
+            if (operation.kind === 'constant')
+                constantTexts.set(operation.result.id, operation.text);
+            if (operation.kind === 'constant' && operation.literal === 'number') {
+                const value = Number(operation.text);
+                if (Number.isFinite(value))
+                    constants.set(operation.result.id, value);
+            }
+            if (operation.kind === 'binding-read')
+                readsCell.set(operation.result.id, operation.declaration);
+            if (operation.kind === 'binding-write') {
+                const written = cellWrites.get(operation.declaration) ?? [];
+                written.push({ value: operation.value, block: blockId });
+                cellWrites.set(operation.declaration, written);
+            }
+        }
+    }
+    // Local closure allocation can expose bindings to writes in another body.
+    // IR allocation operands alone do not carry the emitter's complete capture
+    // layout. Until that proof is published here, keep local reads in place in
+    // bodies that create closures/constructors; SSA parameters remain eligible.
+    const mayCaptureLocals = [...operationOf.values()].some((operation) => operation.kind === 'allocate-callable' || operation.kind === 'allocate-constructor');
+    /** The number this value always holds, through at most one single-assignment cell. */
+    const knownNumber = (value) => {
+        const literal = constants.get(value);
+        if (literal !== undefined)
+            return literal;
+        const cell = readsCell.get(value);
+        if (cell === undefined)
+            return null;
+        const written = cellWrites.get(cell) ?? [];
+        const only = written.length === 1 ? written[0] : undefined;
+        return only ? (constants.get(only.value.value) ?? null) : null;
+    };
+    /**
+     * Whether this loop's first test is known to pass.
+     *
+     * The counter's seed and the bound both have to be constants, and the seed
+     * has to satisfy the test. Anything less is a loop that might run zero times,
+     * and its preheader is not a place a load may be moved to.
+     */
+    const entersAtLeastOnce = (header, blocks) => {
+        const condition = conditionOf.get(header);
+        if (condition === undefined)
+            return false;
+        const test = operationOf.get(condition);
+        if (test?.kind !== 'compute' || test.form !== 'binary')
+            return false;
+        const ascending = test.operator === '<' || test.operator === '<=';
+        const descending = test.operator === '>' || test.operator === '>=';
+        if (!ascending && !descending)
+            return false;
+        const [left, right] = test.operands;
+        if (!left || !right)
+            return false;
+        const bound = knownNumber(right.value);
+        if (bound === null)
+            return false;
+        const counter = readsCell.get(left.value);
+        if (counter === undefined)
+            return false;
+        // Every write outside the loop is a seed; each one has to be a constant
+        // that passes the test, because any of them could be the value the loop
+        // starts from.
+        const seeds = (cellWrites.get(counter) ?? []).filter((write) => !blocks.has(write.block));
+        if (seeds.length === 0)
+            return false;
+        return seeds.every((seed) => {
+            const start = constants.get(seed.value.value);
+            if (start === undefined)
+                return false;
+            if (test.operator === '<')
+                return start < bound;
+            if (test.operator === '<=')
+                return start <= bound;
+            if (test.operator === '>')
+                return start > bound;
+            return start >= bound;
+        });
+    };
+    /** The single entry into this loop from outside it. */
+    const preheaderOf = (header, blocks) => {
+        const outside = (graph.predecessors.get(header) ?? []).filter((predecessor) => !blocks.has(predecessor));
+        return outside.length === 1 ? (outside[0] ?? null) : null;
+    };
+    const dominatesEveryLatch = (blockId, header, blocks, tree) => (graph.predecessors.get(header) ?? []).every((latch) => !blocks.has(latch) || tree.dominates(blockId, latch));
+    /**
+     * Whether running this operation where it never would have run can fault.
+     *
+     * Only an element LOAD can: its index is a value the loop computed, and off
+     * the end of the storage is a read of memory the array does not own. A
+     * `length` read, a cell read and arithmetic all answer from something that
+     * already exists, so running one an extra time costs a few instructions and
+     * changes nothing -- which is what lets them leave a loop whose trip count is
+     * a parameter nobody can bound. Those loops are most of them: `for (let i =
+     * 0; i < iterations; i++)` is the shape of every fixture's outer loop, and
+     * requiring the entry proof for a `ring.length` read left it inside.
+     */
+    const immutableStringRead = (operation) => operation.kind === 'get' &&
+        operation.receiver.representation.kind === 'string' &&
+        ['length', 'charCodeAt'].includes(constantTexts.get(operation.key.value) ?? '');
+    const mayFault = (operation) => operation.kind === 'get' && !immutableStringRead(operation) && constantTexts.get(operation.key.value) !== 'length';
+    /**
+     * Whether anything inside this loop can change what an array answers.
+     *
+     * A `get` on an `array-object` is invariant only while its STORAGE is, and the
+     * operand check below proves something strictly weaker: that the HANDLE is
+     * defined outside the loop. `wanted.length` in
+     *
+     *     while (wanted.length > 0) { ...; wanted.splice(best, 1) }
+     *
+     * passes the operand check -- it is the same array every turn -- and hoisting
+     * it froze the loop's own condition at the value it had before the loop began.
+     * Measured on `examples/apps/maps`: the `while`'s test AND the inner
+     * `for (j = 1; j < wanted.length; j++)` bound were both computed once in the
+     * preheader, and the app aborted on its first frame reading `grid[11]` of an
+     * eleven-element array.
+     *
+     * So the storage has to be proved unmodified, and what proves it here is a
+     * body that writes no array at all: `push`/`splice`/`pop` are CALLS, and a
+     * call may reach any array the program can name -- including one this loop
+     * never spells, which is why the check is not narrowed to the receiver. The
+     * cost is that a loop which stores into one array no longer hoists a load out
+     * of another; regaining that needs an alias proof (distinct allocation sites),
+     * not a weaker invariance test.
+     */
+    const mutatesArrayStorage = (blocks) => {
+        for (const blockId of blocks) {
+            const block = body.blocks.get(blockId);
+            if (!block)
+                continue;
+            for (const operation of block.operations) {
+                if (!storageNeutralKinds.has(operation.kind))
+                    return true;
+            }
+        }
+        return false;
+    };
+    /** Answered once per loop: the walk is over every operation the loop owns. */
+    const arrayStorageMutated = new Map();
+    const relocated = new Set();
+    const into = new Map();
+    /** Whether this operation reads only, and reads only things that cannot move. */
+    const isPureRead = (operation, blocks) => {
+        if (operation.kind === 'constant')
+            return true;
+        if (operation.kind === 'compute') {
+            if (!pureOperators.has(operation.operator))
+                return false;
+            // Only a non-zero constant divisor: a narrowed `%` becomes an integer
+            // division, and moving one whose divisor could be zero would move a trap.
+            return true;
+        }
+        if (operation.kind === 'binding-read') {
+            if (mayCaptureLocals)
+                return false;
+            // Invariant only while the loop writes the cell nowhere.
+            return (cellWrites.get(operation.declaration) ?? []).every((write) => !blocks.has(write.block));
+        }
+        if (operation.kind === 'get') {
+            // Array elements and immutable string builtins: a record or class receiver can
+            // reach an accessor, which is a call, and a call is not something this
+            // may run an extra time or in a different order.
+            return operation.receiver.representation.kind === 'array-object' || immutableStringRead(operation);
+        }
+        return false;
+    };
+    const operandsOf = (operation) => {
+        if (operation.kind === 'compute')
+            return operation.operands;
+        if (operation.kind === 'get')
+            return [operation.receiver, operation.key];
+        return [];
+    };
+    for (let moving = true; moving;) {
+        moving = false;
+        for (const loop of loops) {
+            const preheader = preheaderOf(loop.header, loop.blocks);
+            if (preheader === null)
+                continue;
+            const entered = entersAtLeastOnce(loop.header, loop.blocks);
+            for (const blockId of body.blockOrder) {
+                if (!loop.blocks.has(blockId))
+                    continue;
+                if (!dominatesEveryLatch(blockId, loop.header, loop.blocks, dominance))
+                    continue;
+                const block = body.blocks.get(blockId);
+                if (!block)
+                    continue;
+                // Everything that renders here NOW: what the block owns, plus whatever
+                // an inner loop already moved in. The second half is what lets an
+                // operation invariant in two nested loops travel all the way out --
+                // it lands in the inner preheader on one round and leaves it on the
+                // next.
+                for (const operation of [...(into.get(blockId) ?? []), ...block.operations]) {
+                    const result = 'result' in operation ? operation.result : null;
+                    if (!result)
+                        continue;
+                    if (location.get(result.id) !== blockId)
+                        continue;
+                    if (!isPureRead(operation, loop.blocks))
+                        continue;
+                    if (mayFault(operation) && !entered)
+                        continue;
+                    // An element load and a `length` read both answer from storage this
+                    // loop may rewrite. `isPureRead` proved the handle invariant; this
+                    // proves the bytes behind it are too.
+                    if (operation.kind === 'get' && !immutableStringRead(operation)) {
+                        const mutated = arrayStorageMutated.get(loop.header) ?? mutatesArrayStorage(loop.blocks);
+                        arrayStorageMutated.set(loop.header, mutated);
+                        if (mutated)
+                            continue;
+                    }
+                    // A cell read moved ahead of the loop has to name a cell something
+                    // already assigned; a write that only happens AFTER the loop leaves
+                    // the variable uninitialized at the new position.
+                    if (operation.kind === 'binding-read') {
+                        const written = cellWrites.get(operation.declaration) ?? [];
+                        if (!written.some((write) => dominance.dominates(write.block, preheader)))
+                            continue;
+                    }
+                    const invariant = operandsOf(operation).every((operand) => {
+                        const where = location.get(operand.value);
+                        return where === undefined || !loop.blocks.has(where);
+                    });
+                    if (!invariant)
+                        continue;
+                    relocated.add(result.id);
+                    const previous = into.get(blockId);
+                    if (previous)
+                        into.set(blockId, previous.filter((held) => held !== operation));
+                    location.set(result.id, preheader);
+                    const landing = into.get(preheader) ?? [];
+                    landing.push(operation);
+                    into.set(preheader, landing);
+                    moving = true;
+                }
+            }
+        }
+    }
+    return { into, relocated };
+};
+/**
+ * The values a loop cannot change: what clang's licm would lift, stated here.
+ *
+ * A value defined where no loop re-enters is invariant by position. Inside a
+ * loop it still is when nothing the loop does can move it: a constant, a formal,
+ * a read of a cell no cyclic block writes, or arithmetic over those. Everything
+ * else -- a merge, a call, a load through a receiver -- is not, and is refused
+ * rather than guessed at, because the caller's transform is only free for a
+ * value that is genuinely computed once.
+ *
+ * This distinction is the whole difference between restating a loop's BOUND and
+ * restating the quantity it is compared against: `x * x + y * y <= 4` in
+ * `mandelbrot.ts` reads two cells the loop writes every iteration, and turning
+ * its left side into an integer bound cost 13% of that fixture before this
+ * existed.
+ */
+export const loopInvariantValuesOf = (body) => {
+    const cyclic = cyclicBlocksOf(body);
+    const invariant = new Set();
+    const pending = [];
+    const writtenInLoop = new Set();
+    for (const id of body.blockOrder) {
+        const block = body.blocks.get(id);
+        if (block === undefined)
+            continue;
+        for (const operation of block.operations) {
+            if (operation.kind === 'binding-write' && cyclic.has(id))
+                writtenInLoop.add(operation.declaration);
+            const result = resultOfIrOperation(operation);
+            if (result === null)
+                continue;
+            if (!cyclic.has(id))
+                invariant.add(result.id);
+            else
+                pending.push(operation);
+        }
+    }
+    let growing = true;
+    while (growing) {
+        growing = false;
+        for (const operation of pending) {
+            const result = resultOfIrOperation(operation);
+            if (result === null || invariant.has(result.id))
+                continue;
+            const stable = operation.kind === 'constant' ||
+                operation.kind === 'parameter' ||
+                (operation.kind === 'binding-read' && !writtenInLoop.has(operation.declaration)) ||
+                (operation.kind === 'compute' && operandsOfIrOperation(operation).every((operand) => invariant.has(operand.value)));
+            if (!stable)
+                continue;
+            invariant.add(result.id);
+            growing = true;
+        }
+    }
+    return invariant;
+};

package/dist/ir/instantiation.d.ts

@@ -0,0 +1,61 @@
+import type { DeclarationId, FunctionId, RegionId } from '../identity/ids.js';
+import type { IrBody } from './model.js';
+/**
+ * What a class's construction is made of, as the two questions below need it.
+ *
+ * A projection of `ClassLayout` rather than the layout itself, so this stays a
+ * fact about the IR: the bodies construction runs, and the class it inherits
+ * them from. `targets/cpp/translation-unit.ts` adapts the real layouts.
+ */
+export interface ClassConstruction {
+    readonly base: DeclarationId | null;
+    /** The written constructor's body, or `null` for the implicit one. */
+    readonly constructor: FunctionId | null;
+    /** One body per field declared WITH an initializer; a bare declaration runs nothing. */
+    readonly initializers: readonly FunctionId[];
+}
+/**
+ * The two whole-program answers below, carried together because they are only
+ * ever useful together: a construction may go when nothing observes it AND the
+ * callee it was manufactured for ignores it.
+ */
+export interface InstantiationFacts {
+    readonly receiverIgnoringFunctions: ReadonlySet<FunctionId | RegionId>;
+    readonly unobservableConstructions: ReadonlySet<DeclarationId>;
+}
+/** Nothing known: every construction observable, every function assumed to read its receiver. */
+export declare const noInstantiationFacts: InstantiationFacts;
+/**
+ * Which functions never name their receiver.
+ *
+ * A gea component is a class whose render method is the whole of it, and the
+ * render of a component with no state reads `this` nowhere -- yet the call site
+ * still has to hand it one, so a `construct` runs to manufacture a receiver the
+ * callee ignores. `examples/apps/weather` builds 12 of them, all at mount, each
+ * a `makeRef` plus a walk of its field initializers, for an argument no body
+ * reads.
+ *
+ * A body names its receiver iff it holds a `receiver` operation -- deliberately
+ * regardless of whether that operation's own result is read, because the answer
+ * decides whether the ARGUMENT may be dropped and a body that loads `this` only
+ * to discard it is not worth a second census. Answered per `sourceOwner` rather
+ * than per body: monomorphization gives one function several bodies, and a
+ * function qualifies only when EVERY copy of it ignores the receiver.
+ */
+export declare const functionsIgnoringTheirReceiver: (bodies: readonly IrBody[]) => ReadonlySet<FunctionId | RegionId>;
+/**
+ * Which classes can be constructed without any observable consequence, so a
+ * `construct` whose result nothing reads may be deleted whole.
+ *
+ * A construction runs, in order: the base chain's initialization, this class's
+ * field initializers, and its constructor body. Every one of those is a real
+ * body that may call, throw, or write to something that outlives the object --
+ * a field initialized to `registry.push(this)` is observable no matter how dead
+ * the instance is. So the answer is the conjunction over the whole chain, and a
+ * body this compilation cannot see at all is a `no`.
+ *
+ * The receiver of each such body is the object under construction, which is why
+ * `unobservableInInitialization` admits writes through it: at that point the
+ * object is reachable from nothing else.
+ */
+export declare const classesConstructedUnobservably: (classes: ReadonlyMap<DeclarationId, ClassConstruction>, bodies: readonly IrBody[]) => ReadonlySet<DeclarationId>;

package/dist/ir/instantiation.js

@@ -0,0 +1,137 @@
+import { operandsOfIrOperation } from './queries.js';
+/** Nothing known: every construction observable, every function assumed to read its receiver. */
+export const noInstantiationFacts = { receiverIgnoringFunctions: new Set(), unobservableConstructions: new Set() };
+/**
+ * Which functions never name their receiver.
+ *
+ * A gea component is a class whose render method is the whole of it, and the
+ * render of a component with no state reads `this` nowhere -- yet the call site
+ * still has to hand it one, so a `construct` runs to manufacture a receiver the
+ * callee ignores. `examples/apps/weather` builds 12 of them, all at mount, each
+ * a `makeRef` plus a walk of its field initializers, for an argument no body
+ * reads.
+ *
+ * A body names its receiver iff it holds a `receiver` operation -- deliberately
+ * regardless of whether that operation's own result is read, because the answer
+ * decides whether the ARGUMENT may be dropped and a body that loads `this` only
+ * to discard it is not worth a second census. Answered per `sourceOwner` rather
+ * than per body: monomorphization gives one function several bodies, and a
+ * function qualifies only when EVERY copy of it ignores the receiver.
+ */
+export const functionsIgnoringTheirReceiver = (bodies) => {
+    const naming = new Set();
+    const owners = new Set();
+    for (const body of bodies) {
+        owners.add(body.sourceOwner);
+        for (const block of body.blocks.values())
+            for (const operation of block.operations)
+                if (operation.kind === 'receiver')
+                    naming.add(body.sourceOwner);
+    }
+    const ignoring = new Set();
+    for (const owner of owners)
+        if (!naming.has(owner))
+            ignoring.add(owner);
+    return ignoring;
+};
+const primitiveKinds = new Set(['scalar', 'string', 'null', 'undefined', 'symbol']);
+/**
+ * Whether this operation, inside a body that is building a brand-new object, is
+ * one no other code can observe.
+ *
+ * Narrower than `dead-values.ts`'s `isEffectFree`, and not shared with it: that
+ * predicate answers "may this statement be deleted", which is a question about
+ * one operation. This one answers "may the whole construction be deleted",
+ * which is a question about everything the construction reaches -- so a `call`
+ * is refused here even though its result may be dead, and a `set` is admitted
+ * only into the object under construction, which nothing else can see yet.
+ */
+const unobservableInInitialization = (operation, receivers) => {
+    switch (operation.kind) {
+        case 'constant':
+        case 'binding-read':
+        case 'parameter':
+        case 'receiver':
+        case 'phi':
+        case 'allocate-record':
+        case 'allocate-array-object':
+        case 'allocate-callable':
+            return true;
+        case 'compute':
+        case 'convert':
+        case 'test':
+            return operandsOfIrOperation(operation).every((operand) => primitiveKinds.has(operand.representation.kind));
+        // A write into the object being built, and only that: the object has not
+        // escaped yet, so nobody can read what this wrote. A write through any
+        // other receiver is a real effect and disqualifies the construction.
+        case 'set':
+        case 'define-own-property':
+            return receivers.has(operation.receiver.value);
+        default:
+            return false;
+    }
+};
+/**
+ * Which classes can be constructed without any observable consequence, so a
+ * `construct` whose result nothing reads may be deleted whole.
+ *
+ * A construction runs, in order: the base chain's initialization, this class's
+ * field initializers, and its constructor body. Every one of those is a real
+ * body that may call, throw, or write to something that outlives the object --
+ * a field initialized to `registry.push(this)` is observable no matter how dead
+ * the instance is. So the answer is the conjunction over the whole chain, and a
+ * body this compilation cannot see at all is a `no`.
+ *
+ * The receiver of each such body is the object under construction, which is why
+ * `unobservableInInitialization` admits writes through it: at that point the
+ * object is reachable from nothing else.
+ */
+export const classesConstructedUnobservably = (classes, bodies) => {
+    const byOwner = new Map();
+    for (const body of bodies)
+        byOwner.set(body.sourceOwner, [...(byOwner.get(body.sourceOwner) ?? []), body]);
+    const quiet = new Map();
+    const bodyIsQuiet = (fn) => {
+        const known = quiet.get(fn);
+        if (known !== undefined)
+            return known;
+        // Recursion through a field initializer that constructs its own class
+        // would ask this question of itself; `false` while it is in flight makes
+        // the fixed point terminate on the safe side.
+        quiet.set(fn, false);
+        const found = byOwner.get(fn) ?? [];
+        const answer = found.length > 0 &&
+            found.every((body) => {
+                const receivers = new Set();
+                for (const block of body.blocks.values())
+                    for (const operation of block.operations)
+                        if (operation.kind === 'receiver')
+                            receivers.add(operation.result.id);
+                return [...body.blocks.values()].every((block) => block.terminator.kind !== 'throw' && block.operations.every((operation) => unobservableInInitialization(operation, receivers)));
+            });
+        quiet.set(fn, answer);
+        return answer;
+    };
+    const answers = new Map();
+    const isQuiet = (declaration) => {
+        const known = answers.get(declaration);
+        if (known !== undefined)
+            return known;
+        answers.set(declaration, false);
+        const construction = classes.get(declaration);
+        // A class this unit holds no construction for: its bodies are elsewhere,
+        // and an answer about code nobody here can read is not an answer.
+        if (construction === undefined)
+            return false;
+        const answer = (construction.base === null || isQuiet(construction.base)) &&
+            construction.initializers.every(bodyIsQuiet) &&
+            (construction.constructor === null || bodyIsQuiet(construction.constructor));
+        answers.set(declaration, answer);
+        return answer;
+    };
+    const unobservable = new Set();
+    for (const declaration of classes.keys())
+        if (isQuiet(declaration))
+            unobservable.add(declaration);
+    return unobservable;
+};